Python Konstanten: So nutzt du sie als Azubi, Student & Einsteiger

Du sitzt an deinem ersten großen Python-Projekt in der Umschulung, im Studium oder im neuen Job. Dein Programm berechnet die MwSt für einen Online-Shop. In Zeile 42 rechnest du `preis * 0.19`. In Zeile 87 hast du die gleiche Rechnung. Wenn der Steuersatz nun vom Gesetzgeber auf 21 % steigt, musst du jede einzelne Zahl im Code manuell suchen und ersetzen. Das ist fehleranfällig und nervt.

Genau hier kommen Python Konstanten ins Spiel. Sie sind das Werkzeug deiner Wahl, um feste Werte zentral zu speichern. Das macht deinen Code nicht nur lesbarer, sondern spart dir bei Änderungen Stunden an Fehlersuche. In diesem Artikel erfährst du, wie du sie richtig einsetzt, auch wenn Python es dir不像 andere Sprachen leicht macht.

Was sind Python Konstanten?

Python Konstanten sind im Grunde Variablen, denen du einen Wert zuweist, der während der gesamten Laufzeit deines Programms unverändert bleiben soll. Denk an den Wert Pi (3,14159...) oder die Anzahl der Stunden an einem Tag (24). Diese Werte sind "festgezurrt".

Wichtig: In Python gibt es technisch gesehen keinen harten Schutz, der verhindert, dass du den Wert später änderst. Python vertraut auf die Disziplin der Entwickler:innen. Das unterscheidet Python stark von Sprachen wie Java, wo du das Schlüsselwort `final` nutzt.

Als Einsteiger musst du dich also an strikte Regeln halten, damit dein Code professionell bleibt. Der Schlüssel dazu ist die Namensgebung.

Wie definierst du Python Konstanten richtig?

Die Definition ist simpel, aber die Einhaltung der Regeln ist entscheidend. Du schreibst Konstanten wie normale Variablen, nutzt aber ausschließlich Großbuchstaben. Besteht der Name aus mehreren Wörtern, trennst du diese durch Unterstriche. Das nennt man `UPPER_SNAKE_CASE`.

Warum ist das so wichtig? Jeder andere Entwickler (oder du selbst in sechs Monaten) erkennt sofort: "Oh, das ist in Großbuchstaben geschrieben, das ist eine Konstante - Finger weg!" Diese Regel ist in der offiziellen Style-Guide für Python, dem sogenannten PEP 8, festgehalten.

So sieht das in der Praxis aus:

# Richtig: Konstanten in GROSSBUCHSTABEN
MWST_SATZ = 0.19
MAX_BENUTZER = 50
DB_PASSWORT = "sicheres_passwort_123"

# Falsch: Das sieht aus wie normale Variablen
mwst_satz = 0.19
maxBenutzer = 50

Wenn du diese Konvention befolgst, machst du deinen Code viel wartungsfreundlicher.

Wo platzierst du Konstanten in deinem Code?

Damit du und andere den Wert schnell finden, gilt eine goldene Regel: Konstanten kommen immer an den Anfang deiner Datei. Meistens direkt unter den `import`-Anweisungen.

Das ist besonders wichtig, wenn du später als Fachinformatiker größere Skripte wartest. Du willst nicht in Zeile 500 nach einem Einstellungswert suchen müssen.

Modul-Level vs. Klassen-Konstante

Es gibt zwei Hauptarten, wie du Konstanten anordnen kannst - je nachdem, wie dein Programm aufgebaut ist.

Hier ist ein Code-Beispiel, das den Unterschied zeigt:

# 1. Modul-Konstante (fuer das ganze Skript gueltig)
STANDORT = "Berlin"


class Auto:
    # 2. Klassen-Konstante (nur fuer diese Klasse relevant)
    MAX_SPEED = 250

    def zeige_daten(self):
        # Zugriff auf Klassen-Konstante und Modul-Konstante
        print(
            f"Dieses Auto faehrt maximal {Auto.MAX_SPEED} km/h in {STANDORT}."
        )


mein_auto = Auto()
mein_auto.zeige_daten()

Was sind "Magische Zahlen" und warum vermeidet man sie?

Ein klassischer Fehler bei Anfängern sind sogenannte "Magische Zahlen". Das sind harte Zahlenwerte, die einfach so im Code stehen. Wenn du `breite * 0.5` schreibst, weiß niemand, was die 0.5 bedeutet. Ist es die Hälfte? Ein Rabatt? Ein Faktor?

Indem du diese Zahl in eine Konstante auslagerst, dokumentierst du deinen Code.

Stell dir vor, du entwickelst ein kleines Spiel für ein Uni-Projekt. Du brauchst Bildschirmgrößen und Farben. Hexadezimal-Codes oder Zahlen sind schwer zu merken.

# Konfiguration fuer das Spiel
BILDSCHIRM_BREITE = 800
BILDSCHIRM_HOEHE = 600
FPS = 60  # Frames pro Sekunde

# Farben als RGB-Tupel (Rot, Gruen, Blau)
FARBE_ROT = (255, 0, 0)
FARBE_SCHWARZ = (0, 0, 0)


