Zum Inhalt springen
Michael Blaess
IT-Consulting
Michael Blaess
EN

Python 3.15 ist da. Lohnt sich der Umstieg?

6 Minuten Lesezeit PythonPython 3.15PerformanceProfiling

Am 9. Oktober 2026 ist Python 3.15 erschienen. Die Liste der Änderungen ist lang, und vieles davon betrifft nur Leute, die Erweiterungen in C schreiben.

Ich habe mir ein paar Punkte herausgesucht, die für mich im Alltag wirklich wichtig sind. Alle Beispiele in diesem Beitrag sind auf Python 3.15.0 unter Windows 11 gelaufen, die gezeigten Ausgaben sind die echten.

Die Neuerungen laufen in Python über sogenannte PEPs. Das steht für Python Enhancement Proposal, also einen Änderungsantrag mit Nummer. Wer zu einem Punkt mehr wissen will, findet unter dieser Nummer die ganze Begründung.

Lazy Imports: laden erst, wenn es gebraucht wird

Normalerweise lädt ein import am Dateianfang das Modul sofort. Python sucht die Datei, liest sie, übersetzt sie und führt sie aus. Bei einer Anwendung mit vielen Abhängigkeiten passiert das bei jedem Start, auch wenn der Aufruf nur --help ausgeben soll.

Mit PEP 810 gibt es dafür das neue Schlüsselwort lazy:

import sys

lazy import json
lazy from pathlib import Path

print("json geladen:", "json" in sys.modules)
print(json.dumps({"version": "3.15"}))
print("json geladen:", "json" in sys.modules)
print("pathlib geladen:", "pathlib" in sys.modules)
json geladen: False
{"version": "3.15"}
json geladen: True
pathlib geladen: False

json wird erst geladen, wenn es zum ersten Mal benutzt wird. pathlib wird in diesem Lauf nie gebraucht und deshalb auch nie geladen.

Wie viel das bringt, hängt davon ab, wie viel eine Anwendung importiert und davon nicht benutzt. Für einen Eindruck habe ich ein Skript mit zehn Modulen der Standardbibliothek gebaut, das keines davon verwendet:

import argparse, asyncio, decimal, email.message, http.client
import json, sqlite3, xml.etree.ElementTree, zipfile, urllib.request

print("ok")

Auf meinem Rechner braucht der Start 111 ms, gemessen als Median aus 15 Läufen. Mit der Umgebungsvariable PYTHON_LAZY_IMPORTS=all, die jeden Import verzögert, sind es 16 ms. Das ist der günstigste Fall, weil das Skript gar nichts benutzt. Eine echte Anwendung dürfte irgendwo dazwischen liegen.

Aber Achtung: Ein Fehler beim Import zeigt sich jetzt erst an der Stelle, an der das Modul zum ersten Mal benutzt wird. Ein Tippfehler im Modulnamen fällt also nicht mehr beim Start auf, sondern erst dann, wenn der betroffene Programmteil das erste Mal läuft. Außerdem ist lazy nur auf Modulebene erlaubt. In einer Funktion, einer Klasse oder einem try-Block meldet Python einen Syntaxfehler.

frozendict: ein immutable Dictionary

Für Listen gibt es das Tupel, für Mengen das frozenset. Für das Dictionary fehlte eine unveränderliche Fassung bisher. PEP 814 liefert sie nach:

DEFAULTS = frozendict(timeout=30, retries=3)

DEFAULTS["timeout"] = 60
# TypeError: 'frozendict' object does not support item assignment

neu = DEFAULTS | {"timeout": 60}
print(neu)
# frozendict({'timeout': 60, 'retries': 3})

Wer einen geänderten Wert braucht, baut sich ein neues frozendict. Das Original bleibt, wie es war.

Dazu kommt ein zweiter Nutzen. Ein frozendict lässt sich als Schlüssel verwenden, solange seine Werte das auch können:

cache = {frozendict(host="example.com", port=443): "verbunden"}

print(cache[frozendict(port=443, host="example.com")])
# verbunden

Die Reihenfolge der Einträge spielt beim Vergleich keine Rolle.

Aber Achtung: Ein frozendict ist keine Unterklasse von dict. Eine Prüfung mit isinstance(wert, dict) liefert False. Wer das benötigt, prüft gegen collections.abc.Mapping.

sentinel: „nichts übergeben“ ist nicht dasselbe wie None

Eine Funktion mit einem optionalen Parameter muss unterscheiden können, ob der Aufrufer nichts übergeben hat oder ausdrücklich None. Bisher hat man sich dafür ein leeres object() gebaut. Das funktioniert, sieht in Fehlermeldungen aber so aus: <object object at 0x000001F3A4B2C3D0>.

