Python

Performance de Python 3.15 : qu’est-ce qui est réellement plus rapide ?

Découvrez ce qui est réellement plus rapide dans Python 3.15 : JIT, démarrage, bibliothèque standard, profiling et méthodes de benchmark.

Par JaviPublié 13 min de lectureIntermédiaire

Dans cet article

Python 3.15 contient de vrais travaux de performance, mais il est plus utile de comprendre où ils s’appliquent que de chercher un pourcentage unique du type « Python 3.15 est X % plus rapide ».

Il n’existe pas de chiffre universel responsable.

Les performances de Python 3.15 dépendent de ce que vous exécutez, de la plateforme, du build de l’interpréteur, de l’activation éventuelle du JIT expérimental, de la proportion de code natif et de l’importance du démarrage par rapport à l’exécution en régime établi.

Les changements les plus importants sont :

  • JIT expérimental beaucoup plus capable ;
  • interpréteur tail-calling dans les binaires officiels Windows 64 bits ;
  • imports paresseux explicites pour réduire le coût de démarrage ;
  • plusieurs opérations de bibliothèque standard accélérées ;
  • nouveau profiler par échantillonnage ;
  • frame pointers activés par défaut sur les plateformes compatibles.

Réponse rapide

Python 3.15 peut être plus rapide que Python 3.14, mais pas uniformément.

Les résultats officiels les plus marquants du JIT 3.15 sont :

  • 7–8 % d’amélioration moyenne géométrique du JIT par rapport à l’interpréteur optimisé standard sur Linux x86-64 ;
  • 11–12 % d’amélioration par rapport à l’interpréteur tail-calling sur macOS AArch64.

Mais les workloads individuels vont de régressions à de très gros gains.

La documentation rapporte des résultats allant d’environ 15 % plus lent à plus de 100 % plus rapide sur certains tests.

Performance de Python 3.15 en un coup d’œil

Domaine Python 3.14 Python 3.15 Pourquoi c’est important
JIT expérimental Encore limité Nouveau tracing, registre, optimisations Plus de workloads peuvent en bénéficier
Startup/import Imports eager traditionnels Imports paresseux explicites Les dépendances optionnelles peuvent être différées
Windows Configuration précédente Interpréteur tail-calling Gains spécifiques à la plateforme
Profiling Outils existants profiling + Tachyon Diagnostic plus simple
Observabilité native Dépend du build Frame pointers par défaut Meilleur unwinding
Base64 Implémentation précédente ~2× encode, ~3× decode Gain ciblé
Base32/Base85 Implémentation précédente Réécriture C Gains importants ciblés
CSV sniffing Baseline csv.Sniffer.sniff() jusqu’à 1,6× Utile pour découverte de fichiers

Le grand sujet runtime : le JIT expérimental amélioré

Python 3.14 avait rendu le JIT expérimental plus facile à essayer.

Python 3.15 le rend nettement plus capable avec :

  • nouveau tracing frontend ;
  • support de davantage d’opérations bytecode ;
  • allocation de registres ;
  • optimisations supplémentaires ;
  • meilleure génération de code ;
  • meilleur unwinding.

Le nouveau frontend suit les vrais chemins d’exécution, ce qui permet à plus de code Python d’entrer dans les traces optimisées.

Que veulent vraiment dire les chiffres officiels ?

Plateforme / comparaison Résultat officiel
Linux x86-64, JIT vs CPython optimisé standard 7–8 %
macOS AArch64, JIT vs interpréteur tail-calling 11–12 %
Workloads individuels environ -15 % à >100 %

Ces moyennes ne sont pas une promesse pour votre service ou pipeline.

Deux applications peuvent réagir très différemment : une application CPU-bound pure Python peut bénéficier du JIT, tandis qu’une application dominée par I/O ou NumPy peut très peu changer.

Mesurez votre code, pas Python dans l’abstrait

Commencez par un petit harness :

from statistics import median
from time import perf_counter

