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.
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 :
- même machine ;
- pas de lourdes tâches concurrentes ;
- mêmes dépendances si possible ;
- warm-up pour les workloads longs ;
- plusieurs répétitions ;
- comparer les médianes ;
- séparer startup et steady-state ;
- mesurer des scénarios end-to-end ;
- ne changer qu’une variable à la fois ;
- 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 à :
- le runtime de base est-il meilleur ?
- 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
- Python 3.15.0 release: https://www.python.org/downloads/release/python-3150/
- What’s New in Python 3.15: https://docs.python.org/3.15/whatsnew/3.15.html
- What’s New in Python 3.14: https://docs.python.org/3.14/whatsnew/3.14.html
- PEP 810 — Explicit lazy imports: https://peps.python.org/pep-0810/
- PEP 799 — Profiling package / Tachyon: https://peps.python.org/pep-0799/
- PEP 831 — Frame pointers by default: https://peps.python.org/pep-0831/
Ce contenu vous a-t-il été utile ?
Que pourrions-nous améliorer ?
Merci — cela m’aide à améliorer Javi Builds.
Continuer à apprendre
- Aide-mémoireInspecter un DataFrame pandasInspectez un DataFrame pandas rapidement et en toute sécurité pour comprendre sa forme, ses colonnes, ses types de données, ses valeurs nulles, ses doublons, ses distributions et ses valeurs suspectes avant de transformer les données.Ouvrir l’aide-mémoire
- ArticlePython 3.15 vs 3.11 : nouveautés et guide de migrationDécouvrez les changements de Python 3.11 à 3.15, les nouveautés de chaque version, les risques de compatibilité et comment préparer la migration.Lire l’article
Que devrais-je créer ensuite ?
Je développe Javi Builds autour des problèmes concrets rencontrés par les data engineers. Dites-moi quel sujet vous aimeriez voir ensuite.
Restez au courant
Recevez uniquement les nouvelles de Javi Builds qui vous intéressent.
Consultez votre boîte de réception
Je vous ai envoyé un lien de confirmation. Votre abonnement sera actif après confirmation.