PEP 661 macht daraus einen eigenen Typ:

MISSING = sentinel("MISSING")


def lookup(key: str, default: str | None | MISSING = MISSING) -> str | None:
    values = {"a": "Apfel"}
    if key in values:
        return values[key]
    if default is MISSING:
        raise KeyError(key)
    return default


print(repr(MISSING))          # MISSING
print(lookup("b", None))      # None
print(lookup("b", "Birne"))   # Birne
lookup("b")                   # KeyError: 'b'

Der Wert hat einen lesbaren Namen und darf direkt in der Typangabe stehen.

Unpacking in Comprehensions

Um eine Liste von Listen flach zu „klopfen“, hat man früher diesen Code verwendet:

pages = [["/", "/blog/"], ["/kontakt/"], []]

urls = [url for group in pages for url in group]

Die doppelte Schleife in einer Zeile muss ich jedes Mal zweimal lesen 😕 Mit PEP 798 geht es mit dem Stern, den man von Funktionsaufrufen kennt:

urls = [*group for group in pages]
# ['/', '/blog/', '/kontakt/']

configs = [{"timeout": 30}, {"retries": 3}, {"timeout": 60}]
merged = {**c for c in configs}
# {'timeout': 60, 'retries': 3}

Bei Dictionaries gewinnt der spätere Eintrag, wie bei {**a, **b} auch.

Fehlermeldungen, die andere Sprachen kennen

Wer zwischen mehreren Sprachen wechselt, tippt irgendwann die Methode der falschen Sprache. Python 3.15 erkennt einige dieser Fälle und nennt das passende Gegenstück:

>>> [1, 2, 3].push(4)
AttributeError: 'list' object has no attribute 'push'. Did you mean '.append'?

>>> {}.put("a", 1)
AttributeError: 'dict' object has no attribute 'put'. Use d[k] = v.

>>> (1, 2).append(3)
AttributeError: 'tuple' object has no attribute 'append'. Did you mean to use a 'list' object?

Laut den offiziellen Hinweisen kennt Python dafür gängige Methodennamen aus JavaScript, Java, Ruby und C#. Als jemand, der beruflich viel C# schreibt, freut mich das 🙂

UTF-8 als Standard

Diese Änderung betrifft vor allem Windows. Bisher hat open() ohne Angabe einer Kodierung die des Betriebssystems genommen. Auf einem deutschen Windows ist das cp1252, auf Linux und macOS UTF-8. Dasselbe Skript schrieb also je nach Rechner andere Bytes.

Seit PEP 686 gilt überall UTF-8:

import locale

print(locale.getencoding())
# cp1252

with open("test.txt", "w") as handle:
    print(handle.encoding)
    # utf-8
    handle.write("Grüße")

Das Betriebssystem meldet weiterhin cp1252, open() schreibt trotzdem UTF-8.

Aber Achtung: Das gilt auch beim Lesen. Eine Datei, die ein älteres Python unter Windows ohne Angabe geschrieben hat, liegt in cp1252 vor und könnte beim Lesen mit 3.15 an den Umlauten scheitern. Die sichere Lösung ist dieselbe wie vorher: die Kodierung bei open() immer hinschreiben. Dann verhält sich der Code auf jeder Version gleich.

Tachyon: ein Profiler, der das laufende Programm kaum bremst

Der bisherige Profiler cProfile hängt sich an jeden einzelnen Funktionsaufruf. Das ist genau, kann das Programm aber deutlich bremsen.

Tachyon aus PEP 799 arbeitet anders. Er schaut in festen Abständen von außen nach, an welcher Stelle das Programm gerade steht, und zählt mit. Das nennt sich statistisches Sampling. Der Code muss dafür nicht geändert werden.

Ein kleines Beispiel, das erst rechnet und dann zwei Sekunden wartet:

import time


def rechnen() -> int:
    return sum(i * i for i in range(3_000_000))


def warten() -> None:
    time.sleep(2)


rechnen()
warten()
python -m profiling.sampling run warten.py
Captured 2.126 samples in 2,13 seconds

   nsamples   sample%   tottime (s)   filename:lineno(function)
  2000/2000      95.7         2.000   warten.py:9(warten)
      72/90       3.4         0.072   warten.py:5(rechnen)

Die Ausgabe ist gekürzt. 95,7 % der Zeit steckt im Warten.

Das ist die Voreinstellung, sie misst die verstrichene Zeit. Mit --mode cpu zählt Tachyon nur die Zeit, in der wirklich gerechnet wird. warten taucht in der Ausgabe dann gar nicht mehr auf.

