Python-Datentypumwandlung: Ein Leitfaden mit Beispielen

Im Beispiel wurde der Integer-Wert a_int zu einer Gleitkommazahl b_float addiert, und das Ergebnis wurde automatisch in eine Gleitkommazahl c_sum umgewandelt, ohne dass du den Compiler anweisen musstest. Das ist eine implizite Typumwandlung.

Warum wurde der Float-Wert nicht stattdessen in einen Integer umgewandelt?

Dahinter steckt das allgemeinere Konzept der „Type Promotion“. Vereinfacht gesagt ist das ein Schutzmechanismus des Compilers: Er ermöglicht Operationen, wann immer möglich, indem er deine Daten in einen übergeordneten Typ konvertiert, ohne Informationen zu verlieren.

Eine Umwandlung von Float zu Integer findet daher nicht statt, weil dabei der Nachkommateil wegfallen würde und somit Informationen verloren gingen.

Explizite Datentypumwandlung in Python

Bei der expliziten Typumwandlung, häufig „Type Casting“ genannt, wandelst du einen Wert gezielt von einem Datentyp in einen anderen um. So behältst du die direkte Kontrolle, da du den Zieltyp im Code ausdrücklich vorgibst. Das ist besonders dann nützlich, wenn die automatische (implizite) Umwandlung von Python nicht deinen Anforderungen entspricht.

Die Syntax für eine explizite Umwandlung lautet:

target_data_type(expression)

Wenn du z. B. eine Gleitkommazahl in einen Integer umwandeln willst, schreibst du:

int(3.14)  # Converts 3.14 to 3

Hinweis: Explizite Umwandlungen sind sehr hilfreich, können aber Informationsverlust verursachen. Beim Konvertieren einer Gleitkommazahl in einen Integer geht zum Beispiel der Nachkommateil verloren. Verstehe diese Konsequenzen, um unbeabsichtigte Ergebnisse in deinen Programmen zu vermeiden.

Schauen wir uns einige gängige explizite Datentypumwandlungen an.

Primitive vs. nicht-primitive Datenstrukturen in Python

Primitive Datenstrukturen sind die Bausteine der Datenverarbeitung und enthalten reine, einfache Werte. Python hat vier primitive Variablentypen:

• Integer
• Float
• Strings
• Boolean

Nicht-primitive Datenstrukturen speichern nicht nur einen Wert, sondern Sammlungen von Werten in verschiedenen Formaten. In Python sind das:

• Listen
• Tupel
• Dictionaries
• Sets

Mehr dazu lernst du im DataCamp-Tutorial zu Datenstrukturen in Python.

Umwandlungen bei primitiven Datenstrukturen

Integer- und Float-Umwandlungen in Python

Integer und Floats sind Datentypen für Zahlen.

Um einen Integer in einen Float umzuwandeln, verwendest du in Python die Funktion float(). Möchtest du einen Float in einen Integer konvertieren, nutzt du int().

a_int = 3
b_int = 2

# Explizite Umwandlung von int zu float
c_float_sum = float(a_int + b_int)
print(c_float_sum)

5.0

a_float = 3.3
b_float = 2.0

# Explizite Umwandlung von float zu 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-Präzisionsprobleme und das Decimal-Modul

Fließkomma-Arithmetik in Python kann zu Präzisionsproblemen führen:

print(0.1 + 0.2)  # Output: 0.30000000000000004

Um das zu vermeiden, nutze das Modul Decimal:

from decimal import Decimal

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

Umwandlung von reellen zu komplexen Zahlen in Python

Du kannst Integer mit complex(real,imag) in komplexe Zahlen umwandeln. Die Funktion erwartet zwei Zahlen (Real- und Imaginärteil) und erzeugt daraus eine komplexe Zahl.

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

(2+5j)

Datentypumwandlung mit Strings in Python

Ein String ist eine Folge von einem oder mehreren Zeichen (Buchstaben, Zahlen, Symbole). Häufig musst du Strings in Zahlen oder Zahlen in Strings konvertieren.

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

Das obige Beispiel wirft einen TypeError und weist darauf hin, dass der Compiler nicht implizit von Integer zu String umwandeln kann.

Was das Programm hier tun sollte, wirkt vielleicht offensichtlich. Der Compiler kann sich aber nicht immer sicher sein und stellt deshalb mit explizitem Casting einen Mechanismus bereit, mit dem du klar vorgibst, was du möchtest. So wandelst du einen Integer mit str() in einen String um:

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

