Konvertering av datatyper i Python: en guide med exempel

I exemplet adderades ett heltalsvärde a_int till ett flyttalsvärde b_float, och resultatet konverterades automatiskt till ett flyttalsvärde c_sum utan att du behövde tala om det för kompilatorn. Detta är implicit datakonvertering.

Varför konverterades inte flyttalsvärdet till ett heltal i stället?

Detta beror på ett bredare begrepp inom datavetenskap som kallas typfrämjande. Enkelt uttryckt är detta en försvarsmekanism hos kompilatorn som låter dig utföra operationer när det är möjligt genom att konvertera din data till en annan supertyp utan att förlora information.

Det betyder att konverteringen från flyttal till heltal inte görs eftersom kompilatorn då skulle behöva ta bort bråkdelen, vilket leder till informationsförlust.

Explicit konvertering av datatyper i Python

Explicit konvertering av datatyper, ofta kallad typomvandling (type casting), sker när du medvetet konverterar ett värde från en datatyp till en annan. Detta tillvägagångssätt ger dig direkt kontroll över konverteringen, eftersom du uttryckligen anger måldatatypen i din kod. Det används ofta när den automatiska (implicita) konverteringen som Python erbjuder inte uppfyller dina behov.

Syntaxen för explicit konvertering är:

target_data_type(expression)

Om du till exempel vill konvertera ett flyttal till ett heltal skriver du:

int(3.14)  # Converts 3.14 to 3

Observera: Även om explicita konverteringar är mycket användbara kan de leda till informationsförlust. Till exempel kommer konvertering av ett flyttal till ett heltal att kasta bort bråkdelen. Det är viktigt att förstå dessa konsekvenser för att undvika oavsiktliga resultat i dina program.

Låt oss utforska några vanligt förekommande explicita konverteringar av datatyper.

Primitiva kontra icke-primitiva datastrukturer i Python

Primitiva datastrukturer är byggstenarna för datamanipulation och innehåller rena, enkla datavärden. Python har fyra primitiva variabeltyper:

• Heltal
• Flyttal
• Strängar
• Boolean

Icke-primitiva datastrukturer lagrar inte bara ett värde utan snarare en samling värden i olika format. I Python har du följande icke-primitiva datastrukturer:

• Listor
• Tupler
• Ordböcker
• Mängder

Du kan lära dig mer om dem i DataCamps Data Structures in Python Tutorial.

Konverteringar för primitiva datastrukturer

Konverteringar mellan heltal och flyttal i Python

Heltal och flyttal är datatyper som hanterar tal.

För att konvertera ett heltal till ett flyttal använder du funktionen float() i Python. På samma sätt kan du använda funktionen int() om du vill konvertera ett flyttal till ett heltal.

a_int = 3
b_int = 2

# Explicit typkonvertering från int till float
c_float_sum = float(a_int + b_int)
print(c_float_sum)

5.0

a_float = 3.3
b_float = 2.0

# Explicit typkonvertering från float till int
c_int_sum = int(a_float + b_float)
print(c_int_sum)

c_float_sum = a_float + b_float
print(c_float_sum)

5
5.3

Problem med flyttalsprecision och Decimal-modulen

Aritmetik med flyttal i Python kan leda till precisionsproblem:

print(0.1 + 0.2)  # Output: 0.30000000000000004

För att undvika detta, använd modulen Decimal:

from decimal import Decimal

print(Decimal('0.1') + Decimal('0.2'))  # Output: 0.3

Konvertering från reella tal till komplexa tal i Python

Du kan konvertera heltal till komplexa tal med complex(real,imag). Den kräver två heltal (reella och imaginära tal) och konverterar reella tal till komplexa tal.

real = 2
imag = 5
print(complex(real, imag))

(2+5j)

Konvertering av datatyper med strängar i Python

En sträng är en samling av ett eller flera tecken (bokstäver, siffror, symboler). Du kan behöva konvertera strängar till tal eller tal till strängar ganska ofta.

price_cake = 15
price_cookie = 6
total = price_cake + price_cookie
print("The total is: " + total  + "$")

 
---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-12-54bd76b9b4bd> in <module>()
      2 price_cookie = 6
      3 total = price_cake + price_cookie
----> 4 print("The total is: " + total  + "$")


TypeError: Can't convert 'int' object to str implicitly

Exemplet ovan ger ett TypeError som informerar om att kompilatorn inte kan konvertera ett heltalsvärde till en sträng implicit.

Vad programmet borde göra här kan verka intuitivt för dig. Men kompilatorn är inte alltid säker och tillhandahåller därför en mekanism med explicit typomvandling så att du tydligt kan ange vad du vill. Så här kan du konvertera ett heltal till en sträng i Python med funktionen str():

price_cake = 15
price_cookie = 6
total = price_cake + price_cookie
print("The total is: " + str(total)  + "$")

The total is: 21$

Det fungerar på samma sätt när du konverterar flyttal till strängar.

I Python kan du också konvertera strängar till heltals- och flyttalsvärden när det är möjligt. Låt oss se vad detta innebär:

price_cake = '15'
price_cookie = '6'

