Was ist neu in Python 3.11 – und lohnt sich das Update überhaupt?

Python hat den TIOBE-Preis "Language of the Year" dreimal in den letzten vier Jahren gewonnen. Die beliebte Programmiersprache führt auch zur Jahresmitte 2022 weiterhin den TIOBE-Index an.

Python steht im Juni 2022 an der Spitze des TIOBE-Index.

Ein Python-Rating von 12,74 % bedeutet, dass das Stichwort „Python“ in etwa 13 % aller programmierbezogenen Suchanfragen auftaucht. Anders gesagt: Jede siebte bis achte Programmierfrage im Internet dreht sich um Python.

Heute wird Python häufig mit den größten Durchbrüchen in Data Science und KI in Verbindung gebracht. Praktiker schätzen die einfache Syntax, den großen Fundus an integrierten und externen Bibliotheken für zahlreiche Aufgaben und die starke Community.

Mit der finalen, stabilen Version 3.11 am 3. Oktober 2022 kann sich die Python-Community auf eine Reihe sinnvoller Updates freuen – darunter spürbare Performance-Gewinne, präzisere Fehlermeldungen und Debugging sowie zahlreiche Qualitätsverbesserungen in den Standardbibliotheken.

Welche neuen Features bringt Python 3.11?

Das Changelog zu Python 3.11 liest sich wie eine endlose Liste aus Bugfixes, Verbesserungen und Ergänzungen – vieles davon wirst du im Alltag kaum bemerken. Einige zentrale Neuerungen können deinen Python-Workflow mit der stabilen Version jedoch deutlich verbessern. Die wichtigsten Punkte findest du hier zusammengefasst. 

1. Mehr Geschwindigkeit

Die erste große Änderung, die Data Scientists freuen wird: mehr Tempo. Die Standard-Benchmark-Suite läuft rund 25 % schneller als unter 3.10. In manchen Fällen, so die Python-Dokumentation, kann 3.11 sogar bis zu 60 % schneller sein. So führst du selbst einen Benchmark durch, um die Geschwindigkeitsgewinne zu testen. 

Für den Vergleich zwischen Python 3.10 und 3.11 brauchst du eine Docker-Installation. Stelle sicher, dass Docker Desktop läuft, und führe dann diese zwei Terminal-Befehle aus. Sie laden die Images für beide Python-Versionen herunter.

$ docker run -d python:3.10.4-bullseye

$ docker run -d python:3.11-rc-bullseye

Die geladenen Images sollten im Docker-Dashboard sichtbar sein – dort kannst du sie auch starten.

Nach dem Start der Container kannst du mit docker ps Details wie Container-ID, Image, Status und mehr anzeigen lassen.

Die laufenden Container siehst du auch im Tab "Containers" deines Dashboards. Neben "Run/Stop" findest du CLI-Schaltflächen. Klicke sie für beide Container an, um zwei Terminal-Tabs mit den Containern zu öffnen.

Installiere in beiden Tabs das Paket pyperformance via pip. Führe dann in jedem Container-Terminal die folgenden Befehle aus.

Für Python 3.10

$ pyperformance run -r -o py310.json

Für Python 3.11

$ pyperformance run -r -o py310.jsone run -r -o py311.json

Diese Befehle starten Benchmarks für rund 60 Python-Funktionen aus den Standardbibliotheken und erzeugen JSON-Metadaten. Mit dem optionalen Tag -r weise ich pyperformance an, die Tests strenger auszuführen – das dauert länger. In meinem Fall laufen beide Container auf einer Windows-Maschine mit einem AMD Ryzen 12-Core-CPU.

Jetzt liegen zwei JSON-Dateien in zwei Containern, die wir für den Vergleich in ein gemeinsames Verzeichnis kopieren müssen. Dafür nutzen wir docker cp, um die JSON-Datei aus dem Python-3.11-Container in den 3.10-Container zu übertragen.

Führe die folgenden Befehle in einem separaten Terminal-Tab aus und passe die Pfade an dein System an:

$ docker cp crazy_snyder:/py311.json C:/Users/bex/Desktop

$ docker cp C:/Users/bex/Desktop/py311.json charming_proskuriakova:/

In meinem Fall sind crazy_snyder und charming_proskuriakova die IDs der laufenden Container. Nun liegen beide JSON-Dateien im Python-3.10-Container. Um den Benchmark abzuschließen und das Ergebnis als CSV zu speichern, führe diese Befehle aus.

