Python-gegevens-typen converteren: een gids met voorbeelden

In het voorbeeld is een integerwaarde a_int opgeteld bij een floatwaarde b_float, en het resultaat is automatisch geconverteerd naar een floatwaarde c_sum zonder dat je dit aan de compiler hoefde te vertellen. Dit is impliciete gegevensconversie.

Waarom is de floatwaarde niet in plaats daarvan naar een integer geconverteerd?

Dit komt door een breder concept van typepromotie in de informatica. Simpel gezegd is dit een verdedigingsmechanisme van de compiler dat je in staat stelt om bewerkingen waar mogelijk uit te voeren door je data te converteren naar een ander supertype zonder informatieverlies.

Dat betekent dat de conversie van float naar integer niet wordt gedaan, omdat de compiler dan het fractionele deel zou moeten verwijderen, wat leidt tot informatieverlies.

Expliciete conversie van gegevenstypen in Python

Expliciete conversie van gegevenstypen, vaak type casting genoemd, vindt plaats wanneer je een waarde bewust van het ene gegevenstype naar het andere converteert. Deze aanpak geeft je directe controle over de conversie, omdat je in je code expliciet het doeltgegevenstype opgeeft. Dit wordt vaak gebruikt wanneer de automatische (impliciete) conversie die Python biedt niet aan je wensen voldoet.

De syntaxis voor expliciete conversie is:

target_data_type(expression)

Als je bijvoorbeeld een kommagetal naar een integer wilt converteren, schrijf je:

int(3.14)  # Converts 3.14 to 3

Let op: hoewel expliciete conversies erg handig zijn, kunnen ze tot informatieverlies leiden. Als je bijvoorbeeld een kommagetal naar een integer converteert, wordt het fractionele deel weggegooid. Het is belangrijk om deze consequenties te begrijpen om onbedoelde resultaten in je programma’s te voorkomen.

Laten we een paar veelgebruikte expliciete conversies van gegevenstypen verkennen.

Primitieve versus niet-primitieve datastructuren in Python

Primitieve datastructuren zijn de bouwstenen voor datamanipulatie en bevatten pure, eenvoudige datawaarden. Python heeft vier primitieve variabeletypen:

• Integers
• Float
• Strings
• Boolean

Niet-primitieve datastructuren slaan niet slechts één waarde op, maar een verzameling waarden in verschillende formaten. In Python heb je de volgende niet-primitieve datastructuren:

• Lists
• Tuples
• Dictionaries
• Sets

Je kunt hier meer over leren in DataCamp's Data Structures in Python Tutorial.

Conversies van primitieve datastructuren

Conversies tussen integers en floats in Python

Integers en floats zijn gegevenstypen die met getallen werken.

Om een integer naar een float te converteren, gebruik je de functie float() in Python. Wil je een float naar een integer converteren, dan kun je de functie int() gebruiken.

a_int = 3
b_int = 2

# Expliciete typeconversie van int naar float
c_float_sum = float(a_int + b_int)
print(c_float_sum)

5.0

a_float = 3.3
b_float = 2.0

# Expliciete typeconversie van float naar 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

Float-precisieproblemen en de Decimal-module

Rekenkunde met kommagetallen in Python kan tot precisieproblemen leiden:

print(0.1 + 0.2)  # Output: 0.30000000000000004

Gebruik hiervoor de module Decimal om dit te vermijden:

from decimal import Decimal

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

Conversie van reëel naar complex gegevenstype in Python

Je kunt integers naar complexe getallen converteren met complex(real,imag). Deze functie verwacht twee integers (reëel en imaginair) en zet reële getallen om naar complexe getallen.

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

(2+5j)

Conversie van gegevenstypen met strings in Python

Een string is een verzameling van één of meer tekens (letters, cijfers, symbolen). Je zult vaak strings naar getallen of getallen naar strings moeten converteren.

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

Het voorbeeld hierboven geeft een TypeError, die aangeeft dat de compiler een integerwaarde niet impliciet naar een string kan converteren.

Wat het programma hier zou moeten doen, lijkt voor jou misschien intuïtief. De compiler weet het echter niet altijd zeker en biedt daarom een mechanisme met expliciet type casten, zodat je duidelijk kunt aangeven wat je wilt. Zo kun je in Python een integer naar een string converteren met de functie str():

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

The total is: 21$

Dit werkt op dezelfde manier wanneer je floats naar strings converteert.

In Python kun je ook strings naar integer- en floatwaarden converteren wanneer dat mogelijk is. Laten we bekijken wat dat betekent:

price_cake = '15'
price_cookie = '6'

