Neueste Python-Funktionen

Dieser Artikel erklärt die neuesten Funktionen von Python.

Wir erläutern die wichtigsten Funktionen der Python-Generationen 3.12 bis 3.13 Schritt für Schritt aus einer praxisnahen Perspektive der 'sofort einsetzbaren' Anwendungen.

YouTube Video

Neueste Python-Funktionen

In den letzten Jahren hat sich Python nicht nur auf die 'Leichtigkeit des Schreibens', sondern auch auf 'Robustheit, Geschwindigkeit und Lesbarkeit' konzentriert weiterentwickelt. Im Folgenden stellen wir die wichtigsten Neuerungen der Python-Generationen 3.12 bis 3.13 vor.

Dramatische Verbesserungen der Fehlermeldungen (Python 3.12)

In Python 3.12 werden Fehler nun konkreter und anschaulicher dargestellt. Fehlerstellen können sofort erkannt und die Debugging-Zeit deutlich reduziert werden.

1def calc_total(price, tax):
2    return price + price * tax
3
4result = calc_total(100, )

• Fehlende Argumente werden zusammen mit der entsprechenden Zeile und Position angezeigt, sodass keine Verwirrung bei der Fehlersuche entsteht.

Praktischer Einsatz der 'match'-Anweisung (Strukturelles Pattern Matching)

Die 'match'-Anweisung ermöglicht es, komplexe Verzweigungen und die Unterscheidung von Datenstrukturen deklarativ zu formulieren. Das Arbeiten mit Dictionaries und verschachtelten Strukturen wird damit deutlich lesbarer.

1user = {"status": "active", "name": "Alice"}
2
3match user:
4    case {"status": "active", "name": name}:
5        print(f"Welcome back, {name}!")
6    case {"status": "inactive"}:
7        print("Please activate your account.")
8    case _:
9        print("Unknown user status.")

• Da Bedingungsabfragen und Datenauswertung gleichzeitig erfolgen können, wird das Verschachteln von if-Anweisungen überflüssig.

Intuitives Pattern Matching für die Verarbeitung verschachtelter Daten

Die 'match'-Anweisung ist auch für strukturierte Daten wie JSON oder API-Antworten sehr effektiv.

1data = {"user": {"name": "Bob", "age": 25}}
2
3match data:
4    case {"user": {"name": name, "age": age}}:
5        print(f"{name} is {age} years old.")

• Man kann gezielt nur die benötigten Elemente extrahieren, ohne defensiven Code schreiben zu müssen.

