Flyttal i Python: En Djupdykning
En av de mest grundläggande datatyperna i Python är float, som används för att representera flyttal. Flyttal är tal, oavsett om de är positiva eller negativa, som inkluderar en decimaldel. Denna datatyp omfattar också tal i vetenskaplig notation, där bokstaven ’e’ eller ’E’ indikerar en potens av 10.
Float-datatyper är av stor betydelse, eftersom de kan hantera ett brett spektrum av reella tal, från mycket små till mycket stora värden.
Nedan följer exempel på flyttal i Python:
# Exempel på flyttal
a = 20.0
b = -51.51345
c = 65e7
d = -1.08E12
e = 2E10
print(type(a))
print(type(b))
print(type(c))
print(type(d))
print(type(e))
Utskrift:
<class 'float'>
<class 'float'>
<class 'float'>
<class 'float'>
<class 'float'>
Jämfört med heltalstyper, som avlägsnar decimaldelen av ett tal, tillåter flyttal mer exakta beräkningar. Ett tal som 3,142 skulle med heltal representeras som 3, medan flyttalsrepresentationen behåller det faktiska värdet 3,142. Detta gör flyttal mer lämpade för matematiska beräkningar som kräver noggrannhet.
Flyttal används flitigt inom områden som verklighetsmodellering, maskininlärning, datavetenskap, finansiell analys, matematiska beräkningar, grafisk visualisering samt vetenskapliga och tekniska beräkningar.
Heltal kontra Flyttal i Python
Heltal är en annan vanlig datatyp i Python. Till skillnad från flyttal har de ingen decimaldel. Heltal omfattar positiva heltal, negativa heltal och noll. I Python betecknas heltalsvärden med ’int’.
Heltal är användbara vid operationer som involverar räkning eller indexering. Några exempel på heltal är:
a = 0
b = 968
c = -14
print(type(a))
print(type(b))
print(type(c))
Utskrift:
<class 'int'>
<class 'int'>
<class 'int'>
Här följer en sammanfattning av skillnaderna mellan heltal och flyttal:
| Egenskap | Heltal (int) | Flyttal (float) |
| Representation | Heltal, deras negativa motsvarigheter, och noll, alla utan decimaler. | Reella tal med en decimalpunkt. |
| Precision | Obegränsad precision; den enda begränsningen är tillgängligt minne. | Begränsad precision; det största möjliga flyttalet är ungefär 1.8 x 10308. |
| Minnesanvändning | Använder mindre minne än flyttal. | Använder mer minne än heltal. |
| Bitvisa operationer | Används ofta i bitvisa operationer. | Används sällan i bitvisa operationer. |
| Användning | Används för räkning, indexering och bitvisa operationer. | Används i mätningar, beräkningar och matematiska operationer. |
Skapa och Använda Flyttal i Python
Det enklaste sättet att använda flyttal är genom att tilldela en variabel ett flyttalsvärde, till exempel:
# Tilldela en variabel ett flyttalsvärde
a = 3.142
Du kan även konvertera heltal eller numeriska strängar till flyttal med funktionen float(). Om du skickar ett heltal eller en numerisk sträng till float(), kommer det att omvandlas till ett flyttalsvärde, som visas nedan:
number1 = 2524
numString1 = "513.523"
numString2 = "1341"
# Konvertera till flyttal och lagra
a = float(number1)
print(a)
b = float(numString1)
print(b)
c = float(numString2)
print(c)
Utskrift:
2524.0
513.523
1341.0
I exemplet ovan omvandlas heltal och strängar till flyttal med hjälp av float() och lagras sedan i variabler, vilket visas i den resulterande utskriften.
Flyttal kan också erhållas genom matematiska operationer, som division, vilket visas nedan:
num1 = 20
num2 = 3
result = num1/num2
print("Resultatet av division som heltal:")
print(int(20/3))
print("Resultatet av division som flyttal:")
print(result)
print(type(result))
Utskrift:
Resultatet av division som heltal:
6
Resultatet av division som flyttal:
6.666666666666667
<class 'float'>
Som exemplet visar ger flyttal ett mer exakt resultat än heltalsdivision.
När man arbetar med flyttal i Python kan oväntade resultat uppstå på grund av hur flyttal internt representeras i datorer. Flyttal representeras som binära bråktal (bas 2). De flesta decimala bråktal, särskilt de med återkommande decimaler, kan inte representeras exakt som binära bråktal. Därför lagras flyttal vanligtvis som en approximation av det faktiska värdet.
För att illustrera detta, tänk på flyttalet 0,3. Internt kommer det inte att lagras som exakt 0,3. Genom att använda format()-funktionen kan vi se hur 0,3 lagras internt med 20 signifikanta siffror:
num = 0.3
print("num med 20 signifikanta siffror")
print(format(num, '.20f'))
print("Värdet lagrat i num")
print(num)
Utskrift:
num med 20 signifikanta siffror
0.29999999999999998890
Värdet lagrat i num
0.3
Detta visar att det tilldelade värdet 0,3 inte lagras internt som exakt 0,3. När variabeln ’num’ skrivs ut, visas ett avrundat värde.
Detta kan leda till oväntade resultat. Till exempel, 0,3 + 0,3 + 0,3 borde manuellt ge 0,9, men i Python blir resultatet inte exakt 0,9, som du kan se i följande exempel:
sum = 0.3 + 0.3 + 0.3
answer = 0.9
print("Är summan lika med svaret: ")
print(sum == answer)
print("Den interna representationen av summan är: ")
print(sum)
print("Svaret från manuell beräkning är: ")
print(answer)
Utskrift:
Är summan lika med svaret:
False
Den interna representationen av summan är:
0.8999999999999999
Svaret från manuell beräkning är:
0.9
Därför är det viktigt att komma ihåg att Python lagrar approximationer av flyttalsvärden internt. Vid jämförelser av flyttal bör du runda av värdena till samma antal decimaler. För högre precision kan du använda den inbyggda decimal-modulen.
Decimalmodulen i Python
I situationer där hög noggrannhet är kritisk, som inom ekonomi eller vetenskapliga beräkningar, är det inte idealiskt att använda float. decimal-modulen garanterar högre noggrannhet genom att lagra flyttal med en maskinoberoende decimalbaserad representation.
Modulen kan hantera decimaltal exakt som de är och ger korrekt avrundad flyttalsaritmetik.
För att börja använda decimalmodulen, importera den:
import decimal
För att se fördelarna med decimal-modulen, utför vi samma jämförelse som tidigare, men med modulen:
import decimal
sum = decimal.Decimal('0.3') + decimal.Decimal('0.3') + decimal.Decimal('0.3')
answer = decimal.Decimal('0.9')
print("Är summan lika med svaret: ")
print(sum == answer)
print("Den interna representationen av summan är: ")
print(sum)
print("Svaret från manuell beräkning är: ")
print(answer)
Utskrift:
Är summan lika med svaret:
True
Den interna representationen av summan är:
0.9
Svaret från manuell beräkning är:
0.9
När du arbetar med flyttal och behöver hög precision, rekommenderas att använda decimal-modulen.
Vanliga Fel vid Användning av Flyttal
Många av de fel som uppstår med flyttal i Python beror på bristande förståelse för hur flyttal representeras internt. Som sagt lagras inte ett värde som 0,3 exakt som 0,3. Detta kan leda till oväntade fel om du antar att flyttal lagras exakt.
Ett vanligt fel är avrundningsfel, som uppstår när man utför matematiska beräkningar med flyttal. Eftersom Python inte kan representera alla flyttal exakt, kan resultaten skilja sig från vad man förväntar sig.
På grund av dessa fel kan det vara riskabelt att göra likhetsjämförelser direkt mellan flyttal. Var försiktig när du använder flyttal, eftersom resultaten kan vara oväntade.
För att undvika fel relaterade till flyttal, bör du överväga att använda decimal-modulen. Detta ger mer förutsägbara och exakta resultat vid flyttalsberäkningar.
Sammanfattning
Som programmerare i Python kommer du att använda flyttal. För att undvika fel är det viktigt att förstå hur Python representerar dem internt. Eftersom Python inte lagrar flyttal exakt, bör du undvika exakta likhetsjämförelser direkt mellan flyttal för att förhindra fel.
Om hög precision är viktig, använd decimal-modulen för korrekta resultat. Denna modul representerar flyttal exakt och ger maskinoberoende beräkningar.
Läs gärna även om Python Itertools funktioner och Python Try Except.