# Strängkonkatenering
total = price_cake + price_cookie
print("The total is: " + total + "$")

# Explicit typkonvertering till heltal
total = int(price_cake) + int(price_cookie)
print("The total is: " + str(total)  + "$")

The total is: 156$
The total is: 21$

Låt oss gå igenom koden.

price_cake och price_cookie är initialt strängar. Sedan behöver du räkna ut totalen, vilket innebär att de först måste konverteras till motsvarande heltalsvärden. Annars antar kompilatorn att den operation du vill göra är strängkonkatenering snarare än numerisk addition. Du behöver sedan placera detta värde i den slutliga visningssträngen och alltså konvertera totalen till en sträng för att kunna sammanfoga den med resten av meddelandet.

Förhoppningsvis hjälper detta exempel dig att se vikten av konverteringar av datatyper. Även om detta är ett mycket litet exempel kan du redan se hur användbart det kan vara.

Obs: lade du märke till "när det är möjligt" när vi konverterar en sträng till heltal eller flyttal? Detta beror på att det inte alltid är möjligt att konvertera strängar till tal och tillämpa numeriska operationer på dem. Kompilatorn är medveten om detta och ger dig därför ett fel när du försöker göra det. Se exemplet nedan:

price_cake = 'fifteen'
price_cookie = 'six'
total = int(price_cake) + int(price_cookie)

---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

<ipython-input-25-80591b8accda> in <module>()
      1 price_cake = 'fifteen'
      2 price_cookie = 'six'
----> 3 total = int(price_cake) + int(price_cookie)


ValueError: invalid literal for int() with base 10: 'fifteen'

Sammanfattning: Konverteringar av primitiva datatyper i Python

Icke-primitiva datastrukturer: konverteringar

Typkonvertering till tupler och listor i Python

Precis som med heltal och flyttal kan du också konvertera listor till tupler och tupler till listor.

Kommer du ihåg vad tupler och listor är? Listor och tupler i Python används för att lagra en samling homogena objekt. Skillnaden mellan tupler och listor är att tupler är oföränderliga (immutable), vilket betyder att när de väl är definierade kan du inte ta bort, lägga till eller redigera värden i dem.

Varför skulle du konvertera listor till tupler?

Därför att tupler är oföränderliga datatyper och möjliggör betydande optimering av programmen du skapar.

Och varför skulle du konvertera tupler till listor?

Kanske vill du göra ändringar i den ursprungliga tuplen. Då kan du konvertera dem till listor, göra ändringen och sedan konvertera tillbaka till tupler.

I Python kan du använda funktionen tuple() för att returnera en tuple-version av värdet som skickas in, och på samma sätt funktionen list() för att konvertera en tuple till en lista:

a_tuple = ('a', 1) ,('f', 2), ('g', 3)
b_list = [1,2,3,4,5]

print(tuple(b_list))
print(list(a_tuple))

(1, 2, 3, 4, 5)
[('a', 1), ('f', 2), ('g', 3)]

På liknande sätt konverterar du en sträng till en lista eller en tuple i Python så här:

dessert = 'Cake'

# Konvertera tecknen i en sträng till individuella element i en tuple
print(tuple(dessert))

# Konvertera en sträng till en lista
dessert_list = list(dessert)
dessert_list.append('s')
print(dessert_list)

('C', 'a', 'k', 'e')
['C', 'a', 'k', 'e', 's']

Typkonvertering till ordböcker och mängder i Python

Du kan använda funktionen dict() för att konvertera en tuple till en ordbok och set() för att konvertera en lista till en mängd. 

print(dict(a_tuple))
print(set(b_list))

{'a': 1, 'f': 2, 'g': 3}
{1, 2, 3, 4, 5}

Likt andra konverteringsfunktioner behöver du bara ange funktionsnamnet för att konvertera vilken datatyp som helst till ordböcker och mängder.

Använda dataclasses för strukturerad data (Python 3.7+)

I stället för att använda ordböcker eller tupler erbjuder dataclasses ett bättre sätt att hantera strukturerad data.

from dataclasses import dataclass

@dataclass
class Product:
    name: str
    price: float
    in_stock: bool

item = Product("Laptop", 799.99, True)
print(item)  # Output: Product(name='Laptop', price=799.99, in_stock=True)

Sammanfattning: Konverteringar av icke-primitiva datastrukturer i Python

Unicode, binära, oktala och hexadecimala heltal i Python

Talsystem syftar på antalet symboler eller tecken som representerar ett numeriskt värde. Talsystemet som du normalt använder varje dag kallas decimalt. I decimalsystemet använder du tio olika symboler: 0, 1, 2, 3, 4, 5, 6, 7, 8 och 9. Med dessa tio symboler kan du representera vilken kvantitet som helst. Unicode, binär, hexadecimal och oktal syftar på olika talsystem.

Du går till nästa sifferposition när symbolerna tar slut. I decimalsystemet använder du 10 för att representera ett högre värde än 9, vilket betyder en enhet av tio och noll enheter av ett. I andra talsystem är det dock annorlunda. Till exempel, när du använder ett binärt system som bara har två symboler, 0 och 1, måste du gå till nästa sifferposition när symbolerna tar slut. Så här räknar du binärt: 0, 1, 10, 11, 100, 101, etc.