# Stringconcatenatie
total = price_cake + price_cookie
print("The total is: " + total + "$")

# Expliciete typeconversie naar integer
total = int(price_cake) + int(price_cookie)
print("The total is: " + str(total)  + "$")

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

Laten we de code opsplitsen.

price_cake en price_cookie zijn aanvankelijk strings. Vervolgens wil je het totaal bepalen, wat betekent dat ze eerst naar de bijbehorende integerwaarden moeten worden geconverteerd. Anders gaat de compiler ervan uit dat je een stringconcatenatie wilt uitvoeren in plaats van een numerieke optelling. Daarna moet je deze waarde in de uiteindelijke weergavestring opnemen en dus het totaal naar een string converteren om het met de rest van het bericht te kunnen samenvoegen.

Hopelijk laat dit voorbeeld zien hoe belangrijk conversies van gegevenstypen zijn. Ook al is dit een heel klein voorbeeld, je ziet al hoe nuttig het kan zijn.

Let op: viel je het "wanneer mogelijk" op bij het converteren van een string naar integers of float? Dat komt omdat het niet altijd mogelijk is om strings naar getallen te converteren en er numerieke bewerkingen op toe te passen. De compiler is zich hiervan bewust en geeft je daarom een foutmelding wanneer je dit probeert. Bekijk het voorbeeld hieronder:

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'

Samenvatting: conversies van primitieve gegevenstypen in Python

Conversies van niet-primitieve datastructuren

Typeconversie naar tuples en lijsten in Python

Net als bij integers en floats kun je ook lijsten naar tuples en tuples naar lijsten converteren.

Weet je nog wat tuples en lijsten zijn? Lijsten en tuples in Python worden gebruikt om een verzameling homogene items op te slaan. Het verschil tussen tuples en lijsten is dat tuples immutabel zijn, wat betekent dat je eenmaal gedefinieerde waarden erin niet kunt verwijderen, toevoegen of bewerken.

Waarom zou je lijsten naar tuples converteren?

Omdat tuples immutabele gegevenstypen zijn en aanzienlijke optimalisaties mogelijk maken voor de programma’s die je schrijft.

En waarom zou je tuples naar lijsten converteren?

Misschien wil je wijzigingen aanbrengen in de oorspronkelijke tuple. Je kunt ze dan naar lijsten converteren, de wijziging doorvoeren en ze vervolgens weer naar tuples converteren.

In Python kun je de functie tuple() gebruiken om een tupleversie te retourneren van de waarde die je doorgeeft, en op dezelfde manier de functie list() om een tuple naar een lijst te converteren:

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)]

Op dezelfde manier kun je een string naar een lijst of een tuple converteren in Python:

dessert = 'Cake'

# Converteer de tekens in een string naar afzonderlijke items in een tuple
print(tuple(dessert))

# Converteer een string naar een lijst
dessert_list = list(dessert)
dessert_list.append('s')
print(dessert_list)

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

Typeconversie naar dictionaries en sets in Python

Je kunt de functie dict() gebruiken om een tuple naar een dictionary te converteren en set() om een lijst naar een set te converteren. 

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

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

Net zoals bij andere conversiefuncties hoef je alleen de functienaam te gebruiken om elk datatype naar dictionaries en sets te converteren.

Gebruik van dataclasses voor gestructureerde data (Python 3.7+)

In plaats van dictionaries of tuples te gebruiken, bieden dataclasses een betere manier om met gestructureerde data om te gaan.

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)

Samenvatting: conversies van niet-primitieve datastructuren in Python

Unicode, binaire, octale en hexadecimale integers in Python

Nummerstelsels verwijzen naar het aantal symbolen of tekens waarmee een numerieke waarde wordt weergegeven. Het nummerstelsel dat je doorgaans elke dag gebruikt, heet decimaal. In het decimale stelsel gebruik je tien verschillende symbolen: 0, 1, 2, 3, 4, 5, 6, 7, 8 en 9. Met deze tien symbolen kun je elke hoeveelheid weergeven. Unicode, binair, hexadecimaal en octaal verwijzen naar verschillende nummerstelsels.

Je gaat naar de volgende cijferpositie wanneer je door je symbolen heen bent. In het decimale systeem gebruik je om één hoger dan 9 weer te geven 10, wat betekent één eenheid van tien en nul eenheden van één. In andere nummerstelsels werkt dit echter anders. In een binair stelsel, waarin je slechts twee symbolen gebruikt, 0 en 1, moet je naar de volgende cijferpositie gaan zodra je door je symbolen heen bent. Zo tel je in binair: 0, 1, 10, 11, 100, 101, enz.

