📝 New features in Python 3.15

* profiling.tracing and profiling.sampling
* Tachyon
* Python JIT compiler

Author: veit

docs/conf.py

@@ -159,7 +159,7 @@
         "https://jupyter-tutorial.readthedocs.io/de/latest",
         None,
     ),
-    "python": ("https://docs.python.org/3", None),
+    "python": ("https://docs.python.org/3.15", None),
     "ipython": ("https://ipython.readthedocs.io/en/latest", None),
     "pytest": ("https://docs.pytest.org/en/latest", None),
     "jupyter-notebook": (

docs/performance/index.rst

@@ -66,9 +66,22 @@ Performance-Messungen
 ---------------------
 
 Wenn ihr erst einmal mit eurem Code gearbeitet habt, kann es nützlich sein, die
-Effizienz genauer zu untersuchen. Hierfür kann :mod:`cProfile`,
+Effizienz genauer zu untersuchen. Hierfür kann :abbr:`z. B. (zum Beispiel)`
+`cProfile <https://docs.python.org/3.14/library/profile.html#module-cProfile>`_,
 :doc:`ipython-profiler` oder :doc:`scalene` genutzt werden.
 
+.. versionadded:: Python3.15
+   Mit :pep:`799` wird ein spezielles Profiling-Modul zur Verfügung stehen, das
+   die in Python integrierten Profiling-Tools unter einem einheitlichen
+   Namespace organisiert. Dieses Modul enthält:
+
+   :mod:`profiling.tracing`
+       deterministische Funktionsaufrufverfolgung, die aus `cProfile
+       <https://docs.python.org/3.14/library/profile.html#module-cProfile>`_
+       verschoben wurde.
+   :mod:`profiling.sampling`
+       der neue statistische Sampling-Profiler :doc:`tachyon`.
+
 .. seealso::
     * `airspeed velocity (asv) <https://asv.readthedocs.io/en/stable/>`_ ist ein
       Werkzeug zum Benchmarking von Python-Paketen während ihrer Lebensdauer.
@@ -85,6 +98,7 @@ Effizienz genauer zu untersuchen. Hierfür kann :mod:`cProfile`,
 
     ipython-profiler.ipynb
     scalene.ipynb
+    tachyon
 
 Suche nach bestehenden Implementierungen
 ----------------------------------------
@@ -229,6 +243,20 @@ Wenn ihr mit eurem Projekt nicht bis zur Veröffentlichung von Python 3.11 in de
 finalen Version voraussichtlich am 24. Oktober 2022 warten wollt, könnt ihr euch
 auch die folgenden Python-Interpreter anschauen:
 
+Python JIT compiler
+~~~~~~~~~~~~~~~~~~~
+
+.. versionadded:: Python3.15
+   Der `JIT-Compiler <https://de.wikipedia.org/wiki/Just-in-time-Kompilierung>`_
+   in Python 3.15 zeigt eine mittlere Leistungssteigerung von 3–4 gegenüber dem
+   Standard-CPython-Interpreter, wobei die Performance-Messungen schwanken
+   zwischen -20 und über 100 % auf x86-64-Linux- und AArch64-macOS-Systemen.
+
+   .. seealso::
+      * `The JIT Compiler
+        <https://github.com/python/cpython/blob/main/Tools/jit/README.md>`_
+      * :ref:`whatsnew315-jit`
+
 Cython
 ~~~~~~
 

docs/performance/tachyon.rst

@@ -0,0 +1,97 @@
+Tachyon
+=======
+
+Tachyon ist ein neuer statistischer Sampling-Profiler, der in Python 3.15 als
+:mod:`profiling.sampling` hinzugefügt wurde. Dieser Profiler ermöglicht eine
+leistungsstarke Analyse laufender Python-Prozesse mit geringem Overhead, ohne
+dass Codeänderungen oder ein Neustart des Prozesses erforderlich sind.
+
+Im Gegensatz zu deterministischen Profiler wie :mod:`profiling.tracing`, die
+jeden Funktionsaufruf instrumentieren, erfasst :mod:`profiling.sampling`
+regelmäßig Stack-Traces aus laufenden Prozessen.
+
+Zu den wichtigsten Funktionen gehören:
+
+Profiling ohne Overhead
+    :mod:`profiling.sampling` fügt sich in jeden laufenden Python-Prozess ein,
+    ohne dessen Leistung zu beeinträchtigen. Dies ist Ideal für die
+    Fehlerbehebung in Produktiv-Umgebungen, wo eure Anwendung nicht neu
+    gestartet oder verlangsamt werden darf.
+Keine erforderlichen Codeänderungen
+    Bestehende Anwendungen können ohne Neustart profiliert werden. Ihr müsst
+    einfach anhand der PID den Profiler auf einen laufenden Prozess richten und
+    mit der Datenerhebung beginnen.
+Profiliert laufende Prozesse oder Module
+    :samp:`attach`
+        profiliert laufende Prozesse anhand der PID.
+    :samp:`run -m {MODULE}`
+        führt Module aus und profiliert sie.
+Mehrere Profiling-Modi
+    Ihr könnt auswählen, was gemessen werden soll:
+
+    ``--mode wall``
+        Standardwert, der die tatsächlich verstrichene Zeit misst einschließlich
+        I/O, Netzwerkwartezeiten und Blockierungsvorgängen. Dies ist ideal
+        geeignet um zu verstehen, wo euer Programm Zeit verbraucht,
+        einschließlich der Wartezeiten auf externe Ressourcen.
+    ``--mode cpu``
+        misst nur die aktive CPU-Ausführungszeit, ohne I/O-Wartezeiten und
+        Blockierungen. Verwendet diese Option, um CPU-gebundene Engpässe zu
+        identifizieren und die Rechenleistung zu optimieren.
+    ``--mode gil``
+        misst die Zeit für das :abbr:`GIL (Global Interpreter Lock)` von Python.
+        Verwendet diese Option, um zu ermitteln, welche Threads durch das GIL
+        ausgebremst werden.
+    ``--mode exception``
+        erfasst nur Samples von Threads mit einer aktiven Ausnahme. Verwendet
+        diese Option, um den Overhead beim Exception Handling zu analysieren.
+    ``-a``
+        profiliert alle Threads oder nur den Haupt-Thread, wodurch das
+        Verständnis für des Verhalten von Multithread-Anwendungen wächst.
+
+Mehrere Ausgabeformate
+    Wählt die Visualisierung, die am besten zu Ihrem Workflow passt:
+
+    ``--pstats``
+        liefert detaillierte tabellarische Statistiken, kompatibel mit
+        :mod:`pstats`. Es zeigt die Zeitmessung auf Funktionsebene mit direkten
+        und kumulativen Stichproben an und ist am besten geeignet für
+        detaillierte Analysen und die Integration mit vorhandenen
+        Python-Profiling-Tools.
+    ``--collapsed``
+        erzeugt zusammengefasste Stack-Traces. Dieses Format wurde speziell für
+        die Erstellung von `Flame Graphs
+        <https://www.brendangregg.com/flamegraphs.html>`_ mit externen Tools wie
+        `Brendan Greggs FlameGraph-Skripten
+        <https://github.com/brendangregg/FlameGraph>`_ oder `Speedscope
+        <https://jamie-wong.com/post/speedscope/>`_ entwickelt.
+    ``--flamegraph``
+        erzeugt einen eigenständigen interaktiven HTML-Flamegraph mit `D3.js
+        <https://d3js.org/>`_, der sich direkt in Ihrem Browser für eine
+        sofortige visuelle Analyse öffnet.
+    ``--gecko``
+        erzeugt ein Gecko-Profiler-Format, das mit `Firefox Profiler
+        <https://profiler.firefox.com>`_ kompatibel ist. Die Ausgabe kann in
+        Firefox Profiler hochgeladen werden, um eine erweiterte
+        zeitachsenbasierte Analyse mit Funktionen wie Stapeldiagrammen, Markern
+        und Netzwerkaktivitäten durchzuführen.
+    ``--heatmap``
+        erzeugt eine interaktive HTML-Heatmap-Visualisierung und erstellt eine
+        Heatmap je Datei, die genau zeigen, wo Zeit auf Quellcodeebene
+        verbraucht wird.
+
+``--live``
+    `top <https://man7.org/linux/man-pages/man1/top.1.html>`_-ähnliche
+    Oberfläche, wodurch ihr die Leistung eurer Anwendung während der Ausführung
+    mit interaktiver Sortierung und Filterung Überwachen könnt.
+``--async-aware``
+    Profilerstellung für :doc:`async/await-Code <asyncio-example>`, die euch
+    anzeigt, welche Coroutinen Zeit verbrauchen. Weitere Optionen zeigen euch
+    nur laufende Aufgaben oder alle Aufgaben einschließlich der wartenden an.
+``--opcodes``
+    sammelt Bytecode-Opcode-Informationen für das Profiling auf Befehlsebene und
+    zeigt an, welche Bytecode-Befehle ausgeführt werden, einschließlich
+    Spezialisierungen aus dem adaptiven Interpreter.
+
+.. seealso::
+   :mod:`profiling.sampling`

pyproject.toml

@@ -41,7 +41,7 @@ docs = [
   "matplotlib",
   "nbsphinx",
   "notebook",
-  "sphinx<8.2",
+  "sphinx<8.2",                     # furo requires sphinx < 8.2
   "sphinx-copybutton",
   "sphinx-inline-tabs",
   "sphinx-lint",