Låt oss titta närmare på några av talsystemen i nästa avsnitt.

Konvertera binärt till decimalt i Python

Binära heltal är tal som representeras med bas två. Det betyder att i det binära talsystemet används endast två symboler för att representera tal: 0 och 1. När du räknar uppåt från noll i binärt tar symbolerna slut snabbare: 0, 1, ???

Därefter finns det inga fler symboler kvar. Du går inte till siffran 2 eftersom 2 inte finns i binärt. I stället använder du en särskild kombination av 1:or och 0:or. I ett binärt system är 1000 lika med 8 i decimalt. I binärt använder du tvåpotenser, vilket betyder att 8 i grunden är: (1(2^3)) + (0(2^2)) + (0(2^1)) + (0(2^0)) = 8. Positionen för 1 och 0 definierar vilken potens 2 ska upphöjas till.

Vi ser detta med ett mer komplext exempel för att göra det tydligt:

Binary Number = 1001111
Decimal value = (1*(2^6)) + (0*(2^5)) + (0*(2^4)) + (1*(2^3)) + (1*(2^2)) + (1*(2^1)) + (1*(2^0))
              = 79

I Python kan du helt enkelt använda funktionen bin() för att konvertera från ett decimalt värde till motsvarande binära värde.

På samma sätt kan du använda funktionen int() för att konvertera ett binärt tal till dess decimala värde. Funktionen int() tar som andra argument basen för talet som ska konverteras, vilket är 2 i fallet med binära tal.

a = 79

# Bas 2 (binärt)
bin_a = bin(a)
print(bin_a)
print(int(bin_a, 2)) #Bas 2(binary)

0b1001111
79

Konvertera oktalt till decimalt i Python

Oktal är ett annat talsystem med färre symboler än det konventionella decimalsystemet. Det är bas åtta, vilket betyder att åtta symboler används för att representera alla kvantiteter. De är 0, 1, 2, 3, 4, 5, 6 och 7. Efter 7 kommer 10 eftersom 8 inte finns.

Precis som du använde tvåpotenser i binärt för att bestämma värdet på ett tal, använder du åttapotensen här eftersom detta är bas åtta.

I ett binärt system är 10 lika med 8 i oktalt. Låt oss bryta ner det: (1(8^1)) + (0(8^0)) = 8.

Ett mer komplext exempel:

Octal Number = 117
Decimal value = (1*(8^2)) + (1*(8^1)) + (7*(8^0))
              = 79

I Python kan du använda funktionen oct() för att konvertera från ett decimalt värde till motsvarande oktala värde. Alternativt kan du också använda funktionen int() och rätt bas, vilket är 8 för det oktala talsystemet.

a = 79

# Bas 8 (oktal)
oct_a = oct(a)
print(oct_a)
print(int(oct_a, 8))

0o117
79

Konvertera hexadecimalt till decimalt i Python

Hexadecimal är ett talsystem med bas 16. Till skillnad från binärt och oktalt använder det sex ytterligare symboler utöver siffrorna i decimalsystemet.

Men vad kommer efter 9?

När ytterligare symboler behövs utöver de vanliga numeriska värdena används bokstäver. Så i hexadecimal är den fullständiga listan av symboler 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E och F.

Med samma exempel som tidigare:

Hexadecimal Number = 4F
Decimal value = (4*(16^1)) + (F*(16^0))
              = 79

I Python kan du använda funktionen hex() för att konvertera från ett decimalt värde till motsvarande hexadecimala värde, eller funktionen int() med bas 16 för det hexadecimala talsystemet.

a = 79

# Bas 16 (hexadecimalt)
hex_a = hex(a)
print(hex_a)
print(int(hex_a, 16))

0x4f
79

Konvertera Unicode till tecken

Python chr() konverterar Unicode-heltal till en sträng. Unicode är en allmänt accepterad teckenkodning för att visa skriven text på många olika språk.

Vi har skickat in olika Unicode-heltal till funktionen chr() för att visa ”DATACAMP”. Du kan också använda ord() för att konvertera ett enskilt tecken till ett Unicode-heltal. 

print(
    chr(68),
    chr(65),
    chr(84),
    chr(65),
    chr(67),
    chr(65),
    chr(77),
    chr(80),
)

D A T A C A M P

Sammanfattning: Konverteringar mellan talsystem i Python

Du klarade det!

Grattis! Du har lärt dig om konverteringar av datatyper i Python, främst med hjälp av inbyggda metoder. Detta kommer definitivt att hjälpa dig att hantera olika datatyper och ge dig mer flexibilitet när du skriver dina program.

Vi har en utmärkt kurs, Intermediate Python for Data Science, där du kan lära dig att visualisera din data med matplotlib och arbeta med ordböcker och den välkända pandas DataFrame. Du kommer också att se hur du kan styra flödet i ditt program med slingor. Det finns dessutom en fallstudie i slutet av kursen där du kan tillämpa allt du har lärt dig och omsätta dina kunskaper i praktiken!