def benchmark(fn, iterations=10_000, repeats=7):
    samples = []

    for _ in range(repeats):
        start = perf_counter()

        for _ in range(iterations):
            fn()

        samples.append(perf_counter() - start)

    return {
        "best": min(samples),
        "median": median(samples),
        "worst": max(samples),
    }

Puis un workload représentatif :

def workload():
    values = [n * n for n in range(100)]
    return sum(values)

print(benchmark(workload))

Ce n’est pas un remplacement de pyperformance ou pyperf. Le but est de montrer la méthode correcte : même machine, mêmes entrées, plusieurs répétitions.

Comparer Python 3.14 et 3.15

Sous Windows :

py -3.14 benchmark.py
py -3.15 benchmark.py

Sur les systèmes avec exécutables séparés :

python3.14 benchmark.py
python3.15 benchmark.py

Pour des résultats utiles :

  1. même machine ;
  2. pas de lourdes tâches concurrentes ;
  3. mêmes dépendances si possible ;
  4. warm-up pour les workloads longs ;
  5. plusieurs répétitions ;
  6. comparer les médianes ;
  7. séparer startup et steady-state ;
  8. mesurer des scénarios end-to-end ;
  9. ne changer qu’une variable à la fois ;
  10. noter le build exact et l’OS.

Testez le JIT séparément

Ne mélangez pas « 3.14 vs 3.15 » et « JIT vs sans JIT ».

Une meilleure matrice :

Run Python JIT
A 3.14 Off
B 3.15 Off
C 3.15 On

Cela permet de répondre séparément à :

  1. le runtime de base est-il meilleur ?
  2. le JIT expérimental aide-t-il ce workload ?

Les imports paresseux ciblent le startup, pas le débit CPU

Les imports paresseux explicites diffèrent le chargement jusqu’à la première utilisation :

lazy import json
lazy from pathlib import Path

print("CLI is ready")

def load_config(raw):
    return json.loads(raw)

def output_path(name):
    return Path(name)

Pour une application avec beaucoup de fonctionnalités optionnelles, cela peut éviter le travail d’import sur les chemins d’exécution qui n’utilisent jamais ces fonctionnalités. Les CLI, fonctions serverless, gestionnaires de paquets, outils administratifs, systèmes de plugins et grands frameworks modulaires sont de bons candidats.

Mesurer directement le coût des imports

Python fournit une mesure du temps d’import :

python -X importtime app.py

Utilisez-la pour repérer les imports lourds avant de décider lesquels rendre paresseux. Si un module coûte cher mais est toujours utilisé immédiatement, vous ne faites que déplacer le coût. Si une dépendance lourde n’est requise que dans une faible proportion des exécutions, la différer peut améliorer sensiblement le chemin courant.

Les améliorations de bibliothèque standard peuvent être importantes

Base64

La documentation 3.15 indique environ 2× en encodage et 3× en décodage pour l’implémentation sous-jacente.

Base32/Base85

Certaines implémentations ont été réécrites en C avec de gros gains ciblés.

Détection CSV

csv.Sniffer.sniff() peut détecter les séparateurs jusqu’à 1,6× plus vite :

import csv

with open("incoming.csv", newline="", encoding="utf-8") as file:
    sample = file.read(4096)
    dialect = csv.Sniffer().sniff(sample)

print(dialect.delimiter)

Pour un système qui inspecte beaucoup de CSV inconnus, c’est utile. Pour un pipeline où le séparateur est déjà connu, beaucoup moins.

Windows reçoit un changement d’interpréteur important

Les binaires officiels Python 3.15 64 bits Windows utilisent l’interpréteur tail-calling.

La documentation rapporte des gains intéressants dans la configuration testée, mais il ne faut pas conclure que toute application Windows est 20 % plus rapide.

Le bon message : Windows mérite particulièrement un benchmark 3.15.

Le profiling s’améliore, ce qui peut compter plus que la vitesse brute

Python 3.15 introduit le package profiling et Tachyon.

Tachyon peut :

  • profiler un PID existant ;
  • lancer un script et le profiler ;
  • profiler des modules ;
  • échantillonner CPU et wall-clock ;
  • analyser GIL et exceptions ;
  • produire des sorties flame graph/heatmap.

