Python-Variablen verstehen: Ein umfassender Leitfaden

Eine Variable ist ein benanntes Label, das auf einen im Speicher abgelegten Wert zeigt. Variablen sind die wichtigste Methode, um Daten in einem Python-Programm zu speichern, weiterzugeben und zu transformieren. Im Gegensatz zu einigen anderen Sprachen müssen Sie in Python keinen Typ deklarieren — Sie weisen einfach einen Wert zu, und Python bestimmt den Typ automatisch.

Diese Seite behandelt:

• Wie man Variablen erstellt und ihnen Werte zuweist
• Dynamische Typisierung — was das in der Praxis bedeutet
• Mehrfachzuweisung und Tuple-Unpacking
• Erweiterte Zuweisungsoperatoren
• Den Typ einer Variablen mit type() prüfen
• Den speziellen Wert None
• Variablen mit del löschen
• Grundlagen des Gültigkeitsbereichs von Variablen

Verwandte Kapitel: Variablennamen · Variablen ausgeben · Mehrere Werte zuweisen · Python-Datentypen · Globale Variablen · Python-Gültigkeitsbereich

Eine Variable erstellen

Um eine Variable zu erstellen, schreiben Sie einen Namen, dann =, dann den Wert. Python erstellt die Variable und bindet sie sofort an diesen Wert.

Einen string zuweisen und ausgeben

John Doe

Hier ist name der Variablenname und "John Doe" der Wert. Das =-Zeichen ist der Zuweisungsoperator — es ist kein Gleichheitstest (dafür verwendet man ==).

Für Variablennamen gelten einige Regeln:

• Muss mit einem Buchstaben oder einem Unterstrich (_) beginnen, nie mit einer Ziffer.
• Kann Buchstaben, Ziffern und Unterstriche enthalten.
• Ist Groß-/Kleinschreibung-sensitiv — score, Score und SCORE sind drei verschiedene Variablen.
• Darf kein Python-Schlüsselwort wie if, for, while oder class sein.

Der Python-Stil (PEP 8) empfiehlt snake_case für Variablennamen: Kleinbuchstaben-Wörter, verbunden durch Unterstriche, wie first_name oder total_price. Weitere Benennungskonventionen finden Sie unter Variablennamen.

Dynamische Typisierung

Python ist dynamisch typisiert: Eine Variable hat keinen festen Typ. Der Typ wird durch den aktuell zugewiesenen Wert bestimmt und kann sich bei einer Neuzuweisung ändern.

x = 10
print(type(x))   # <class 'int'>

x = "hello"
print(type(x))   # <class 'str'>

x = 3.14
print(type(x))   # <class 'float'>

<class 'int'>
<class 'str'>
<class 'float'>

Diese Flexibilität ist praktisch, ist aber auch eine häufige Fehlerquelle: Wenn Sie versehentlich eine Variable mit einem Wert des falschen Typs überschreiben, warnt Python Sie nicht — nur ein TypeError (oder ein falsches Ergebnis) zur Laufzeit zeigt das Problem an. Typ-Hinweise (z. B. x: int = 10) sind eine Möglichkeit, die Absicht zu dokumentieren und solche Fehler frühzeitig mit einem Typprüfer zu erkennen. Weitere Details finden Sie unter Python Type Hints.

Den Typ einer Variablen prüfen

Verwenden Sie die eingebaute Funktion type(), um zu prüfen, welchen Typ eine Variable aktuell enthält:

name = "Alice"
age = 30
price = 9.99
active = True

print(type(name))    # <class 'str'>
print(type(age))     # <class 'int'>
print(type(price))   # <class 'float'>
print(type(active))  # <class 'bool'>

<class 'str'>
<class 'int'>
<class 'float'>
<class 'bool'>

type() ist besonders beim Debuggen nützlich — wenn eine Variable einen unerwarteten Typ enthält, ist print(type(x)) der schnellste Weg, um zu bestätigen, was sie tatsächlich enthält.

Variablen für jeden Datentyp

Python verfügt über eine umfangreiche Menge an eingebauten Typen. Hier ist ein einzelner Block, der eine Variable jeden gängigen Typs erstellt, damit Sie das Benennungsmuster auf einen Blick sehen können:

Variablen verschiedener Typen zuweisen

integer_val  = 10                          # int
float_val    = 10.5                        # float
complex_val  = 10 + 5j                     # complex
string_val   = "Hello, World!"             # str
bool_val     = True                        # bool
list_val     = [1, 2, 3, 4, 5]            # list  (mutable, ordered)
tuple_val    = (1, 2, 3, 4, 5)            # tuple (immutable, ordered)
dict_val     = {"key1": "value1"}          # dict  (key-value pairs)
set_val      = {1, 2, 3, 4, 5}            # set   (unique, unordered)
none_val     = None                        # NoneType

Einen tiefen Einblick darin, wann welcher Typ zu wählen ist, finden Sie unter Python-Datentypen.

Mehrfachzuweisung

Denselben Wert mehreren Variablen zuweisen