The total is: 21$

Genauso funktioniert die Umwandlung von Float zu String.

In Python kannst du Strings, wenn möglich, auch in Integer- und Float-Werte umwandeln. Schauen wir uns das an:

price_cake = '15'
price_cookie = '6'

# String-Verkettung
total = price_cake + price_cookie
print("The total is: " + total + "$")

# Explizite Umwandlung zu Integer
total = int(price_cake) + int(price_cookie)
print("The total is: " + str(total)  + "$")

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

Kurze Erklärung des Codes.

price_cake und price_cookie sind zunächst Strings. Um die Summe zu berechnen, müssen sie zuerst in die entsprechenden Integer-Werte konvertiert werden. Andernfalls geht der Compiler von String-Verkettung statt numerischer Addition aus. Anschließend fügst du den Wert in die Ausgabemeldung ein und musst die Summe wieder in einen String umwandeln, um sie mit dem Rest zu verketten.

Hoffentlich zeigt dir dieses Beispiel die Bedeutung von Typumwandlungen. Auch wenn es nur ein kleines Beispiel ist, wird der Nutzen schnell klar.

Hinweis: Ist dir das „wenn möglich“ bei der Umwandlung von Strings in Integer oder Float aufgefallen? Das liegt daran, dass Strings nicht immer in Zahlen konvertiert werden können und somit keine numerischen Operationen zulassen. Der Compiler weiß das und gibt entsprechend einen Fehler aus. Sieh dir das Beispiel an:

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'

Zusammenfassung: Umwandlungen primitiver Datentypen in Python

Umwandlungen bei nicht-primitiven Datenstrukturen

Typumwandlung zu Tupeln und Listen in Python

Wie bei Integern und Floats kannst du auch Listen in Tupel und Tupel in Listen umwandeln.

Zur Erinnerung: Listen und Tupel dienen der Speicherung von Kollektionen homogener Elemente. Der Unterschied: Tupel sind unveränderlich. Einmal definiert, kannst du keine Werte darin löschen, hinzufügen oder bearbeiten.

Warum solltest du Listen in Tupel umwandeln?

Weil Tupel unveränderlich sind und dadurch Programme oft effizienter machen.

Und warum Tupel in Listen umwandeln?

Vielleicht willst du Änderungen an einem ursprünglichen Tupel vornehmen. Dann wandelst du es in eine Liste um, nimmst die Änderungen vor und wandelst es wieder in ein Tupel zurück.

In Python gibt dir tuple() eine Tupel-Variante des übergebenen Werts zurück; mit list() wandelst du ein Tupel in eine Liste um:

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

Ähnlich kannst du einen String in eine Liste oder ein Tupel konvertieren:

dessert = 'Cake'

# Zeichen eines Strings in einzelne Elemente eines Tupels umwandeln
print(tuple(dessert))

# String in eine Liste umwandeln
dessert_list = list(dessert)
dessert_list.append('s')
print(dessert_list)

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

Typumwandlung zu Dictionaries und Sets in Python

Mit dict() wandelst du ein Tupel in ein Dictionary um und mit set() eine Liste in ein Set. 

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

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

Wie bei anderen Umwandlungsfunktionen gibst du einfach die entsprechende Funktion an, um einen beliebigen Typ in Dictionaries oder Sets zu konvertieren.

Einsatz von dataclasses für strukturierte Daten (Python 3.7+)

Statt Dictionaries oder Tupel bieten dataclasses eine bessere Möglichkeit, strukturierte Daten zu verwalten.

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)

Zusammenfassung: Umwandlungen nicht-primitiver Datenstrukturen in Python

Unicode, Binär-, Oktal- und Hexadezimalzahlen in Python

Zahlensysteme beziehen sich auf die Anzahl der Symbole oder Zeichen, mit denen numerische Werte dargestellt werden. Das Zahlensystem, das du im Alltag nutzt, ist das Dezimalsystem. Es verwendet zehn Symbole: 0, 1, 2, 3, 4, 5, 6, 7, 8 und 9. Mit diesen zehn Symbolen lassen sich alle Mengen darstellen. Unicode, Binär, Hexadezimal und Oktal bezeichnen unterschiedliche Zahlensysteme.