Le workflow passe de :

guess
→ optimize
→ hope

à :

measure
→ locate hot path
→ optimize
→ measure again

Les frame pointers améliorent l’observabilité système

CPython 3.15 active les frame pointers par défaut sur les plateformes compatibles.

Cela améliore le déroulage pour les profilers système, debuggers, outils eBPF et analyses de crash.

Et le free-threading ?

Le free-threading continue d’évoluer, et Python 3.15 apporte du travail ABI/C-API important.

Mais ce n’est pas une promesse de performance single-thread.

Traitez free-threading, JIT et CPython standard comme des configurations distinctes.

Ce que cela signifie pour la data engineering

PySpark

Une grande partie du travail s’exécute dans Spark et la JVM. Accélérer légèrement le driver Python ne signifie pas qu’un gros job Spark devient 8 % plus rapide.

pandas et NumPy

Beaucoup d’opérations passent dans du code natif optimisé.

ETL et orchestration

Le Python pur autour de l’orchestration peut bénéficier davantage, surtout pour metadata, validation, imports et encodage.

Serverless et jobs courts

Le startup peut être plus important que le throughput.

Pertinence par workload

Workload Pertinence probable des changements 3.15
CLI / startup lourd Potentiel élevé
Boucles CPU Python pur À benchmarker
API web longue durée Dépend du workload
Serverless Startup potentiellement important
pandas/NumPy vectorisé Souvent moins dominé par l’interpréteur
PySpark Beaucoup de travail hors CPython
Automation I/O-bound Impact runtime souvent modeste
Traitement Base64 intensif Gains ciblés possibles
Découverte CSV Sniffing plus rapide
Extensions natives Le support dépend des dépendances

Plan de benchmark pratique

Si j’évaluais Python 3.15 pour un service de production, j’utiliserais cette séquence.

1. Documenter la baseline

Consignez la version corrective de Python 3.14, le système, le processeur, les dépendances, la configuration de l’application et des entrées représentatives.

2. Changer uniquement Python

Créez un environnement Python 3.15 avec des dépendances équivalentes et exécutez la même suite de tests.

3. Mesurer le démarrage séparément

Pour les CLI et applications courtes, séparez le temps de lancement et d’import de l’exécution en régime établi.

4. Mesurer des scénarios de bout en bout

Benchmarker des opérations métier : traiter 10 000 enregistrements, exécuter une requête API complète, valider un fichier représentatif, produire un rapport ou lancer une étape ETL locale.

5. Tester le JIT comme variante séparée

Comparez la baseline 3.15 à la même version avec le JIT activé.

6. Profiler avant d’optimiser

Vérifiez avec des outils de profiling que l’exécution Python est réellement le goulot.

7. Répéter

Exécutez assez d’échantillons pour distinguer une amélioration réelle du bruit système.

La performance seule justifie-t-elle la mise à niveau ?

En général, non.

Il faut aussi tenir compte de :

  • support des dépendances ;
  • images de déploiement ;
  • CI ;
  • extensions natives ;
  • observabilité ;
  • compatibilité du runtime ;
  • risque opérationnel.

Mais Python 3.15 est une version particulièrement intéressante à benchmarker car plusieurs axes progressent en même temps.

Conclusion

La meilleure description est :

Python 3.15 crée davantage d’opportunités de performance, mais il faut mesurer celles qui s’appliquent réellement à votre workload.

Le JIT est plus mature, les imports paresseux ciblent le démarrage, plusieurs hot spots de la bibliothèque standard sont plus rapides, Windows change d’interpréteur et le profiling s’améliore.

Il n’existe toutefois pas un chiffre universel.

Mesurez ce que vos utilisateurs attendent réellement. Pour les décisions de migration voisines, consultez la comparaison Python 3.15 vs 3.14. Pour l’évolution sur plusieurs versions, utilisez le guide de mise à niveau de Python 3.11 à 3.15.

Références officielles

Étiquettes

  • Python
  • Performance
  • Observabilité