$ pyperformance compare py310.json py311.json --csv comparison.csv

$ docker cp charming_proskuriakova:/comparison.csv C:/Users/bex/Desktop/articles

Zum Schluss laden wir die CSV in Pandas und analysieren sie:

import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns

df = pd.read_csv("data/comparison.csv")
df.rename({"Base": "py310", "Changed": "py311", "Benchmark": "function"},
                   axis=1,
                   inplace=True)

>>> df.shape

(59, 3)

>>> df.sample(5)

Jede Zeile im DataFrame zeigt, wie lange (in Millisekunden) beide Versionen für die jeweilige Python-Funktion benötigt haben. Lass uns ein Histogramm der Speedups plotten.

df["speed_up"] = (df["py310"] / df["py311"]).round(3)

fig, ax = plt.subplots()

sns.histplot(df["speed_up"], bins=11)
ax.set(xlabel="Speedup (times)", 
           title="Python 3.10 vs. Python 3.11 - speedup comparison")

plt.show()

Das Diagramm zeigt klar: Der Großteil der Funktionen war in Python 3.11 etwa 1,2-mal (20 %) schneller. Das bestätigen auch Mittelwert und Median.

>>> df["speed_up"].mean()

1.2605593220338982

>>> df["speed_up"].median()

1.207

In einem Fall lag der Geschwindigkeitszuwachs sogar über 60 %. 

>>> df["speed_up"].max()

1.899

Es gibt auch vier Fälle, in denen Python 3.10 schneller war als die neue Version.

>>>  (df["speed_up"] <= 1).sum() 

4

Die Performancegewinne sind messbar, ihre praktische Relevanz hängt aber stark vom Anwendungsfall ab – und die finale, stabile Version von Python 3.11 steht erst noch an. Der Benchmark nutzt reine Python-Funktionen, die du im Alltag womöglich seltener einsetzt. Eine Docker-Installation mit Python 3.10 und 3.11 aufzusetzen, gibt dir jedoch ein gutes Gefühl für die Geschwindigkeitszuwächse in deinen Szenarien. 

2. Bessere Fehlermeldungen

Eine weitere starke Neuerung in Python 3.11 sind präzisere Fehlermeldungen, die exakt auf die Stelle zeigen, an der der Fehler auftritt. Anstatt eines 100-zeiligen Tracebacks mit schwer interpretierbarer Fehlermeldung markiert Python 3.11 den konkreten Ausdruck, der den Fehler verursacht hat.

Im obigen Beispiel zeigt der Interpreter auf das x, das wegen seines None-Werts den Absturz ausgelöst hat. In aktuellen Python-Versionen wäre das unklarer, da es zwei Objekte mit dem Attribut ‚x‘ gibt. Das Error-Handling in 3.11 markiert jedoch eindeutig den problematischen Ausdruck. 

Dieses Beispiel zeigt, wie 3.11 einen Fehler in einem tief verschachtelten Dictionary punktgenau identifiziert und klar angibt, zu welchem Key der Fehler gehört.

Die gleiche Präzision gilt für komplexe arithmetische Ausdrücke.

Die verbesserten Fehlermeldungen sind definitiv ein Gewinn – vor allem für Data Scientists, die häufig debuggen.

3. Exception Notes

„Explizit ist besser als implizit.“

Dieser Satz ist die zweite Zeile aus The Zen of Python, einer Liste aus 20 Designprinzipien von Python. Gemeint ist: Python-Code soll so ausdrucksstark wie möglich sein.

Um dieses Prinzip zu stärken, führt Python 3.11 Exception Notes ein (PEP 678). Innerhalb von except-Klauseln kannst du jetzt add_note() aufrufen und beim Auslösen des Fehlers eine eigene Zusatznachricht mitgeben.

import math

try:
  math.sqrt(-1)
except ValueError as e:
  e.add_note("Negative value passed! Please try again.")
  raise

Wenn du eine eigene Exception-Klasse wie unten geschrieben hast, kannst du mehrere Hinweise über das geschützte Klassenattribut __notes__ hinzufügen:

import math

class MyOwnError(Exception):
   # Should be a list of strings
   __notes__ = ["This is a custom error!"]

try:
   math.sqrt(-1)
except:
   raise MyOwnError