Sie können = verketten, um denselben Wert in einer Zeile mehreren Variablen zuzuweisen:

a = b = c = 0
print(a, b, c)

0 0 0

Dies ist nützlich für die Initialisierung von Zählern oder Flags, aber bei veränderbaren Objekten ist Vorsicht geboten — a = b = c = [] lässt alle drei Namen auf dieselbe Liste zeigen, sodass eine Änderung an einem alle drei beeinflusst.

Tuple-Unpacking

Weisen Sie verschiedenen Variablen in einer Zeile unterschiedliche Werte zu, indem Sie sie mit Kommas trennen:

x, y, z = 1, 2, 3
print(x, y, z)

1 2 3

Python ordnet die rechtsseitigen Werte den linksseitigen Namen der Reihe nach zu. Die Anzahl der Namen muss der Anzahl der Werte entsprechen, sonst erhalten Sie einen ValueError. Für Stern-Unpacking (*) und verschachteltes Unpacking, siehe Mehrere Werte zuweisen.

Erweiterte Zuweisungsoperatoren

Eine erweiterte Zuweisung kombiniert eine Operation mit der Zuweisung in einem einzigen Schritt. Anstatt count = count + 1 zu schreiben, schreiben Sie count += 1:

count = 0
count += 1    # same as count = count + 1
print(count)  # 1

total = 100
total -= 25   # same as total = total - 25
print(total)  # 75

price = 10.0
price *= 1.2  # same as price = price * 1.2
print(price)  # 12.0

1
75
12.0

Der vollständige Satz erweiterter Zuweisungsoperatoren ist +=, -=, *=, /=, //=, %=, **=, &=, |=, ^=, >>= und <<=. Sie funktionieren mit jedem Typ, der den zugrunde liegenden Operator unterstützt — zum Beispiel verkettet += bei einem string:

message = "Hello"
message += ", World!"
print(message)

Hello, World!

Rechnen mit Variablen

Variablen, die Zahlen enthalten, können in arithmetischen Ausdrücken verwendet werden. Python wertet den Ausdruck aus und gibt einen neuen Wert zurück:

Mathematik mit Variablen

a = 10
b = 20

print(a + b)   # addition       → 30
print(b - a)   # subtraction    → 10
print(a * b)   # multiplication → 200
print(b / a)   # division       → 2.0  (always float in Python 3)
print(b // a)  # floor division → 2
print(b % a)   # modulo         → 0

30
10
200
2.0
2
0

Beachten Sie, dass / in Python 3 immer ein float zurückgibt, auch wenn das Ergebnis eine ganze Zahl ist. Verwenden Sie //, wenn Sie einen ganzzahligen Quotienten benötigen.

Die vollständige Liste der Operatoren (bitweise, Vergleich, logisch, Mitgliedschaft, Identität) finden Sie unter Python-Operatoren.

Der spezielle Wert None

None ist Pythons Art, „kein Wert" oder „nichts" darzustellen. Es ist der einzige Wert des Typs NoneType:

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

None
<class 'NoneType'>
True

Prüfen Sie None immer mit is None (Identitätsprüfung), nicht mit == None (Gleichheitsprüfung). Funktionen, die keinen Wert explizit mit return zurückgeben, geben standardmäßig None zurück.

Eine Variable löschen

Verwenden Sie die del-Anweisung, um einen Variablennamen aus dem aktuellen Gültigkeitsbereich zu entfernen. Nach dem Löschen löst das Referenzieren des Namens einen NameError aus:

temp = "temporary value"
print(temp)  # temporary value

del temp
# print(temp)  # NameError: name 'temp' is not defined

del wird am häufigsten verwendet, um Speicher explizit freizugeben (z. B. nach der Verarbeitung eines großen Datensatzes) oder um lokalen Zustand zu bereinigen. Es entfernt die Namensbindung, nicht notwendigerweise das zugrunde liegende Objekt — Pythons Garbage Collector gibt den Speicher des Objekts frei, wenn keine Namen mehr darauf zeigen.

Grundlagen des Gültigkeitsbereichs von Variablen

Wo eine Variable zugänglich ist, hängt davon ab, wo sie definiert ist. Die zwei häufigsten Gültigkeitsbereiche sind:

• Lokaler Gültigkeitsbereich — eine Variable, die innerhalb einer Funktion erstellt wird, existiert nur für die Lebensdauer dieses Funktionsaufrufs.
• Globaler Gültigkeitsbereich — eine Variable, die auf der obersten Ebene eines Moduls erstellt wird, ist von überall in diesem Modul aus zugänglich.

message = "I am global"   # global variable

def greet():
    greeting = "Hello"    # local variable — not accessible outside
    print(greeting)
    print(message)        # can read global variable

greet()
# print(greeting)  # NameError — greeting does not exist here

Hello
I am global

Das Ändern einer globalen Variablen innerhalb einer Funktion erfordert das Schlüsselwort global. Weitere Informationen zur vollständigen LEGB-Regel finden Sie unter Globale Variablen und Python-Gültigkeitsbereich.

Übungen