I Python, den utbud av flottör värden beror på implementeringen och plattformen. Python-språkspecifikationen kräver bara det flytpunkt siffror stöder åtminstone 1e-308 till 1e+308 med en precision av minst 53 bitar .
I praktiken använder de flesta moderna Python-implementeringar IEEE 754 flyttalsstandard, vilket ger en räckvidd på ungefär 1.7e-308 till 1,7e+308 med en precision av 53 bitar . Detta sortiment är detsamma på alla plattformar och stöds av float-inbyggd typ.
Det är dock viktigt att notera att aritmetik med flyttal är föremål för avrundningsfel och andra källor till oprecision, speciellt när man utför operationer på mycket stora eller mycket små tal. Det kan leda till oväntat beteende och buggar i vissa fall.
För att undvika dessa problem rekommenderas det ofta att använda decimal eller fast punkt aritmetik när man arbetar med penningvärden eller andra tillämpningar som kräver hög precision. De decimalmodul i Python ger stöd för aritmetik med fast punkt med konfigurerbar precision och är ett bra alternativ till aritmetik med flyttal för dessa applikationer.
r på c-språk
De IEEE 754 standarden definierar intervallet och precisionen för flyttalstal som används av de flesta moderna programmeringsspråk, inklusive Python. Standarden definierar två grundläggande format för flyttal:
Det använder 32 bitar och ger ungefär 7 decimaler precisionssiffror.
Det använder 64 bitar och ger ungefär 16 decimaler precisionssiffror.
Python använder Dubbel precision flyttalstal som standard, vilket betyder att intervallet för flytvärden är ungefärligt 1.7e-308 till 1,7e+308 med en precision av 53 bitar . Detta intervall bestäms av de maximala och lägsta exponenter som kan representeras med hjälp av 11 bitar , kombinerat med de maximala och lägsta signifikanserna (d.v.s. bråkdelen av talet) som kan representeras med hjälp av 52 bitar .
Den faktiska precisionen i flyttalsaritmetiken kan påverkas av många faktorer, inklusive hur siffror lagras i minnet, operationsordningen och valet av avrundningsläge. Det kan leda till subtila avrundningsfel och andra källor till oprecision i vissa fall.
För att undvika dessa problem rekommenderas det ofta att använda alternativa tillvägagångssätt när man arbetar med mycket stora eller mycket små tal, eller när hög precision krävs. Till exempel:
- Använda sig av aritmetik med fast punkt eller decimalaritmetik , som ger ett fast antal decimaler med precision och undviker avrundningsfel.
- Använda sig av godtycklig precision bibliotek som 'mpmath' eller 'gmpy2' , som gör att du kan utföra beräkningar med mycket hög precision och undvika avrundningsfel.
En viktig aspekt att notera är att när du utför aritmetiska operationer på flyttalsnummer i Python, kan du stöta på något oväntat beteende på grund av hur flyttalsaritmetik fungerar.
Vissa aritmetiska operationer kan resultera i mycket små eller mycket stora tal som inte kan representeras exakt med flyttalsaritmetik. I dessa fall kan resultatet bli avrundad eller stympad , vilket leder till oväntat beteende eller felaktigheter i dina beräkningar.
Flyttalsarithmetik är inte associativ , vilket innebär att ordningen du utför operationer i kan påverka resultatet. Till exempel, (a + b) + c kanske inte är lika med a + (b + c) på grund av avrundningsfel och andra källor till oprecision.
Flyttalsaritmetik är det inte heller distributiv , vilket betyder att (a + b) * c kanske inte är lika med a * c + b * c på grund av avrundningsfel och andra källor till oprecision. För att minimera effekterna av dessa problem, rekommenderas det ofta att använda matematikmodulen eller andra numeriska bibliotek som tillhandahåller funktioner för att utföra aritmetiska operationer på flyttalstal på ett mer exakt och tillförlitligt sätt. Det är också en god praxis att undvika att jämföra flyttalstal för likhet, och istället använda en toleranströskel eller andra metoder för att jämföra storleken på skillnaden mellan två värden.
Exempel:
Låt oss ta ett exempel för att visa hur aritmetik med flyttal kan leda till oväntat beteende 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
Förklaring:
I det här exemplet utför vi två olika beräkningar med samma värden på a, b, och c . I den första beräkningen lägger vi till a och b först och lägg sedan till resultatet c . I den andra beräkningen lägger vi till b och c först och lägg sedan till resultatet a .
Vi kan förvänta oss att de två beräkningarna ger samma resultat, eftersom de använder samma värden på a, b , och c . Men på grund av flyttalsaritmetikens begränsningar ger de två beräkningarna något olika resultat.
Den första beräkningen ger ett resultat av 0,6000000000000001 , medan den andra beräkningen ger ett resultat av 0,6 . Det beror på att de mellanliggande resultaten av den första beräkningen skiljer sig något från de mellanliggande resultaten av den andra beräkningen, på grund av avrundningsfel och andra källor till inexakthet.
För att undvika dessa problem rekommenderas det ofta att du använder decimalmodul eller andra metoder för att utföra aritmetiska operationer på flytpunkt siffror på ett mer exakt och tillförlitligt sätt.
Till exempel:
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
Förklaring:
I det här exemplet använder vi decimalmodul att utföra samma beräkningar med hjälp av fast punkt aritmetik med en precision på 1 decimaler. Det tillåter oss att undvika de avrundningsfel och andra källor till oprecision som kan påverka flytpunkt aritmetisk. Som ett resultat ger båda beräkningarna samma resultat av 0,6 .