def zeichne_hintergrund():
    # Statt (0,0,0) schreiben, nutzen wir die Konstante
    print(f"Zeichne Hintergrund in {FARBE_SCHWARZ}")
    print(f"Fenster-Groesse: {BILDSCHIRM_BREITE}x{BILDSCHIRM_HOEHE}")


zeichne_hintergrund()

Achte darauf: Werte, die sich *ändern* (wie die aktuelle Punktzahl), sind keine Konstanten. Dort nutzt du ganz normale Variablen.

Welche 3 Fehler solltest du als Anfänger vermeiden?

Wenn du im Beruf oder Studium Code-Reviews durchläufst, fallen diese Fehler immer wieder auf. Vermeide sie, um direkt professionell zu wirken.

1. Konstanten versehentlich überschreiben

Da Python dich nicht technisch daran hindert, passiert es oft aus Versehen.

# Falsch: Der Wert wird geaendert
MAX_USER = 50
MAX_USER = 60  # Das verwirrt alle!

# Richtig: Konstanten bleiben gleich
MAX_USER = 50

2. Zahlen ohne Kontext nutzen

Wie oben erwähnt, machen "Magische Zahlen" den Code unleserlich.

# Falsch: Was bedeutet die 0.19?
gesamtpreis = netto_preis + (netto_preis * 0.19)

# Richtig: Selbsterklaerend durch Konstante
MWST_SATZ = 0.19
gesamtpreis = netto_preis + (netto_preis * MWST_SATZ)

3. Kleinschreibung bei festen Werten

Wenn du eine Konstante klein schreibst (`max_benutzer`), denken alle, es sei eine Variable, die sich ändern darf. Das verletzt die Standard-Konventionen und führt zu Fehlern in Teams.

Wie schützt du Konstanten vor Änderung in Python?

Wenn du besonders sicherheitskritische Software schreibst, reicht die Namenskonvention vielleicht nicht aus. Du kannst Konstanten mit einem kleinen Trick "schützen", indem du Klassen und den `@property`-Dekorator nutzt.

Das ist fortgeschritten, aber sehr effiziv. Wir erlauben das *Lesen* des Wertes, aber wer versucht, ihn zu *überschreiben*, bekommt eine Fehlermeldung (Exception).

class Einstellungen:
    def __init__(self):
        self._wichtiger_wert = 42  # Der eigentliche Wert ist "versteckt"

    @property
    def WICHTIGER_WERT(self):
        return self._wichtiger_wert

    @WICHTIGER_WERT.setter
    def WICHTIGER_WERT(self, wert):
        raise ValueError("Konstanten duerfen nicht geaendert werden!")


config = Einstellungen()
print(config.WICHTIGER_WERT)  # Das klappt: Ausgabe 42

# Das wirft einen Fehler und bricht das Programm ab:
# config.WICHTIGER_WERT = 99

Dein Übungstipp für heute

Nimm dir ein kleines Python-Skript von dir vor. Scanne es nach Zahlen (wie `100`, `0.5`, `24`) oder festen Strings (wie Dateipfade), die sich nicht ändern.

Ersetze diese "Magischen Zahlen" durch sprechende Konstanten am Anfang der Datei. Du wirst sehen: Der Code liest sich plötzlich wie flüssiger Text.

FAQ: Häufige Fragen zu Python Konstanten

Gibt es ein "const"-Schlüsselwort in Python?

Nein, im Gegensatz zu Sprachen wie C++ oder JavaScript gibt es in Python kein `const`-Schlüsselwort. Python setzt auf die Konvention der Großschreibung (UPPER_SNAKE_CASE), um Konstanten zu markieren.

Warum kann man Konstanten in Python trotzdem ändern?

Python ist eine sehr flexible Sprache. Die Philosophie ist "We are all consenting adults". Das bedeutet, der Compiler hindert dich nicht daran, Werte zu ändern, sondern vertraut darauf, dass du als Programmierer:in weißt, was du tust.

Wo speichere ich Konstanten in großen Projekten?

In großen Anwendungen erstellt man oft eine eigene Datei, zum Beispiel `config.py` oder `konstanten.py`. Dort sammelt man alle globalen Werte und importiert sie dort hin, wo sie gebraucht werden (z.B. `from config import MAX_USERS`).

Soll ich Konstanten auch für Strings nutzen?

Ja, absolut. Pfadangaben, Fehlernachrichten oder API-URLs solltest du ebenfalls als Konstanten definieren. Das macht es einfacher, deine Anwendung später in eine andere Umgebung zu verschieben.

Fazit

Python Konstanten sind ein essenzielles Werkzeug, um sauberen, wartbaren Code zu schreiben. Du hast gelernt, dass du sie durch Großschreibung (`UPPER_SNAKE_CASE`) definierst und sie am besten oben in deiner Datei oder einer separaten Config-Datei platzierst. Auch wenn Python dich technisch nicht daran hindert, sie zu ändern, solltest du dieser Regel strikt folgen, um "Magische Zahlen" zu vermeiden.

Das Verständnis solcher Grundlagen ist oft der Unterschied zwischen einem Anfänger-Skript und professioneller Software. Möchtest du mehr über solche Best Practices lernen oder bereitest du dich auf eine Prüfung vor? Auf study-it.education findest du Tutorien und Hilfe, die dich Schritt für Schritt zum Profi bringen.