Wenn dir die Symbole ausgehen, wechselst du zur nächsten Stellenposition. Im Dezimalsystem verwendest du für den Wert eins über 9 die 10, also eine Zehn und null Einer. In anderen Zahlensystemen ist das anders. Im Binärsystem gibt es nur zwei Symbole, 0 und 1. Wenn dir die Symbole ausgehen, wechselst du zur nächsten Stelle. Gezählt wird also: 0, 1, 10, 11, 100, 101, usw.

Schauen wir uns einige Zahlensysteme im Detail an.

Binär nach Dezimal in Python umwandeln

Binärzahlen sind Zahlen zur Basis zwei. Es gibt also nur die Symbole 0 und 1. Beim Zählen ab null gehen dir schneller die Symbole aus: 0, 1, ???

Es gibt keine weiteren Symbole. Die Ziffer 2 gibt es nicht im Binärsystem. Stattdessen nutzt du Kombinationen aus 1 und 0. Im Binärsystem entspricht 1000 der Dezimalzahl 8. Du arbeitest mit Zweierpotenzen, d. h. 8 ist: (1(2^3)) + (0(2^2)) + (0(2^1)) + (0(2^0)) = 8. Die Positionen der 1 und 0 bestimmen die Potenz von 2.

Ein komplexeres Beispiel zur Verdeutlichung:

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 kannst du mit bin() eine Dezimalzahl in ihre binäre Darstellung umwandeln.

Entsprechend konvertiert int() eine Binärzahl in eine Dezimalzahl. int() nimmt als zweites Argument die Basis des zu konvertierenden Zahlensystems, bei Binär also 2.

a = 79

# Basis 2 (binär)
bin_a = bin(a)
print(bin_a)
print(int(bin_a, 2)) #Basis 2 (binär)

0b1001111
79

Oktal nach Dezimal in Python umwandeln

Oktal ist ein weiteres Zahlensystem mit weniger Symbolen als das Dezimalsystem. Es hat die Basis acht, verwendet also die Symbole 0, 1, 2, 3, 4, 5, 6 und 7. Nach 7 kommt 10, da es keine 8 gibt.

Wie beim Binärsystem nutzt du hier Potenzen der 8, weil die Basis acht ist.

Im Oktalsystem entspricht 10 der Dezimalzahl 8. Zerlegt: (1(8^1)) + (0(8^0)) = 8.

Ein komplexeres Beispiel:

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

In Python kannst du mit oct() eine Dezimalzahl in ihre oktale Darstellung konvertieren. Alternativ nutzt du int() mit Basis 8 für das Oktalsystem.

a = 79

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

0o117
79

Hexadezimal nach Dezimal in Python umwandeln

Hexadezimal ist ein Zahlensystem zur Basis 16. Anders als Binär und Oktal nutzt es sechs zusätzliche Symbole über die im Dezimalsystem hinaus.

Was kommt nach 9?

Wenn zusätzliche Symbole benötigt werden, kommen Buchstaben zum Einsatz. Die Symbole im Hexadezimalsystem sind also 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E und F.

Beispiel wie zuvor:

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

In Python nutzt du hex(), um eine Dezimalzahl in Hexadezimal umzuwandeln, oder int() mit Basis 16 für den umgekehrten Weg.

a = 79

# Basis 16 (hexadezimal)
hex_a = hex(a)
print(hex_a)
print(int(hex_a, 16))

0x4f
79

Unicode in Zeichen umwandeln

Python chr() konvertiert Unicode-Integer in einen String. Unicode ist ein weltweit akzeptierter Zeichencode zur Darstellung geschriebener Texte in vielen Sprachen.

Wir haben verschiedene Unicode-Integer an chr() übergeben, um “DATACAMP” auszugeben. Mit ord() kannst du umgekehrt ein einzelnes Zeichen in einen Unicode-Integer umwandeln. 

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

Zusammenfassung: Umwandlungen zwischen Zahlensystemen in Python

Geschafft!

Glückwunsch! Du hast Datentypumwandlungen in Python kennengelernt, vor allem mithilfe von eingebauten Funktionen. Das wird dir helfen, mit unterschiedlichen Datentypen flexibler zu arbeiten.

Unser Kurs Intermediate Python for Data Science zeigt dir, wie du Daten mit matplotlib visualisierst, mit Dictionaries und dem bekannten pandas DataFrame arbeitest und mit Schleifen den Programmfluss steuerst. Am Ende wartet eine Fallstudie, in der du alles anwenden und dein Wissen in die Praxis umsetzen kannst!