Diese Unterscheidung hätte mir schon einmal geholfen. Bei meinem Terminal-Musikplayer retro-amp standen im Profil die Wartefunktionen ganz oben und sahen nach Last aus. Eine Anwendung, die überwiegend auf Eingaben wartet, verbringt ihre Zeit eben mit Warten.

Drei weitere Aufrufe, die ich mir gemerkt habe:

python -m profiling.sampling attach 1234
python -m profiling.sampling dump 1234
python -m profiling.sampling run --live skript.py

attach hängt sich über die Prozessnummer an ein Programm, das schon läuft. dump zeigt einmalig, wo jeder Thread gerade steht, was bei einem hängenden Programm hilft. --live zeigt die Auswertung fortlaufend im Terminal.

Mehr Farbe im Terminal

Eine Kleinigkeit zum Schluss. python --help ist jetzt farbig, ebenso die Ausgaben mehrerer Werkzeuge der Standardbibliothek. Für eigene Skripte ist difflib interessant: difflib.unified_diff() hat einen neuen Parameter color=True und färbt den Vergleich dann so ein, wie man es von git diff kennt.

Was fällt weg?

Jede neue Version entfernt auch Dinge, die vorher lange als veraltet markiert waren. Die folgenden Punkte stammen aus dem Abschnitt „Removed“ und „Porting“ der offiziellen Hinweise:

  • datetime.strptime() meldet einen Fehler, wenn das Format einen Tag enthält, aber kein Jahr.
  • Bei sqlite3.connect() muss jeder Parameter außer der Datenbank mit Namen übergeben werden.
  • Die Module sre_compile, sre_constants und sre_parse gibt es nicht mehr.
  • pathlib.PurePath.is_reserved() ist entfernt, der Ersatz heißt os.path.isreserved().
  • Die Kurzform NamedTuple("Point", x=int, y=int) wird nicht mehr unterstützt.

Wer von 3.13 kommt, überspringt eine Version und sollte die Liste von 3.14 dazunehmen. Dort ist vor allem asyncio.get_event_loop() zu nennen, das ohne laufende Schleife jetzt einen Fehler meldet.

Sollte man jetzt umsteigen?

Zum Ausprobieren: ja, sofort. Für Anwendungen, die ausgeliefert werden, würde ich noch warten.

Der Grund liegt nicht bei Python, sondern bei den Paketen drumherum. Pakete mit kompiliertem Anteil brauchen für jede Python-Version eine eigene Fassung, und die erscheint nicht bei allen am ersten Tag. Am 9. Oktober 2026 wurden dazu die Dateilisten auf PyPI geprüft:

  • Für PyYAML und pygame gab es noch keine Fassung für 3.15.
  • pydantic-core, Pillow, cryptography und lxml hatten bereits eine.
  • PySide6 lässt sich installieren, die Unterstützung für 3.15 ist laut den Entwicklernotizen von Qt aber erst ab Version 6.12.1 geplant.

Dazu kommt Nuitka, mit dem ich meine Anwendungen zu eigenständigen Programmen übersetze. Das Änderungsprotokoll von Nuitka 4.2 nennt die Unterstützung für 3.15 „experimental at best“. Ein Programm, das bei jemand anderem auf dem Rechner laufen soll, baue ich damit noch nicht 😕

Was ich daraus gelernt habe

Lazy Imports und Tachyon sind für mich die beiden Neuerungen, die den Umstieg definitiv lohnen. Die eine verkürzt den Start, die andere zeigt, wo die Zeit wirklich bleibt.

Für meine Projekte werde ich in den nächsten Wochen folgendermaßen vorgehen: Die Tests laufen ab jetzt zusätzlich auf 3.15, damit ein Bruch früh auffällt. Gebaut und ausgeliefert wird weiter mit der Vorgängerversion, bis die Pakete nachgezogen haben.

Eine neue Python-Version ist kein Grund zur Eile. Sie ist ein Grund, die eigene Testabdeckung anzusehen. Wer seinen Tests vertraut, kann den Umstieg einfach ausprobieren und weiß danach, woran er ist.

Quellen (geprüft am 09.10.2026): What’s new in Python 3.15 · What’s new in Python 3.14 · Ankündigung auf discuss.python.org · Dokumentation zu profiling.sampling · Nuitka Changelog · Qt for Python Development Notes

Steht bei Ihnen ein ähnliches Vorhaben an?

Ich unterstütze Sie von der Beratung und Planung über die Umsetzung bis zur Qualitätssicherung.

“Es ist nicht wenig Zeit, die wir haben, sondern viel Zeit, die wir nicht nutzen.”

- Seneca