Erweiterte f-String-Debug-Ausgabe (`= Notation / Python 3.8 und später, verbesserte Bedienbarkeit)

Mit f-Strings kann man jetzt durch Hinzufügen von = sowohl den Ausdruck selbst als auch das Auswertungsergebnis gleichzeitig anzeigen lassen. Dieses Feature ist speziell fürs Debugging gedacht und besonders nützlich, wenn man schnell den Inhalt einer Variable überprüfen möchte.

1x = 10
2y = 20
3print(f"{x=}, {y=}, {x+y=}")

• Da Variablennamen und Werte zusammen angezeigt werden, werden temporäre Debug-Ausgaben mit print() viel übersichtlicher.
• Log-Ausgaben und Überprüfungscode können so prägnanter und ausdrucksstärker geschrieben werden.

Vereinfachte Type Hints und 'type'-Alias (Python 3.12: Neue Syntax für Typ-Aliase)

In Python 3.12 wurde eine eigene Syntax für die Definition von Typ-Aliasen — die type-Anweisung — eingeführt. Dadurch dienen Type Hints nicht nur als Zusatzinformation, sondern auch als Sprachelement zur klaren Ausdruck des Designziels.

1type UserId = int
2type UserName = str
3
4def greet(user_id: UserId, name: UserName) -> str:
5    return f"Hello, {name} (id={user_id})"

• Indem UserId oder UserName Bedeutung gegeben wird, können die unterschiedlichen Rollen auch dann deutlich gemacht werden, wenn beide denselben Typ int oder str verwenden.
• Typdefinitionen werden kompakter und die Verständniskosten bei Code-Reviews und Wartung sinken.
• Früher wurden Typ-Aliase wie UserId = int per Zuweisung erstellt, aber durch die Verwendung der type-Anweisung wird explizit klargestellt, dass es sich um eine Typdefinition handelt. Das ist besonders wirkungsvoll, um die Lesbarkeit des Designs in mittelgroßen und größeren Codebasen zu verbessern.

Natürliche Typannotationen mit eingebauten Typen (vereinfachte Generics ab Python 3.9+)

Seit Python 3.9 kann man eingebaute Typen wie list oder dict direkt als Generics angeben.

Dadurch kann man intuitive und lesbare Type Hints schreiben, ohne Typen aus dem typing-Modul importieren zu müssen.

1def sum_numbers(numbers: list[int]) -> int:
2    return sum(numbers)
3
4print(sum_numbers([1, 2, 3, 4]))

• Type Hints dienen nicht als 'Einschränkung', sondern als 'Dokumentation, die den Verarbeitungsinhalt erläutert'.

Sicheres Method Chaining mit dem Self-Typ (Python 3.11 und später)

Seit Python 3.11 kann Self als Rückgabetyp für Methoden genutzt werden, die die Klasse selbst zurückgeben.

Damit lassen sich Methodenverkettungen sicher schreiben, ohne dass Typinformationen verloren gehen.

 1from typing import Self
 2
 3class Counter:
 4    def __init__(self, value: int = 0) -> None:
 5        self.value = value
 6
 7    def increment(self) -> Self:
 8        self.value += 1
 9        return self
10
11counter = Counter()
12counter.increment().increment()
13print(counter.value)

• Auch bei Methoden, die self zurückgeben, bleibt nun immer der richtige Rückgabewert erhalten.
• IDEs und Typprüfer können Methodenverkettungen dadurch korrekt nachvollziehen.

Klarere Zeichenkettenmanipulation (removeprefix / removesuffix | Python 3.9 und später)

Ab Python 3.9 gibt es mit str.removeprefix() und str.removesuffix() spezielle Methoden, um Präfixe und Suffixe sicher zu entfernen. Damit lässt sich die Absicht 'nur Anfang oder Ende entfernen' im Code präzise ausdrücken.

1filename = "report_2026.txt"
2
3clean_name = filename.removeprefix("report_")
4name_without_ext = clean_name.removesuffix(".txt")
5
6print(name_without_ext)

• Der angegebene String wird nur entfernt, wenn er tatsächlich am Anfang oder Ende steht — unbeabsichtigte Ersetzungen entfallen.
• Diese Methode ist lesbarer und sicherer als die Verwendung von replace() oder Slicing.
• Gerade bei 'Zeichenketten mit festem Format', wie Dateinamen oder URLs, kann die Verwendung dieser Methoden das Fehlerrisiko erheblich reduzieren.

Robuster Zeichenkettenvergleich für Internationalisierung (str.casefold() | Unicode-Support)

str.casefold() in Python ist eine Methode für Groß-/Kleinschreibungs-unempfindliche Vergleiche unter Berücksichtigung von Unicode. Im Unterschied zu einfachem lower() oder upper() normalisiert casefold() Zeichenketten einschließlich sprachspezifischer Zeichenumwandlungen.

1text1 = "Stra\u00dfe"
2text2 = "strasse"
3
4print(text1)
5print(text2)
6
7print(f"Comparison Result: {text1.casefold() == text2.casefold()}")

• Es kann sprachabhängige Unterschiede, wie z.B. das deutsche ß und ss, korrekt behandeln.
• Dies ist eine unverzichtbare Technik für Anwendungen mit Mehrsprachigkeit oder Internationalisierung.

Standard TOML-Unterstützung (tomllib | Python 3.11 und später)

Seit Python 3.11 ist das Modul tomllib zur TOML-Konfigurationsdatei-Lesung fester Bestandteil der Standardbibliothek. Konfigurationsmanagement kann nun komplett in Python erfolgen, ohne von externen Bibliotheken abhängig zu sein.

 1import tomllib
 2
 3with open("config.toml", "rb") as f:
 4    config = tomllib.load(f)
 5
 6print(config["database"]["host"])
 7
 8# config.toml
 9# title = "TOML Example"
10# [database]
11# host = "192.168.1.1"
12# ports = [ 8001, 8001, 8002 ]

• Externe Pakete wie toml werden damit überflüssig — das vereinfacht die Abhängigkeiten.
• Das Laden von Konfigurationsdateien ist standardisiert, was Verteilung, Betrieb und CI-Umgebungen vereinfacht.

Exception-Handling fürs Zeitalter von Parallelverarbeitung (ExceptionGroup / except* | Python 3.11 und später)

Python 3.11 hat ExceptionGroup eingeführt, um mehrere Fehler gemeinsam zu verarbeiten, sowie die neue Syntax except*, um sie sicher aufzuteilen. Damit können 'gleichzeitige Fehler' etwa bei asynchroner oder paralleler Verarbeitung behandelt werden.

 1def process(values):
 2    errors = []
 3    for v in values:
 4        if v < 0:
 5            errors.append(ValueError(f"Negative value: {v}"))
 6    if errors:
 7        raise ExceptionGroup("Invalid values", errors)
 8
 9try:
10    process([1, -2, -3])
11except* ValueError as e:
12    print("Handled:", e)

• Mehrere Fehler können nun in einer einzigen Aktion ausgelöst und klassifiziert werden.
• Das löst das Problem, dass bei asynchronen Vorgängen bisher oft nur der erste Fehler sichtbar war.
• Bei Vorgängen wie asyncio.gather() oder paralleler Batchverarbeitung können gleichzeitig mehrere Fehlerursachen auftreten. Mit ExceptionGroup lassen sich Fehlererfassung, Logging und Wiederholungsstrategien einfacher strukturieren.

Durch das Update auf die neueste Version verbessert sich die Performance automatisch

Seit Python 3.11 wurden durch interne Optimierungen viele Abläufe beschleunigt.

1def count_up(n):
2    total = 0
3    for i in range(n):
4        total += i
5    return total
6
7print(count_up(1_000_000))

• Der größte Vorteil: Die Geschwindigkeitssteigerungen greifen, ohne dass Sie Ihren Code umschreiben müssen.

Steuerung der Speicherbereinigung (GC) über das Modul gc

Mit dem Standardmodul gc lässt sich die automatische Speicherbereinigung in Python vorübergehend ausschalten oder manuell anstoßen. Das ist eine effektive Optimierung bei der Stapelverarbeitung großer Datenmengen oder in performancekritischen Anwendungsfällen.

1import gc
2
3gc.disable()
4# heavy batch processing
5gc.enable()
6gc.collect()

• Das Unterdrücken unnötiger Speicherbereinigung kann Schwankungen in der Bearbeitungszeit verringern.
• Mit expliziter Sammlung zu festen Zeitpunkten lässt sich der Speicherverbrauch leichter kontrollieren.
• Diese Technik sollte jedoch nicht standardmäßig eingesetzt werden, sondern nur dann, wenn ein Profiling belegt, dass GC ein Engpass ist. Für die meisten Anwendungen empfiehlt es sich, auf Pythons automatische Speicherbereinigung zu vertrauen.

Zusammenfassung

Mit den Verbesserungen bei Fehlermeldungen und der Weiterentwicklung der Type Hints in Python 3.12 bis 3.13 ist das Verständnis und die Wartung von Code einfacher geworden als je zuvor. Hinzu kommen Verbesserungen wie eine bessere Debugging-Erfahrung und Performance-Steigerungen durch interne Optimierungen, die direkt zu steigender Produktivität beitragen. All diese neuen Funktionen müssen nicht sofort auf einmal genutzt werden; es ist sinnvoll, mit der neuesten Python-Version zu starten und Funktionen nach Bedarf schrittweise einzusetzen. Dieser allmähliche Einsatz führt zu besser lesbarem und robustem Python-Code.

Sie können den obigen Artikel mit Visual Studio Code auf unserem YouTube-Kanal verfolgen. Bitte schauen Sie sich auch den YouTube-Kanal an.

YouTube Video