Laten we enkele van de nummerstelsels in de volgende secties nader bekijken.

Binair naar decimaal converteren in Python

Binaire integers zijn de getallen die met grondtal twee worden weergegeven. Dit betekent dat in het binaire nummerstelsel slechts twee symbolen worden gebruikt om getallen weer te geven: 0 en 1. Als je in binair vanaf nul omhoog telt, ben je sneller door je symbolen heen: 0, 1, ???

Er zijn vervolgens geen symbolen meer over. Je gaat niet naar het cijfer 2, want 2 bestaat niet in binair. In plaats daarvan gebruik je een speciale combinatie van 1’en en 0’en. In een binair stelsel is 1000 gelijk aan 8 in decimaal. In binair gebruik je machten van twee, wat betekent dat 8 in feite is: (1(2^3)) + (0(2^2)) + (0(2^1)) + (0(2^0)) = 8. De positie van de 1 en 0 bepaalt tot welke macht 2 moet worden verheven.

Laten we dit met een complexer voorbeeld verduidelijken:

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

In Python kun je eenvoudig de functie bin() gebruiken om van een decimale waarde naar de bijbehorende binaire waarde te converteren.

Evenzo gebruik je de functie int() om een binair getal naar zijn decimale waarde te converteren. De functie int() neemt als tweede argument het grondtal van het te converteren getal, wat 2 is in het geval van binaire getallen.

a = 79

# Base 2(binary)
bin_a = bin(a)
print(bin_a)
print(int(bin_a, 2)) #Base 2(binary)

0b1001111
79

Octaal naar decimaal converteren in Python

Octaal is een ander nummerstelsel met minder symbolen dan het conventionele decimale systeem. Het heeft grondtal acht, wat betekent dat acht symbolen worden gebruikt om alle hoeveelheden weer te geven. Dat zijn 0, 1, 2, 3, 4, 5, 6 en 7. Na 7 komt 10, omdat 8 niet bestaat.

Net zoals je in binair machten van twee gebruikte om de waarde van een getal te bepalen, gebruik je hier machten van 8, omdat dit grondtal acht is.

In een octaal stelsel is 10 gelijk aan 8 in decimaal. Uiteengezet: (1(8^1)) + (0(8^0)) = 8.

Een complexer voorbeeld:

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

In Python kun je de functie oct() gebruiken om van een decimale waarde naar de bijbehorende octale waarde te converteren. Je kunt ook de functie int() gebruiken met het juiste grondtal, dat 8 is voor het octale nummerstelsel.

a = 79

# Base 8(octal)
oct_a = oct(a)
print(oct_a)
print(int(oct_a, 8))

0o117
79

Hexadecimaal naar decimaal converteren in Python

Hexadecimaal is een nummerstelsel met grondtal 16. In tegenstelling tot binair en octaal gebruikt het zes extra symbolen naast de cijfers uit het decimale stelsel.

Maar wat komt er na 9?

Wanneer er extra symbolen nodig zijn naast de normale numerieke waarden, worden letters gebruikt. In hexadecimaal is de volledige lijst van symbolen dus 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E en F.

Met hetzelfde voorbeeld als eerder:

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

In Python kun je de functie hex() gebruiken om van een decimale waarde naar de bijbehorende hexadecimale waarde te converteren, of de functie int() met grondtal 16 voor het hexadecimale nummerstelsel.

a = 79

# Base 16(hexadecimal)
hex_a = hex(a)
print(hex_a)
print(int(hex_a, 16))

0x4f
79

Unicode naar teken converteren

Python chr() converteert Unicode-integers naar een string. Unicode is een algemeen geaccepteerde tekencodering voor het weergeven van geschreven teksten van diverse talen.

We hebben verschillende Unicode-integers aan de functie chr() gegeven om “DATACAMP” weer te geven. Je kunt ook ord() gebruiken om één teken naar een Unicode-integer te converteren. 

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

Samenvatting: conversies van nummerstelsels in Python

Je bent er!

Gefeliciteerd! Je hebt geleerd over conversies van gegevenstypen in Python, voornamelijk met ingebouwde methoden. Dit helpt je zeker om met verschillende gegevenstypen om te gaan en geeft je meer flexibiliteit bij het schrijven van je programma’s.

We hebben een uitstekende cursus Intermediate Python for Data Science waarin je leert hoe je je data visualiseert met matplotlib en werkt met dictionaries en de bekende pandas DataFrame. Je ziet ook hoe je de flow van je programma kunt sturen met loops. Aan het einde van de cursus is er een casestudy waarin je alles wat je hebt geleerd kunt toepassen en je kennis in de praktijk brengt!