Datentypen im Überblick

Ueberblick: Die fuenf Grundtypen

Python hat fuenf grundlegende Datentypen, die du von Anfang an kennen solltest:

alter = 25              # int
temperatur = 36.6       # float
stadt = "Berlin"        # str
ist_sonnig = True       # bool
ergebnis = None         # NoneType

Lass uns jeden Typ im Detail anschauen.

int — Ganzzahlen

Ganzzahlen (englisch: integers) sind Zahlen ohne Nachkommastellen. In Python koennen sie beliebig gross werden — es gibt kein Limit!

klein = 42
negativ = -17
null = 0

# Python kann mit riesigen Zahlen umgehen:
riesig = 99999999999999999999999999999999999999
print(riesig)  # Kein Problem!
print(type(riesig))  # <class 'int'>

Das ist eine Besonderheit von Python. In vielen anderen Sprachen (wie Java oder C) gibt es eine Obergrenze fuer Ganzzahlen. Python nicht — die Zahl kann so gross sein, wie dein Arbeitsspeicher erlaubt.

Nuetzliche Schreibweisen

# Unterstriche fuer bessere Lesbarkeit (werden ignoriert):
einwohner = 83_190_556
budget = 1_000_000

# Verschiedene Zahlensysteme:
binaer = 0b1010     # Binaer: 10
oktal = 0o17        # Oktal: 15
hexadezimal = 0xFF  # Hexadezimal: 255

print(binaer)       # 10
print(hexadezimal)  # 255

float — Gleitkommazahlen

Gleitkommazahlen (Floats) sind Zahlen mit Nachkommastellen:

pi = 3.14159
temperatur = -12.5
preis = 9.99

print(type(pi))  # <class 'float'>

Achtung: Gleitkomma-Genauigkeit

Floats werden intern als Binaerzahlen gespeichert. Das fuehrt manchmal zu ueberraschenden Ergebnissen:

print(0.1 + 0.2)  # 0.30000000000000004 -- Ueberraschung!
print(0.1 + 0.2 == 0.3)  # False!

Das ist kein Python-Bug, sondern eine Eigenschaft der Gleitkomma-Darstellung (IEEE 754). Fuer praezise Berechnungen (z.B. mit Geld) gibt es das decimal-Modul:

from decimal import Decimal

preis = Decimal("0.1") + Decimal("0.2")
print(preis)  # 0.3 -- exakt!

Spezielle Float-Werte

unendlich = float("inf")
neg_unendlich = float("-inf")
keine_zahl = float("nan")

print(unendlich > 999999999)  # True
print(keine_zahl == keine_zahl)  # False -- NaN ist nie gleich sich selbst!

str — Strings (Text)

Strings sind Zeichenketten — also Text. Du erstellst sie mit Anfuehrungszeichen:

einfach = 'Hallo Welt'
doppelt = "Hallo Welt"
dreifach = """Das ist ein
mehrzeiliger String."""

print(type(einfach))  # <class 'str'>

Einfache und doppelte Anfuehrungszeichen sind gleichwertig. Dreifache Anfuehrungszeichen erlauben Zeilenumbrueche.

# Laenge eines Strings
text = "Python"
print(len(text))  # 6

# Strings sind Sequenzen
print(text[0])   # P
print(text[-1])  # n

Strings werden im naechsten Tutorial detailliert behandelt. Hier reicht der Ueberblick.

bool — Wahrheitswerte

Boolsche Werte kennen nur zwei Zustaende: True (wahr) oder False (falsch).

ist_aktiv = True
hat_bezahlt = False

print(type(ist_aktiv))  # <class 'bool'>

Boolsche Werte entstehen oft durch Vergleiche:

alter = 18

print(alter >= 18)    # True
print(alter == 21)    # False
print(alter != 0)     # True
print("a" in "Hallo") # False
print("H" in "Hallo") # True

bool ist ein Untertyp von int

