I Python er række af flyder værdier afhænger af implementeringen og platformen. Python-sprogspecifikationen kræver kun det flydende komma tal understøtter mindst 1e-308 til 1e+308 med en præcision på mindst 53 bit .
I praksis bruger de fleste moderne Python-implementeringer IEEE 754 floating-point standard, som giver en rækkevidde på ca 1.7e-308 til 1,7e+308 med en præcision på 53 bit . Dette sortiment er det samme på alle platforme og understøttes af float indbygget type.
Det er dog vigtigt at bemærke, at aritmetik med flydende komma er underlagt afrundingsfejl og andre kilder til unøjagtighed, især når du udfører operationer på meget store eller meget små tal. Det kan i nogle tilfælde føre til uventet adfærd og fejl.
For at undgå disse problemer anbefales det ofte at bruge decimal eller fast punkt aritmetik, når du arbejder med pengeværdier eller andre applikationer, der kræver høj præcision. Det decimalmodul i Python giver understøttelse af fastpunkts-aritmetik med konfigurerbar præcision og er et godt alternativ til flydende-komma-aritmetik til disse applikationer.
hvordan man konverterer streng til heltal
Det IEEE 754 standard definerer rækkevidden og præcisionen af flydende kommatal, der bruges af de fleste moderne programmeringssprog, inklusive Python. Standarden definerer to grundlæggende formater for flydende kommatal:
Det bruger 32 bit og giver ca 7 decimaler præcisionscifre.
Det bruger 64 bit og giver ca 16 decimaler præcisionscifre.
Python bruger dobbelt præcision flydende kommatal som standard, hvilket betyder, at intervallet af flydende værdier er ca 1.7e-308 til 1,7e+308 med en præcision på 53 bit . Dette interval bestemmes af de maksimale og minimale eksponenter, der kan repræsenteres ved hjælp af 11 bits , kombineret med de maksimale og minimale signifikander (dvs. brøkdelen af tallet), der kan repræsenteres ved hjælp af 52 bit .
Den faktiske præcision af flydende komma-aritmetik kan påvirkes af mange faktorer, herunder den måde, tal gemmes i hukommelsen, rækkefølgen af operationer og valget af afrundingstilstand. Det kan i nogle tilfælde føre til subtile afrundingsfejl og andre kilder til unøjagtighed.
For at undgå disse problemer anbefales det ofte at bruge alternative tilgange, når der arbejdes med meget store eller meget små tal, eller når der kræves høj præcision. For eksempel:
- Brug fastpunktsregning eller decimalregning , som giver et fast antal decimaler med præcision og undgår afrundingsfejl.
- Brug vilkårlig-præcision biblioteker som 'mpmath' eller 'gmpy2' , som giver dig mulighed for at udføre beregninger med meget høj præcision og undgå afrundingsfejl.
Et vigtigt aspekt at bemærke er, at når du udfører aritmetiske operationer på flydende-komma-tal i Python, kan du støde på noget uventet adfærd på grund af den måde, flydende-komma-aritmetik fungerer.
Nogle aritmetiske operationer kan resultere i meget små eller meget store tal, der ikke kan repræsenteres præcist ved hjælp af flydende komma-aritmetik. I disse tilfælde kan resultatet blive afrundet eller afkortet , hvilket fører til uventet adfærd eller unøjagtigheder i dine beregninger.
Flydende komma aritmetik er ikke associativ , hvilket betyder, at den rækkefølge, du udfører handlinger i, kan påvirke resultatet. For eksempel, (a + b) + c kan ikke være lig med a + (b + c) på grund af afrundingsfejl og andre kilder til unøjagtighed.
Flydende komma aritmetik er heller ikke distributive , hvilket betyder at (a + b) * c kan ikke være lig med a * c + b * c på grund af afrundingsfejl og andre kilder til unøjagtighed. For at minimere virkningen af disse problemer, anbefales det ofte at bruge matematikmodulet eller andre numeriske biblioteker, der giver funktioner til at udføre aritmetiske operationer på flydende kommatal på en mere præcis og pålidelig måde. Det er også en god praksis at undgå at sammenligne flydende kommatal for lighed, og i stedet bruge en tolerancetærskel eller andre metoder til at sammenligne størrelsen af forskellen mellem to værdier.
Eksempel:
Lad os tage et eksempel for at vise hvordan flydende-komma-aritmetik kan føre til uventet adfærd i python:
a = 0.1 b = 0.2 c = 0.3 result1 = (a + b) + c result2 = a + (b + c) print(result1) print(result2)
Produktion:
0.6000000000000001 0.6
Forklaring:
I dette eksempel udfører vi to forskellige beregninger med de samme værdier af a, b, og c . I den første beregning tilføjer vi -en og b først, og føje derefter resultatet til c . I den anden beregning tilføjer vi b og c først, og føje derefter resultatet til -en .
Vi kan forvente, at de to beregninger giver det samme resultat, da de bruger de samme værdier af a, b , og c . Men på grund af begrænsningerne ved flydende komma-aritmetik giver de to beregninger lidt forskellige resultater.
Den første beregning giver et resultat af 0,60000000000000001 , mens den anden beregning giver et resultat af 0,6 . Det skyldes, at de mellemliggende resultater af den første beregning er lidt anderledes end de mellemliggende resultater af den anden beregning, på grund af afrundingsfejl og andre kilder til unøjagtighed.
For at undgå disse problemer anbefales det ofte at bruge decimalmodul eller andre metoder til at udføre aritmetiske operationer på flydende komma tal på en mere præcis og pålidelig måde.
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)
Produktion:
0.6 0.6
Forklaring:
I dette eksempel bruger vi decimalmodul at udføre de samme beregninger vha fast punkt aritmetik med en præcision på 1 decimalplads. Det giver os mulighed for at undgå de afrundingsfejl og andre kilder til unøjagtighed, der kan påvirke flydende komma aritmetik. Som et resultat giver begge beregninger det samme resultat af 0,6 .