A Python, el rang de flotació els valors depèn de la implementació i de la plataforma. L'especificació del llenguatge Python només ho requereix punt flotant els números admeten almenys 1e-308 a 1e+308 amb una precisió d'almenys 53 bits .
A la pràctica, la majoria de les implementacions modernes de Python utilitzen el IEEE 754 estàndard de coma flotant, que proporciona un rang d'aproximadament 1.7e-308 a 1.7e+308 amb una precisió de 53 bits . Aquest rang és el mateix a totes les plataformes i és compatible amb el tipus flotant integrat.
Tanmateix, és important tenir en compte que l'aritmètica de coma flotant està subjecta a errors d'arrodoniment i altres fonts d'imprecisió, especialment quan es realitzen operacions amb nombres molt grans o molt petits. En alguns casos, pot provocar un comportament inesperat i errors.
Per evitar aquests problemes, sovint es recomana utilitzar-lo decimal o punt fix aritmètica quan es treballa amb valors monetaris o altres aplicacions que requereixen alta precisió. El mòdul decimal a Python ofereix suport per a l'aritmètica de coma fix amb precisió configurable i és una bona alternativa a l'aritmètica de coma flotant per a aquestes aplicacions.
factorial al c
El IEEE 754 L'estàndard defineix el rang i la precisió dels nombres de coma flotant utilitzats per la majoria dels llenguatges de programació moderns, inclòs Python. L'estàndard defineix dos formats bàsics per als números de coma flotant:
S'utilitza 32 bits i ofereix aproximadament 7 decimals dígits de precisió.
S'utilitza 64 bits i ofereix aproximadament 16 decimals dígits de precisió.
Python utilitza doble precisió nombres de coma flotant per defecte, el que significa que l'interval de valors flotants és aproximadament 1.7e-308 a 1.7e+308 amb una precisió de 53 bits . Aquest rang ve determinat pels exponents màxim i mínim que es poden representar utilitzant 11 bits , combinat amb els significats màxim i mínim (és a dir, la part de la fracció del nombre) que es poden representar mitjançant 52 bits .
La precisió real de l'aritmètica de coma flotant es pot veure afectada per molts factors, inclosa la forma en què s'emmagatzemen els nombres a la memòria, l'ordre de les operacions i l'elecció del mode d'arrodoniment. En alguns casos, pot provocar errors d'arrodoniment subtils i altres fonts d'imprecisió.
Per evitar aquests problemes, sovint es recomana utilitzar enfocaments alternatius quan es treballa amb números molt grans o molt petits, o quan es requereix una alta precisió. Per exemple:
- Ús aritmètica de punt fix o aritmètica decimal , que proporciona un nombre fix de decimals de precisió i evita errors d'arrodoniment.
- Ús precisió arbitrària biblioteques com 'mpmath' o 'gmpy2' , que permeten realitzar càlculs amb molt alta precisió i evitar errors d'arrodoniment.
Un aspecte important a tenir en compte és que quan es realitzen operacions aritmètiques sobre nombres de coma flotant a Python, és possible que trobeu un comportament inesperat a causa de la manera com funciona l'aritmètica de coma flotant.
Algunes operacions aritmètiques poden donar lloc a nombres molt petits o molt grans que no es poden representar amb precisió mitjançant l'aritmètica de coma flotant. En aquests casos, el resultat pot ser arrodonida o truncada , provocant un comportament inesperat o imprecisions en els vostres càlculs.
Aritmètica de coma flotant no és associatiu , el que significa que l'ordre en què realitzeu les operacions pot afectar el resultat. Per exemple, (a + b) + c pot no ser igual a a + (b + c) a causa d'errors d'arrodoniment i altres fonts d'imprecisió.
L'aritmètica de coma flotant tampoc ho és distributiu , que vol dir que (a + b) * c pot no ser igual a a * c + b * c a causa d'errors d'arrodoniment i altres fonts d'imprecisió. Per minimitzar l'impacte d'aquests problemes, sovint es recomana utilitzar el mòdul de matemàtiques o altres biblioteques numèriques que proporcionen funcions per realitzar operacions aritmètiques sobre nombres de coma flotant d'una manera més precisa i fiable. També és una bona pràctica evitar la comparació de nombres de coma flotant per a la igualtat i, en canvi, utilitzar un llindar de tolerància o altres mètodes per comparar la magnitud de la diferència entre dos valors.
Exemple:
Prenguem un exemple per mostrar com aritmètica de coma flotant pot provocar un comportament inesperat a Python:
a = 0.1 b = 0.2 c = 0.3 result1 = (a + b) + c result2 = a + (b + c) print(result1) print(result2)
Sortida:
0.6000000000000001 0.6
Explicació:
En aquest exemple, estem realitzant dos càlculs diferents utilitzant els mateixos valors de a, b, i c . En el primer càlcul, sumem a i b primer i després afegiu-hi el resultat c . En el segon càlcul, sumem b i c primer i després afegiu-hi el resultat a .
Podríem esperar que els dos càlculs produeixin el mateix resultat, ja que utilitzen els mateixos valors de a, b , i c . Tanmateix, a causa de les limitacions de l'aritmètica de coma flotant, els dos càlculs produeixen resultats lleugerament diferents.
El primer càlcul produeix un resultat de 0.6000000000000001 , mentre que el segon càlcul produeix un resultat de 0.6 . És perquè els resultats intermedis del primer càlcul són lleugerament diferents dels resultats intermedis del segon càlcul, a causa dels errors d'arrodoniment i altres fonts d'imprecisió.
Per evitar aquests problemes, sovint es recomana utilitzar el mòdul decimal o altres mètodes de realització operacions aritmètiques activat punt flotant números d'una manera més precisa i fiable.
Per exemple:
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)
Sortida:
0.6 0.6
Explicació:
En aquest exemple, fem servir el mòdul decimal per realitzar els mateixos càlculs utilitzant punt fix aritmètica amb una precisió de 1 xifra decimal. Ens permet evitar els errors d'arrodoniment i altres fonts d'imprecisió que poden afectar punt flotant aritmètica. Com a resultat, ambdós càlculs produeixen el mateix resultat de 0.6 .