Ueberraschung: In Python ist bool technisch eine Unterklasse von int! True ist 1 und False ist 0.

print(True + True)     # 2
print(False + 1)       # 1
print(True * 10)       # 10

# Das kann nuetzlich sein:
noten = [True, False, True, True, False]
print(sum(noten))  # 3 -- zaehlt die True-Werte!

None — Der “leere” Wert

None ist Pythons Art zu sagen: “Hier ist kein Wert.” Es ist weder 0, noch "", noch False — es ist das voellige Fehlen eines Wertes.

ergebnis = None

print(ergebnis)        # None
print(type(ergebnis))  # <class 'NoneType'>

Wofuer braucht man None?

# 1. Variable ohne Anfangswert
benutzereingabe = None

# 2. Funktionen, die nichts zurueckgeben
def sage_hallo():
    print("Hallo!")

rueckgabe = sage_hallo()  # gibt "Hallo!" aus
print(rueckgabe)          # None

# 3. Optionale Parameter
def begruessung(name=None):
    if name is None:
        print("Hallo, Unbekannter!")
    else:
        print(f"Hallo, {name}!")

begruessung()         # Hallo, Unbekannter!
begruessung("Max")    # Hallo, Max!

None richtig pruefen

Verwende immer is und is not fuer None-Vergleiche — nicht ==:

wert = None

# Richtig:
if wert is None:
    print("Kein Wert vorhanden")

if wert is not None:
    print("Wert vorhanden")

# Falsch (funktioniert meistens, ist aber schlechter Stil):
if wert == None:
    print("Nicht empfohlen!")

Type Casting — Typen umwandeln

Du kannst Werte von einem Typ in einen anderen konvertieren:

int() — In Ganzzahl umwandeln

print(int(3.7))       # 3     -- Nachkommastellen abgeschnitten!
print(int(3.2))       # 3     -- NICHT gerundet, sondern abgeschnitten
print(int("42"))      # 42    -- String zu int
print(int(True))      # 1
print(int(False))     # 0

# Das geht NICHT:
# print(int("3.14"))  # ValueError!
# print(int("Hallo")) # ValueError!

float() — In Gleitkommazahl umwandeln

print(float(42))       # 42.0
print(float("3.14"))   # 3.14
print(float("42"))     # 42.0
print(float(True))     # 1.0

str() — In String umwandeln

print(str(42))         # "42"
print(str(3.14))       # "3.14"
print(str(True))       # "True"
print(str(None))       # "None"

# Nuetzlich beim Zusammenfuegen:
alter = 25
print("Ich bin " + str(alter) + " Jahre alt.")

bool() — In Wahrheitswert umwandeln

print(bool(1))       # True
print(bool(0))       # False
print(bool(42))      # True    -- jede Zahl ausser 0 ist True
print(bool(""))      # False   -- leerer String ist False
print(bool("Hallo")) # True    -- nicht-leerer String ist True
print(bool(None))    # False
print(bool([]))      # False   -- leere Liste ist False
print(bool([1, 2]))  # True

type() und isinstance()

Du kennst bereits type(). Fuer Typ-Pruefungen gibt es auch isinstance():

alter = 25

# type() gibt den exakten Typ zurueck
print(type(alter))  # <class 'int'>
print(type(alter) == int)  # True

# isinstance() prueft, ob ein Objekt von einem bestimmten Typ ist
print(isinstance(alter, int))    # True
print(isinstance(alter, float))  # False

# isinstance() kann mehrere Typen auf einmal pruefen:
print(isinstance(alter, (int, float)))  # True -- ist int ODER float

# isinstance() beruecksichtigt Vererbung:
print(isinstance(True, int))    # True -- bool ist Unterklasse von int
print(type(True) == int)        # False -- type() prueft exakt

Faustregel: Verwende isinstance() statt type() fuer Typ-Pruefungen, weil es auch Vererbung beruecksichtigt.

Truthy und Falsy Werte

