Python Datentypen: Ein umfassender Leitfaden

Jeder Wert in Python hat einen Datentyp, der dem Interpreter mitteilt, um welche Art von Daten es sich handelt und welche Operationen erlaubt sind. Da Python dynamisch typisiert ist, wird der Typ niemals explizit deklariert — der Interpreter leitet ihn zur Laufzeit ab. Das Verständnis der eingebauten Typen ist daher unerlässlich: Die Wahl des falschen Typs führt zu Fehlern, unnötigem Kopieren oder schlechter Performance.

Dieses Kapitel behandelt jeden eingebauten Datentyp:

Verwende die eingebaute Funktion type(), um jederzeit zu prüfen, welchen Typ ein Wert hat:

print(type(42))       # <class 'int'>
print(type(3.14))     # <class 'float'>
print(type("hello"))  # <class 'str'>
print(type(True))     # <class 'bool'>
print(type([1, 2]))   # <class 'list'>
print(type((1, 2)))   # <class 'tuple'>
print(type({1, 2}))   # <class 'set'>
print(type({"a": 1})) # <class 'dict'>
print(type(None))     # <class 'NoneType'>

Numerische Typen

Python hat drei numerische Typen: int, float und complex. Alle drei unterstützen die standardmäßigen arithmetischen Operatoren (+, -, *, /, //, %, **).

int

Ein int speichert eine ganze Zahl unbegrenzter Größe — Python-Ganzzahlen sind nicht auf 32 oder 64 Bit beschränkt.

Wichtige Operatoren

Beachte, dass / immer ein float zurückgibt, auch wenn das Ergebnis eine ganze Zahl ist. Verwende //, wenn du einen ganzzahligen Quotienten benötigst.

Python Integer-Datentyp

# Integer addition
print(1 + 2)    # 3

# Integer subtraction
print(3 - 1)    # 2

# Integer multiplication
print(2 * 3)    # 6

# True division always returns float
print(6 / 2)    # 3.0

# Floor division returns int
print(7 // 2)   # 3

# Exponentiation
print(2 ** 10)  # 1024

float

Ein float speichert eine Dezimalzahl im IEEE 754 Doppelpräzisionsformat. Verwende Gleitkommazahlen, wenn du Bruchteile benötigst.

Hinweis — Gleitkommadarstellung: 0.1 + 0.2 ist im binären Gleitkommaformat nicht exakt 0.3. Verwende round() oder das Modul decimal, wenn exakte Dezimalarithmetik wichtig ist (z. B. bei Währungen).

complex

Eine complex-Zahl hat einen Real- und einen Imaginärteil, in Python als a + bj geschrieben (mit j, nicht i). Komplexe Zahlen werden hauptsächlich in der Wissenschaftsinformatik, Signalverarbeitung und technischen Berechnungen verwendet.

str (Zeichenketten)

Ein str ist eine unveränderliche Sequenz von Unicode-Zeichen. Zeichenketten können in einfache Anführungszeichen, doppelte Anführungszeichen oder dreifache Anführungszeichen (für mehrzeilige Zeichenketten) eingeschlossen werden.

single = 'Hello'
double = "World"
multi  = """This spans
multiple lines."""

Häufige Zeichenkettenoperationen

Nützliche Zeichenkettenmethoden

s = "  Hello World  "
print(s.strip())          # "Hello World"  — remove whitespace
print(s.strip().lower())  # "hello world"
print(s.strip().upper())  # "HELLO WORLD"
print("Hello World".split())   # ['Hello', 'World']
print(",".join(["a", "b", "c"]))  # a,b,c
print("Hello World".replace("World", "Python"))  # Hello Python
print(len("Hello"))       # 5

f-strings (formatierte Zeichenkettenliterale)

f-strings (eingeführt in Python 3.6) sind die bevorzugte Methode, um Werte in Zeichenketten einzubetten:

name = "Alice"
age  = 30
print(f"{name} is {age} years old.")   # Alice is 30 years old.
print(f"Next year she will be {age + 1}.")  # Next year she will be 31.

Da Zeichenketten unveränderlich sind, erzeugt jede Operation, die eine Zeichenkette „ändert", tatsächlich eine neue. Für mehr zu Zeichenkettenmethoden siehe das Kapitel Python Strings.

bool (Boolean)

Ein bool hat genau zwei Werte: True und False. Booleans sind in Python eine Unterklasse von int — True entspricht 1 und False entspricht 0.

print(type(True))   # <class 'bool'>
print(True + 1)     # 2  (True is treated as 1)
print(False + 10)   # 10 (False is treated as 0)

Wahre und falsche Werte

Jedes Python-Objekt kann in einem booleschen Kontext ausgewertet werden. Die folgenden Werte sind falsch (werden als False ausgewertet); alles andere ist wahr:

• False, None
• Numerische Null: 0, 0.0, 0j
• Leere Sequenzen: "", [], (), set()
• Leere Zuordnung: {}

print(bool(0))      # False
print(bool(""))     # False
print(bool([]))     # False
print(bool(None))   # False

print(bool(42))     # True
print(bool("hi"))   # True
print(bool([0]))    # True  — list with one item is truthy

Eine vollständige Behandlung findest du im Kapitel Python Booleans.

list

Eine list ist eine geordnete, veränderliche Sequenz. Sie kann Elemente beliebiger Typen enthalten, auch gemischte, und erlaubt Duplikate.

# Creating a list
fruits = ["apple", "banana", "cherry"]

# Modifying an item
fruits[1] = "orange"
print(fruits)  # ['apple', 'orange', 'cherry']

# Adding items
fruits.append("mango")
print(fruits)  # ['apple', 'orange', 'cherry', 'mango']

# Removing an item
fruits.remove("orange")
print(fruits)  # ['apple', 'cherry', 'mango']

# Length
print(len(fruits))  # 3

Wann sollte man eine list verwenden: wenn du eine geordnete Sammlung benötigst, die sich ändern wird — Elemente hinzufügen, entfernen oder Werte direkt aktualisieren. Für eine ausführliche Behandlung siehe das Kapitel Python Lists.

tuple

Ein tuple ist eine geordnete, unveränderliche Sequenz. Nach der Erstellung können seine Elemente nicht mehr geändert werden.

# Creating a tuple
coords = (10, 20)
print(coords[0])    # 10
print(len(coords))  # 2

# Tuple unpacking
x, y = coords
print(x, y)  # 10 20

# Single-element tuple needs a trailing comma
single = (42,)
print(type(single))  # <class 'tuple'>

Wann sollte man ein tuple anstelle einer list verwenden:

• Die Daten sollen sich nicht ändern (z. B. GPS-Koordinaten, RGB-Farbwerte, Datenbankzeilen).
• Du möchtest den Wert als Dictionary-Schlüssel verwenden (Listen können keine Dict-Schlüssel sein, da sie veränderlich sind; Tuples können es).
• Du möchtest die Absicht kommunizieren: „Diese Sequenz ist fest."

Mehr dazu im Kapitel Python Tuples.

set

Ein set ist eine ungeordnete Sammlung eindeutiger Elemente. Doppelte Werte werden beim Erstellen oder Hinzufügen stillschweigend verworfen.

# Duplicates are automatically removed
unique = {1, 2, 2, 3, 3, 3}
print(unique)  # {1, 2, 3}

# Adding an item
unique.add(4)
print(unique)  # {1, 2, 3, 4}

# Membership test — O(1) average
print(3 in unique)  # True

# Set operations
a = {1, 2, 3}
b = {2, 3, 4}
print(a | b)  # {1, 2, 3, 4}  union
print(a & b)  # {2, 3}        intersection
print(a - b)  # {1}           difference

Wann sollte man ein set verwenden: wenn du schnelle Zugehörigkeitstests benötigst oder Duplikate aus einer Sammlung entfernen möchtest. Mehr dazu im Kapitel Python Sets.

dict (Dictionary)

Ein dict ist eine ungeordnete Zuordnung von Schlüssel-Wert-Paaren. Ab Python 3.7 behalten Dictionaries die Einfügereihenfolge bei. Schlüssel müssen eindeutig und unveränderlich sein (Zeichenketten und Zahlen sind die häufigsten Wahlen).

person = {"name": "John", "age": 32, "city": "New York"}

# Access by key
print(person["name"])  # John

# Add a key
person["country"] = "United States"
print(person)
# {'name': 'John', 'age': 32, 'city': 'New York', 'country': 'United States'}

# Remove a key
del person["city"]
print(person)
# {'name': 'John', 'age': 32, 'country': 'United States'}

# Safe access with a default value
print(person.get("email", "not provided"))  # not provided

# Iterate over keys and values
for key, value in person.items():
    print(f"{key}: {value}")

Wann sollte man ein dict verwenden: wenn Daten von Natur aus als Schlüssel-Wert-Struktur vorliegen und du schnellen Zugriff über den Namen benötigst. Mehr dazu im Kapitel Python Dictionary Methods.

NoneType

None ist Pythons Nullwert — er stellt die Abwesenheit eines Wertes dar. Es ist die einzige Instanz von NoneType.

result = None
print(result)         # None
print(type(result))   # <class 'NoneType'>

# Functions that do not explicitly return a value return None
def greet(name):
    print(f"Hello, {name}!")

x = greet("Alice")    # prints: Hello, Alice!
print(x)              # None

Verwende immer is None (Identitätsprüfung) anstelle von == None (Gleichheitsprüfung):

if result is None:
    print("No result yet")

Veränderlichkeit auf einen Blick

Veränderlichkeit bestimmt, ob ein Wert nach der Erstellung direkt geändert werden kann. Dies beeinflusst die Korrektheit (versehentliches Aliasing), die Performance (Kopieren vs. Referenzieren) und was als Dict-Schlüssel verwendet werden kann.

Typkonvertierung

Python stellt eingebaute Funktionen zur Konvertierung zwischen Typen bereit. Dies wird explizite Typkonvertierung (oder Casting) genannt.

# To int
print(int("42"))      # 42
print(int(3.9))       # 3  (truncates, does not round)
print(int(True))      # 1

# To float
print(float(7))       # 7.0
print(float("3.14"))  # 3.14

# To str
print(str(3.14))      # '3.14'
print(str(True))      # 'True'

# Between sequences
print(list((1, 2, 3)))   # [1, 2, 3]
print(tuple([1, 2, 3]))  # (1, 2, 3)
print(set([1, 2, 2, 3])) # {1, 2, 3}

int() schneidet ab (rundet nicht): int(3.9) ergibt 3, nicht 4. Verwende round() vor int(), wenn Runden erforderlich ist.

Eine vollständige Diskussion der Casting-Regeln findest du im Kapitel Python Casting.

Typprüfung im Code

Verwende isinstance() (bevorzugt) oder type() für Typprüfungen:

x = 42
print(isinstance(x, int))    # True
print(isinstance(x, float))  # False

# isinstance also works with a tuple of types
print(isinstance(x, (int, float)))  # True

Bevorzuge isinstance() gegenüber type(x) == int, da es Vererbung berücksichtigt — ein bool ist auch ein int, daher gibt isinstance(True, int) True zurück, was in der Regel das Gewünschte ist.

Kurzübersicht

* Einfügereihenfolge beibehalten ab Python 3.7+.

Übung