In Python wordt de bereik van vlotter waarden zijn afhankelijk van de implementatie en het platform. De Python-taalspecificatie vereist alleen dat drijvende komma cijfers ondersteunen tenminste 1e-308 naar 1e+308 met een nauwkeurigheid van minstens 53 bits .
In de praktijk gebruiken de meeste moderne Python-implementaties de IEEE 754 drijvende-kommastandaard, die een bereik biedt van ongeveer 1.7e-308 naar 1,7e+308 met een nauwkeurigheid van 53 bits . Dit bereik is op alle platforms hetzelfde en wordt ondersteund door het float-inbouwtype.
Het is echter belangrijk op te merken dat de rekenkunde met drijvende komma onderhevig is aan afrondingsfouten en andere bronnen van onnauwkeurigheid, vooral bij het uitvoeren van bewerkingen op zeer grote of zeer kleine getallen. Het kan in sommige gevallen tot onverwacht gedrag en bugs leiden.
Om deze problemen te voorkomen, wordt het vaak aanbevolen om te gebruiken decimale of vast punt rekenkunde bij het werken met geldwaarden of andere toepassingen die hoge precisie vereisen. De decimale module in Python biedt ondersteuning voor rekenkunde met vaste komma met configureerbare precisie en is voor deze toepassingen een goed alternatief voor rekenkunde met drijvende komma.
datumtekenreeks java
De IEEE 754 standaard definieert het bereik en de precisie van getallen met drijvende komma die worden gebruikt door de meeste moderne programmeertalen, waaronder Python. De standaard definieert twee basisformaten voor getallen met drijvende komma:
Het gebruikt 32 bits en levert ongeveer 7 decimaal cijfers van precisie.
Het gebruikt 64 bits en levert ongeveer 16 decimaal cijfers van precisie.
Python gebruikt dubbele precisie Standaard drijvende-kommagetallen, wat betekent dat het bereik van zwevende waarden ongeveer is 1.7e-308 naar 1,7e+308 met een nauwkeurigheid van 53 bits . Dit bereik wordt bepaald door de maximale en minimale exponenten die kunnen worden weergegeven met behulp van 11 bits , gecombineerd met de maximale en minimale significanden (dat wil zeggen het breukdeel van het getal) die kunnen worden weergegeven met 52 bits .
De feitelijke nauwkeurigheid van drijvende-kommaberekeningen kan door veel factoren worden beïnvloed, waaronder de manier waarop getallen in het geheugen worden opgeslagen, de volgorde van bewerkingen en de keuze van de afrondingsmodus. In sommige gevallen kan dit tot subtiele afrondingsfouten en andere bronnen van onnauwkeurigheid leiden.
Om deze problemen te voorkomen, wordt vaak aanbevolen om alternatieve benaderingen te gebruiken wanneer u met zeer grote of zeer kleine aantallen werkt, of wanneer hoge precisie vereist is. Bijvoorbeeld:
- Gebruik rekenkunde met een vast punt of decimale rekenkunde , dat een vast aantal decimalen voor nauwkeurigheid biedt en afrondingsfouten voorkomt.
- Gebruik willekeurige precisie bibliotheken zoals 'mpmath' of 'gmpy2' , waarmee u berekeningen met zeer hoge nauwkeurigheid kunt uitvoeren en afrondingsfouten kunt voorkomen.
Een belangrijk aspect om op te merken is dat bij het uitvoeren van rekenkundige bewerkingen op getallen met drijvende komma in Python, je onverwacht gedrag kunt tegenkomen vanwege de manier waarop berekeningen met drijvende komma werken.
Sommige rekenkundige bewerkingen kunnen resulteren in zeer kleine of zeer grote getallen die niet nauwkeurig kunnen worden weergegeven met behulp van drijvende-kommaberekeningen. In deze gevallen kan het resultaat zijn afgerond of afgeknot , wat leidt tot onverwacht gedrag of onnauwkeurigheden in uw berekeningen.
Rekenkunde met drijvende komma is niet associatief , wat betekent dat de volgorde waarin u bewerkingen uitvoert het resultaat kan beïnvloeden. Bijvoorbeeld, (a + b) + c kan niet gelijk zijn aan een + (b + c) als gevolg van afrondingsfouten en andere bronnen van onnauwkeurigheid.
Drijvende-kommaberekeningen zijn dat ook niet distributief , wat betekent dat (a + b) * c kan niet gelijk zijn aan een * c + b * c als gevolg van afrondingsfouten en andere bronnen van onnauwkeurigheid. Om de impact van deze problemen te minimaliseren, wordt het vaak aanbevolen om de wiskundemodule of andere numerieke bibliotheken te gebruiken die functies bieden voor het uitvoeren van rekenkundige bewerkingen op getallen met drijvende komma op een nauwkeurigere en betrouwbaardere manier. Het is ook een goede gewoonte om het vergelijken van getallen met drijvende komma op gelijkheid te vermijden, en in plaats daarvan een tolerantiedrempel of andere methoden te gebruiken om de grootte van het verschil tussen twee waarden te vergelijken.
Voorbeeld:
Laten we een voorbeeld nemen om te laten zien hoe rekenkunde met drijvende komma kan leiden tot onverwacht gedrag in Python:
a = 0.1 b = 0.2 c = 0.3 result1 = (a + b) + c result2 = a + (b + c) print(result1) print(result2)
Uitgang:
0.6000000000000001 0.6
Uitleg:
In dit voorbeeld voeren we twee verschillende berekeningen uit met dezelfde waarden van een, b, En C . In de eerste berekening voegen we toe A En B eerst en voeg vervolgens het resultaat toe C . In de tweede berekening voegen we toe B En C eerst en voeg vervolgens het resultaat toe A .
We zouden kunnen verwachten dat de twee berekeningen hetzelfde resultaat opleveren, omdat ze dezelfde waarden gebruiken van een, b , En C . Vanwege de beperkingen van de drijvende-kommaberekening leveren de twee berekeningen echter enigszins verschillende resultaten op.
De eerste berekening levert een resultaat op van 0,6000000000000001 , terwijl de tweede berekening een resultaat oplevert van 0,6 . Dit komt doordat de tussenresultaten van de eerste berekening enigszins afwijken van de tussenresultaten van de tweede berekening, als gevolg van afrondingsfouten en andere bronnen van onnauwkeurigheid.
Om deze problemen te voorkomen, wordt vaak aanbevolen om de decimale module of andere uitvoeringsmethoden rekenkundige bewerkingen op drijvende komma cijfers nauwkeuriger en betrouwbaarder te verwerken.
Bijvoorbeeld:
import decimal a = decimal.Decimal('0.1') b = decimal.Decimal('0.2') c = decimal.Decimal('0.3') result1 = (a + b) + c result2 = a + (b + c) print(result1) print(result2)
Uitgang:
0.6 0.6
Uitleg:
In dit voorbeeld gebruiken we de decimale module om dezelfde berekeningen uit te voeren met vast punt rekenen met een nauwkeurigheid van 1 decimale plaats. Het stelt ons in staat afrondingsfouten en andere bronnen van onnauwkeurigheid die van invloed kunnen zijn, te vermijden drijvende komma rekenkundig. Als gevolg hiervan leveren beide berekeningen hetzelfde resultaat op 0,6 .