Trifft der Interpreter nun auf den Fehler, erscheint die benutzerdefinierte Nachricht nach dem regulären Meldungstext.

Neu ist außerdem die Syntax except* zum Auslösen von Exceptions zusammen mit der neuen Klasse ExceptionGroup. PEP 654 beschreibt, wie sich in verschiedenen Szenarien mehrere unabhängige Fehler gleichzeitig auslösen lassen. Die meisten Anwendungsfälle sind eher speziell – etwa bei WebSockets oder bei nebenläufiger Programmierung mit asyncio. Wenn dich das interessiert, findest du die neue Syntax hier.

4. Neues Typing-Feature: Self

Statisch typisierte Sprachen helfen, Code lesbarer und leichter zu debuggen. Wenn du Typen von Variablen sowie Ein- und Ausgaben von Funktionen klar definierst, sparst du dir oft stundenlanges Debugging und machst deinen Code für andere verständlicher. Typannotationen ermöglichen es modernen IDEs außerdem, Funktionssignaturen beim Tippen anzuzeigen.

Bislang bot das mächtige typing-Modul in Python Typen für nahezu alle Datenstrukturen – außer für Klassen, deren Methoden Instanzen ihrer eigenen Klasse zurückgeben. Im aktuellen Python ist das folgende Beispiel nicht möglich:

from typing import Self
class Language:

  def __init__(self, name, version, release_date):
      self.name = name
      self.version = version
      self.release_date = release_date

  def change_version(self, version) -> Self:
      self.version = version

      return Language(self.name, self.version, self.release_date)

Python 3.11 führt nun den Typ Self ein, den du in die Funktionssignatur aufnehmen kannst, wenn der Rückgabewert self oder eine neue Instanz der Klasse ist.

5. Verbesserungen an den Standardbibliotheken

Es gibt zudem einige praktische Verbesserungen in den Standardbibliotheken. Zunächst kommen zwei lange erwartete Funktionen ins math-Modul.

>>> import math
>>> math.cbrt(9)  # Find the cube-root of x
2.080083823051904
>>> math.cbrt(27)
3.0000000000000004
>>> math.exp2(5)  # Raise 2 to the power of x
32.0

Dass es 28 Jahre gedauert hat, bis Python eine Kubikwurzel-Funktion bekam, ist erstaunlich – aber besser spät als nie.  

Auch das Modul fractions hat ein neues Feature, mit dem du Brüche aus Strings erzeugen kannst:

>>> from fractions import Fraction
>>> Fraction("22/7")  # New in Python 3.11
Fraction(22, 7)
>>> Fraction(numerator=22, denominator=7)
Fraction(22, 7)
>>> Fraction("3e-4")
Fraction(3, 10000)
>>> Fraction("-73/41")
Fraction(-73, 41)
>>> Fraction(3.1415)  # Find the closest approximation to the given float
Fraction(7074029114692207, 2251799813685248)

Wie du siehst, ist fractions für manche Rechenaufgaben sehr nützlich. Besonders praktisch: Du findest damit den nächsten Bruch, der einen Float gut approximiert. Mit einer Grenze für den Nenner geht das noch gezielter:

>>> from math import pi
>>> Fraction(pi).limit_denominator(100000)
Fraction(312689, 99532)

Neu ist außerdem das Modul tomllib zum Parsen von TOML-Dokumenten. TOML (Tom's Obvious Minimal Language) ist ein beliebtes Dateiformat für gut lesbare Konfigurationsdateien. Hier ein Bild von der Projekt-Homepage:

import tomllib

.toml_str = """
python-version = "3.11.0"
release_date = "2022-10-22"
"""

data = tomllib.loads(toml_str)
print(data)  # {'python-version': '3.11.0', 'release_date': '2022-10-22'}
print(data['python-version'])  # 3.11.0
print(data['release_date'])  # 2022-10-22

Release-Termin von Python 3.11

Die Entwicklung von Python 3.11 startete am 5. Mai 2021. Seitdem erschienen sieben Alpha-Versionen; am 8. Mai 2022 folgte die erste Beta. Ab diesem Datum bis zur offiziellen Veröffentlichung werden keine neuen Features mehr hinzugefügt.

Die finale, stabile Version erscheint am 3. Oktober 2022 – zuvor kommen noch drei weitere Betas und zwei Release Candidates. Mehr über Python erfährst du in den folgenden Ressourcen.