I Python er rekkevidde av flyte verdier avhenger av implementeringen og plattformen. Python-språkspesifikasjonen krever bare det flytende punkt tall støtter minst 1e-308 til 1e+308 med en presisjon på minst 53 biter .
I praksis bruker de fleste moderne Python-implementeringer IEEE 754 flytepunktstandard, som gir en rekkevidde på ca 1.7e-308 til 1,7e+308 med en presisjon på 53 biter . Denne rekkevidden er den samme på alle plattformer og støttes av typen flytende innebygd.
Det er imidlertid viktig å merke seg at flytende-komma-aritmetikk er gjenstand for avrundingsfeil og andre kilder til unøyaktighet, spesielt når du utfører operasjoner på svært store eller svært små tall. Det kan føre til uventet oppførsel og feil i noen tilfeller.
For å unngå disse problemene, anbefales det ofte å bruke desimal eller fast punkt aritmetikk når du arbeider med pengeverdier eller andre applikasjoner som krever høy presisjon. De desimalmodul i Python gir støtte for fastpunkt-aritmetikk med konfigurerbar presisjon og er et godt alternativ til flytepunkt-aritmetikk for disse applikasjonene.
lære selen
De IEEE 754 standard definerer rekkevidden og presisjonen til flyttall som brukes av de fleste moderne programmeringsspråk, inkludert Python. Standarden definerer to grunnleggende formater for flytende tall:
Det bruker 32 biter og gir ca 7 desimaler sifre med presisjon.
Det bruker 64 biter og gir ca 16 desimaler sifre med presisjon.
Python bruker dobbel presisjon flytende kommatall som standard, noe som betyr at området for flyteverdier er omtrentlig 1.7e-308 til 1,7e+308 med en presisjon på 53 biter . Dette området bestemmes av maksimums- og minimumseksponentene som kan representeres ved hjelp av 11 biter , kombinert med maksimums- og minimumsignifikandene (dvs. brøkdelen av tallet) som kan representeres ved å bruke 52 biter .
Den faktiske presisjonen til flytepunktaritmetikk kan påvirkes av mange faktorer, inkludert måten tall lagres i minnet, rekkefølgen på operasjoner og valg av avrundingsmodus. Det kan i noen tilfeller føre til subtile avrundingsfeil og andre kilder til unøyaktighet.
For å unngå disse problemene, anbefales det ofte å bruke alternative tilnærminger når du arbeider med svært store eller svært små tall, eller når det kreves høy presisjon. For eksempel:
- Bruk fastpunktsregning eller desimalregning , som gir et fast antall desimaler med presisjon og unngår avrundingsfeil.
- Bruk vilkårlig-presisjon biblioteker liker 'mpmath' eller 'gmpy2' , som lar deg utføre beregninger med svært høy presisjon og unngå avrundingsfeil.
Et viktig aspekt å merke seg er at når du utfører aritmetiske operasjoner på flyttall i Python, kan du støte på noe uventet oppførsel på grunn av måten flytepunktsregning fungerer.
Noen aritmetiske operasjoner kan resultere i svært små eller veldig store tall som ikke kan representeres nøyaktig ved bruk av flytende kommaaritmetikk. I disse tilfellene kan resultatet bli avrundet eller avkortet , som fører til uventet oppførsel eller unøyaktigheter i beregningene dine.
Flytende aritmetikk er ikke assosiativ , som betyr at rekkefølgen du utfører operasjoner i kan påvirke resultatet. For eksempel, (a + b) + c kan ikke være lik a + (b + c) på grunn av avrundingsfeil og andre kilder til unøyaktighet.
Flytepunkt-aritmetikk er det heller ikke distributive , som betyr at (a + b) * c kan ikke være lik a * c + b * c på grunn av avrundingsfeil og andre kilder til unøyaktighet. For å minimere virkningen av disse problemene, anbefales det ofte å bruke matematikkmodulen eller andre numeriske biblioteker som gir funksjoner for å utføre aritmetiske operasjoner på flyttall på en mer presis og pålitelig måte. Det er også en god praksis å unngå å sammenligne flyttall for likhet, og i stedet bruke en toleranseterskel eller andre metoder for å sammenligne størrelsen på forskjellen mellom to verdier.
Eksempel:
La oss ta et eksempel for å vise hvordan flytekomma-aritmetikk kan føre til uventet oppførsel i python:
a = 0.1 b = 0.2 c = 0.3 result1 = (a + b) + c result2 = a + (b + c) print(result1) print(result2)
Produksjon:
0.6000000000000001 0.6
Forklaring:
I dette eksemplet utfører vi to forskjellige beregninger med de samme verdiene av a, b, og c . I den første beregningen legger vi til en og b først, og legg deretter resultatet til c . I den andre beregningen legger vi til b og c først, og legg deretter resultatet til en .
Vi kan forvente at de to beregningene gir samme resultat, siden de bruker de samme verdiene av a, b , og c . På grunn av begrensningene til flytepunktaritmetikk gir de to beregningene imidlertid litt forskjellige resultater.
Den første beregningen gir et resultat av 0,6000000000000001 , mens den andre beregningen gir et resultat av 0,6 . Det er fordi de mellomliggende resultatene av den første beregningen er litt forskjellige fra de mellomliggende resultatene i den andre beregningen, på grunn av avrundingsfeil og andre kilder til unøyaktighet.
For å unngå disse problemene, anbefales det ofte å bruke desimalmodul eller andre metoder for å utføre aritmetiske operasjoner på flytende punkt tall på en mer presis og pålitelig måte.
For eksempel:
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)
Produksjon:
0.6 0.6
Forklaring:
I dette eksemplet bruker vi desimalmodul å utføre de samme beregningene ved hjelp av fast punkt aritmetikk med en presisjon på 1 desimalpunkt. Det lar oss unngå avrundingsfeil og andre kilder til unøyaktighet som kan påvirke flytende punkt aritmetikk. Som et resultat gir begge beregningene det samme resultatet av 0,6 .