Python-Variablennamen — Regeln, Konventionen und Best Practices

Ein Variablenname ist das Label, mit dem Python einen Wert im Speicher findet. Gute Namen machen deinen Code lesbar wie einen Satz; schlechte Namen lassen selbst dich eine Woche später rätseln, was das eigene Skript tut. Dieses Kapitel behandelt die harten Regeln, die Python erzwingt, die weichen Konventionen der Community (PEP 8), Fallstricke wie das Überschatten von Built-ins und spezielle Unterstrich-Muster — alles mit ausführbaren Beispielen.

Harte Regeln — Was Python verlangt

Vor den Konventionen kommen die Regeln. Wer eine davon bricht, erhält einen SyntaxError oder NameError.

Erlaubte Zeichen

Ein Variablenname darf Buchstaben (a-z, A-Z), Ziffern (0-9) und Unterstriche (_) enthalten. Er muss mit einem Buchstaben oder einem Unterstrich beginnen — niemals mit einer Ziffer. Leerzeichen, Bindestriche oder Sonderzeichen (%, #, @, -) sind nicht erlaubt.

# Valid names
user_name = "Alice"
_private = 42
value1 = 3.14
MAX_RETRIES = 5

# Invalid names — these all raise SyntaxError
# 1user = "bad"     # starts with a digit
# user-name = "bad" # hyphens are subtraction
# user name = "bad" # space is not allowed

Python unterscheidet Groß- und Kleinschreibung

username, Username und USERNAME sind drei völlig unterschiedliche Variablen. Das ist eine häufige Fehlerquelle für Einsteiger.

score = 10
Score = 20
SCORE = 30

print(score)   # 10
print(Score)   # 20
print(SCORE)   # 30

Reservierte Keywords dürfen nicht als Namen verwendet werden

Python reserviert bestimmte Wörter für die Sprache selbst. Wird eines davon als Variablenname verwendet, entsteht ein SyntaxError. Alle reservierten Keywords lassen sich mit dem keyword-Modul auflisten:

import keyword
print(keyword.kwlist)

Ausgabe (Python 3.12):

['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await',
 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except',
 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is',
 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try',
 'while', 'with', 'yield']

Häufige Fehler: list, str, int, type oder input als Variablennamen zu verwenden — das sind eingebaute Namen, keine reservierten Keywords. Python gibt daher keinen SyntaxError aus, aber das Built-in wird lautlos überschattet, was später zu verwirrenden Fehlern führt (siehe Built-ins überschatten weiter unten).

PEP-8-Namenskonventionen

PEP 8 ist Pythons offizieller Stilführer. Wer ihn befolgt, macht seinen Code für jeden Python-Entwickler sofort lesbar.

Konventionsübersicht

snake_case für Variablen und Funktionen

snake_case verwendet ausschließlich Kleinbuchstaben mit Unterstrichen zwischen Wörtern. Das ist der Standard für Variablen und Funktionen in Python.

# PEP 8 compliant
first_name = "Alice"
last_name = "Smith"
total_price = 9.99
items_in_cart = 3

# Not PEP 8 (camelCase) — works, but avoid for variables
firstName = "Alice"   # JavaScript style, not Pythonic

ALL_CAPS für Konstanten

Per Konvention signalisiert ein Name in Großbuchstaben: „Dieser Wert sollte nicht verändert werden." Python erzwingt keine Unveränderlichkeit, aber die Konvention wird allgemein verstanden.

MAX_CONNECTIONS = 100
TIMEOUT_SECONDS = 30
PI = 3.141592653589793

# Using the constant
if current_connections > MAX_CONNECTIONS:
    print("Connection limit reached")

CapWords für Klassen

Klassennamen verwenden CapWords (auch PascalCase genannt): Jedes Wort beginnt mit einem Großbuchstaben, keine Unterstriche.

class UserProfile:
    pass

class HttpRequestError(Exception):
    pass

Beschreibende und aussagekräftige Namen

Der beste Variablenname verrät dem nächsten Leser was der Wert darstellt, nicht wie er gespeichert ist. Strebe nach Namen, die eine Codezeile wie einen Satz lesen lassen.

# Unclear
r = 5
a = 3.14159 * r ** 2

# Clear
radius = 5
circle_area = 3.14159 * radius ** 2

print(circle_area)  # 78.53975

Wann kurze Namen in Ordnung sind

Einbuchstabige Namen (x, y, i, n) sind in engen, allgemein verständlichen Kontexten akzeptabel:

• Schleifenzähler: for i in range(10):
• Mathematische Formeln: y = m * x + b
• Koordinaten: (x, y) oder (row, col)

Außerhalb dieser Kontexte sollte man auch bei längeren Namen auf etwas Beschreibendes zurückgreifen.

Unnötige Abkürzungen vermeiden

Abkürzungen sparen Tastenanschläge, kosten aber Lesbarkeit. Verwende vollständige Wörter, sofern die Abkürzung nicht allgemein bekannt ist.

# Unclear abbreviations
usr_nm = "alice"
tot_amt = 49.95
n_itm = 7

# Clear full names
username = "alice"
total_amount = 49.95
number_of_items = 7

Weithin akzeptierte Abkürzungen, die beibehalten werden dürfen: url, id, http, db, idx, num.

Unterstrich-Muster

Python verwendet Unterstriche in Variablennamen, um Absichten zu kommunizieren. Das Verständnis dieser Muster hilft beim Lesen jeder Python-Codebasis.

_single_leading — interner Gebrauch

Ein Name, der mit einem Unterstrich beginnt, ist ein Signal an andere Entwickler: „Das ist ein Implementierungsdetail; verlasse dich nicht von außerhalb dieses Moduls oder dieser Klasse darauf." Python erzwingt dies nicht — es ist reine Konvention.

class DataLoader:
    def __init__(self, path):
        self.path = path
        self._cache = {}   # internal; not part of the public API

    def load(self):
        if self.path not in self._cache:
            self._cache[self.path] = self._read_file()
        return self._cache[self.path]

    def _read_file(self):
        # "private" helper
        with open(self.path) as f:
            return f.read()

from module import * überspringt ebenfalls Namen, die mit _ beginnen.

__double_leading — Name Mangling

Zwei führende Unterstriche lösen Pythons Name Mangling aus: __attr innerhalb der Klasse Foo wird als _Foo__attr gespeichert. Das verhindert versehentliches Überschreiben in Unterklassen.

class Base:
    def __init__(self):
        self.__secret = "hidden"

obj = Base()
# print(obj.__secret)      # AttributeError
print(obj._Base__secret)   # "hidden" — mangled name

Name Mangling sollte sparsam eingesetzt werden, da es das Debugging erschwert.

__dunder__ — spezielle Methoden

Namen, die auf beiden Seiten von doppelten Unterstrichen umgeben sind, sind Pythons eingebaute spezielle („Dunder"-)Methoden und Attribute. Erfinde niemals eigene __name__-Variablen — Python reserviert diesen Namensraum.

class Point:
    def __init__(self, x, y):   # called when an instance is created
        self.x = x
        self.y = y

    def __repr__(self):          # called by repr() and in the REPL
        return f"Point({self.x}, {self.y})"

p = Point(3, 4)
print(p)          # Point(3, 4)
print(repr(p))    # Point(3, 4)

_ als Wegwerfvariable

Ein einzelner Unterstrich _ wird per Konvention als „egal"-Variable verwendet, wenn ein Wert aufgefangen werden muss, aber nicht genutzt wird.

# Unpack a tuple but only use two of three values
x, _, z = (1, 2, 3)
print(x, z)  # 1 3

# Loop counter when the index is not needed
for _ in range(5):
    print("hello")

Built-ins überschatten

Pythons eingebaute Namen (list, str, int, dict, type, input, print, id, min, max, sum, open, …) sind keine Keywords, daher erlaubt Python stillschweigend ihre Wiederverwendung als Variablennamen. Das ist fast immer ein Fehler.

# Dangerous — shadows the built-in list type
list = [1, 2, 3]
print(list)           # [1, 2, 3] — seems fine

new = list([4, 5])    # TypeError: 'list' object is not callable

Sobald list = [1, 2, 3] zugewiesen ist, verweist der Name list in diesem Gültigkeitsbereich nicht mehr auf den eingebauten Konstruktor. Die Lösung besteht einfach darin, einen anderen Namen zu wählen.

# Safe
numbers = [1, 2, 3]
more_numbers = list([4, 5])  # list() still works
print(more_numbers)          # [4, 5]

Häufig versehentlich überschattete Built-ins: id, input, type, str, int, float, list, dict, set, tuple, min, max, sum, filter, map, open, print.

Gültigkeitsbereich und Variablennamen

Ein Variablenname ist nur innerhalb des Gültigkeitsbereichs (Scope) sichtbar, in dem er definiert wurde. Zwei Variablen in verschiedenen Gültigkeitsbereichen können denselben Namen haben, ohne zu kollidieren — das kann jedoch zu Verwirrung führen.

total = 0          # module-level variable

def calculate(prices):
    total = 0      # local variable — does NOT overwrite the module-level one
    for price in prices:
        total += price
    return total

result = calculate([10, 20, 30])
print(result)      # 60
print(total)       # 0  — unchanged

Mehr darüber, wie Python Namen auflöst (die LEGB-Regel), findest du unter Python Scope. Um globale Variablen und das global-Keyword zu verstehen, siehe Global Variables in Python.

Kurzreferenz

# Hard rules
user1 = "ok"        # letters, digits, underscores — fine
_private = "ok"     # leading underscore — fine
# 1user = "bad"     # SyntaxError: starts with digit
# my-var = "bad"    # SyntaxError: hyphens not allowed

# PEP 8 conventions
snake_case_var = 42           # variables and functions
MAX_VALUE = 100               # constants
# class names use CapWords (PascalCase)

# Underscore patterns
_internal = "internal use"    # single leading: hint "private"
_ = "throwaway"               # lone underscore: discard value

# What to avoid
# list = []      # shadows built-in
# str = "hello"  # shadows built-in
# if = True      # SyntaxError: reserved keyword

Eine umfassendere Einführung dazu, wie Variablen in Python erstellt und zugewiesen werden, findest du unter Python Variables. Wie verwandte Variablen zusammengefasst werden, wird unter Group Variables in Python erklärt.

Übungen