In Python hat jeder Wert einen Wahrheitswert. Werte, die als False gelten, nennt man Falsy. Alles andere ist Truthy.

Falsy-Werte (werden als False behandelt)

# Alle Falsy-Werte in Python:
bool(False)     # False
bool(None)      # False
bool(0)         # False
bool(0.0)       # False
bool("")        # False   -- leerer String
bool([])        # False   -- leere Liste
bool(())        # False   -- leeres Tuple
bool({})        # False   -- leeres Dictionary
bool(set())     # False   -- leeres Set

Truthy-Werte (werden als True behandelt)

# Alles andere ist Truthy:
bool(1)          # True
bool(-1)         # True   -- auch negative Zahlen!
bool(42)         # True
bool("Hallo")   # True
bool([1, 2])    # True
bool(" ")       # True   -- String mit Leerzeichen ist NICHT leer!

Warum ist das wichtig?

Du kannst Truthy/Falsy direkt in if-Abfragen nutzen:

name = input("Dein Name: ")

# Statt:
if name != "":
    print(f"Hallo, {name}!")

# Kannst du schreiben:
if name:
    print(f"Hallo, {name}!")

# Leere Eingabe (leerer String) ist Falsy, also wird der Block uebersprungen

# Noch ein Beispiel:
suchergebnisse = []

if not suchergebnisse:
    print("Keine Ergebnisse gefunden.")
else:
    print(f"{len(suchergebnisse)} Ergebnisse gefunden.")

Uebersichtstabelle aller Grundtypen

Alle Grundtypen sind unveraenderlich (immutable). Das bedeutet: Wenn du den “Wert aenderst”, erstellst du in Wirklichkeit ein neues Objekt.

x = 5
print(id(x))  # z.B. 140234866877584

x = x + 1
print(id(x))  # z.B. 140234866877616 -- neue ID! Neues Objekt!

Uebungen

Uebung 1: Typen erkennen

Welchen Typ haben die folgenden Werte? Ueberlege zuerst, dann pruefe mit type():

a = 100
b = 100.0
c = "100"
d = True
e = None
f = 0
g = ""
h = "False"

# Pruefe deine Vermutungen:
print(type(a))  # ?
print(type(b))  # ?
print(type(c))  # ?
# ... und so weiter

Uebung 2: Type Casting

Konvertiere die folgenden Werte und beobachte das Ergebnis:

# String zu Zahl
zahl = int("123")
print(zahl, type(zahl))

# Zahl zu String
text = str(456)
print(text, type(text))

# Float zu Int (was passiert mit den Nachkommastellen?)
ganzzahl = int(7.89)
print(ganzzahl)  # Was kommt raus?

# Was passiert hier?
# ergebnis = int("Hallo")
# Probiere es aus und lies die Fehlermeldung!

Uebung 3: Truthy/Falsy

Sage vorher, ob die folgenden Ausdruecke True oder False ergeben:

print(bool(1))           # ?
print(bool(0))           # ?
print(bool(-1))          # ?
print(bool(""))          # ?
print(bool(" "))         # ?
print(bool("0"))         # ?
print(bool([]))          # ?
print(bool([0]))         # ?
print(bool(None))        # ?
print(bool(0.0001))      # ?

Uebung 4: Benutzereingabe verarbeiten

Schreibe ein Programm, das den Benutzer nach Vor- und Nachname sowie Geburtsjahr fragt. Berechne das Alter und gib alles formatiert aus:

vorname = input("Vorname: ")
nachname = input("Nachname: ")
geburtsjahr = int(input("Geburtsjahr: "))

alter = 2026 - geburtsjahr

print(f"{vorname} {nachname} ist {alter} Jahre alt.")
print(f"Typ von alter: {type(alter)}")
print(f"Typ von vorname: {type(vorname)}")

alter: int = 25
name: str = "Max"
preis: float = 9.99
aktiv: bool = True

def begruessung(name: str) -> str:
    return f"Hallo, {name}!"