Python

Python 3.15 vs 3.14 : nouveautés et faut-il migrer ?

Comparez Python 3.15 à 3.14 : nouveautés du langage, du runtime et du profiling, risques de compatibilité et checklist de migration.

Par JaviPublié 12 min de lectureIntermédiaire

Dans cet article

Python 3.15 n’est pas une simple version de maintenance. Par rapport à Python 3.14, il apporte plusieurs nouveautés qui peuvent changer la manière de structurer des applications réelles : imports paresseux explicites, mapping immuable intégré, valeurs sentinelles de premier ordre, déballage dans les compréhensions, UTF-8 comme encodage texte par défaut, nouveau package de profiling avec l’échantillonneur Tachyon, et JIT expérimental nettement amélioré.

Cela ne signifie pas que toute application Python 3.14 doit migrer immédiatement vers 3.15. Python 3.14 est déjà une version moderne avec évaluation différée des annotations, amélioration du mode free-threaded, support expérimental du JIT dans les binaires officiels Windows et macOS, template string literals, sous-interpréteurs dans la bibliothèque standard et d’autres améliorations majeures.

La vraie question n’est donc pas « 3.15 est-il plus récent ? », mais :

Python 3.15 apporte-t-il suffisamment de valeur à votre charge de travail pour justifier une mise à niveau depuis 3.14 ?

Pour de nombreux développeurs, oui. Pour les systèmes de production soumis à de fortes contraintes de dépendances ou de runtime managé, la bonne réponse reste souvent : « tester d’abord ».

Cette comparaison se concentre sur la migration progressive de Python 3.14 à 3.15. Le hub Python présente le parcours complet.

Réponse rapide

Si vous êtes déjà sur Python 3.14, Python 3.15 est particulièrement intéressant si vous vous souciez de :

  • temps de démarrage des applications et CLI ;
  • configuration et données de mapping immuables ;
  • API qui doivent distinguer « non fourni » de None ;
  • aplatissement et fusion plus simples dans les compréhensions ;
  • encodage texte par défaut plus prévisible ;
  • profiling et diagnostic en production ;
  • expérimentation avec le JIT plus récent ;
  • évolution du free-threading et de la compatibilité des extensions C.

Si votre application est stable en 3.14 et dépend de packages natifs, d’un runtime Python managé, de PySpark ou d’un service cloud dont vous ne contrôlez pas la version Python, commencez par vérifier la compatibilité.

Python 3.15 vs 3.14 en un coup d’œil

Domaine Python 3.14 Python 3.15 Impact pratique
Imports paresseux Patterns manuels ou imports locaux Syntaxe explicite lazy import Peut réduire le travail au démarrage
Mappings immuables Pas de frozendict intégré frozendict intégré Configuration/état immuable plus sûr
Valeurs sentinelles Souvent object() ou objets personnalisés sentinel() intégré API plus claires et meilleur typage
Encodage texte par défaut Le comportement plateforme/locale reste important Mode UTF-8 activé par défaut I/O texte plus prévisible
Compréhensions Syntaxe imbriquée classique Déballage * et ** Transformations plus lisibles
Profiling Outils existants Nouveau package profiling et Tachyon Meilleur diagnostic en production
JIT expérimental JIT encore jeune JIT fortement amélioré Plus de code peut être optimisé
Écosystème free-threading Fortes avancées en 3.14 Travail ABI/runtime supplémentaire Meilleure voie pour les extensions
Runtime Windows Configuration précédente Interpréteur tail-calling dans les binaires officiels 64 bits Gain potentiel spécifique à la plateforme
Free-threading macOS Disponible en option Support installé par défaut dans les binaires officiels Expérimentation plus simple

Le point essentiel : Python 3.15 s’appuie sur 3.14. Il ne remplace pas les idées introduites en 3.14 ; il en pousse plusieurs plus loin.

Ce que Python 3.14 apportait déjà

Avant de regarder 3.15, il faut comprendre la base.

Python 3.14 avait déjà introduit ou fortement fait progresser :

  • l’évaluation différée des annotations ;
  • les améliorations majeures du mode free-threaded ;
  • les binaires expérimentaux JIT sous Windows et macOS ;
  • les template string literals ;
  • une interface de bibliothèque standard pour les sous-interpréteurs ;
  • des capacités runtime et tooling plus fortes.

Ainsi, le saut 3.14 → 3.15 est bien plus petit que le saut 3.11 → 3.15.

Si vous venez de Python 3.11, consultez le guide plus large Python 3.15 vs 3.11. Ici, on se concentre uniquement sur 3.14 → 3.15.

1. Les imports paresseux explicites sont le changement applicatif le plus visible

Les grosses applications Python paient souvent au démarrage le coût de modules qui ne seront jamais utilisés sur un chemin d’exécution donné.

Avant 3.15, on déplaçait souvent les imports coûteux dans la fonction qui en avait besoin :

def export_report(data):
    import expensive_reporting_library

    return expensive_reporting_library.render(data)

Python 3.15 ajoute les imports paresseux explicites :

lazy import json
lazy from pathlib import Path

print("Application started")

payload = json.loads('{"status": "ok"}')
path = Path("output.json")

Les noms restent au niveau du module, mais le travail d’import est repoussé jusqu’à la première utilisation.

C’est particulièrement intéressant pour :

  • les applications CLI ;
  • les fonctions serverless ;
  • les outils développeur ;
  • les plugins ;
  • les applications avec de gros graphes de dépendances ;
  • les fonctionnalités optionnelles rarement utilisées.

Ce n’est pas automatiquement un gain pour tous les programmes. Si un module est toujours utilisé immédiatement, il faudra de toute façon l’importer.

Mode global des imports paresseux

Python 3.15 fournit aussi un mode global avec l’option -X lazy_imports=all et la variable PYTHON_LAZY_IMPORTS. Les modes pris en charge sont all et normal.

Cela permet d’évaluer ce comportement sans réécrire immédiatement tous les imports.

2. frozendict apporte enfin un mapping immuable intégré

Python disposait depuis longtemps de tuples immuables et de frozenset, mais pas d’équivalent intégré immuable à dict.

Python 3.15 ajoute frozendict :

settings = frozendict(
    environment="prod",
    retries=3,
    region="us-east"
)

print(settings["environment"])

# TypeError: 'frozendict' object does not support item assignment
settings["retries"] = 5

Un frozendict peut être hashable lorsque ses clés et valeurs le sont, ce qui ouvre des cas d’usage intéressants pour le caching et la configuration stable.

from functools import lru_cache

@lru_cache
def build_client(options: frozendict):
    print("creating client")
    return object()

config = frozendict(region="us-east", retries=3)

client1 = build_client(config)
client2 = build_client(config)

Quand est-ce utile ?

frozendict est adapté à :

  • la configuration immuable ;
  • les clés de cache ;
  • les snapshots de métadonnées ;
  • l’état partagé qui ne doit pas être modifié ;
  • les API qui veulent recevoir un mapping sans permettre sa mutation.

Il ne faut pas remplacer tous les dict par frozendict.

3. sentinel() simplifie un vieux pattern Python

Un problème classique est de distinguer :

  • « l’appelant a passé None » ;
  • « l’appelant n’a rien fourni ».

Historiquement :

_NOT_GIVEN = object()

def update_name(value=_NOT_GIVEN):
    if value is _NOT_GIVEN:
        return "leave unchanged"

    if value is None:
        return "clear the value"

    return f"set to {value}"

Python 3.15 ajoute sentinel() :

NOT_GIVEN = sentinel("NOT_GIVEN")

def update_name(value=NOT_GIVEN):
    if value is NOT_GIVEN:
        return "leave unchanged"

    if value is None:
        return "clear the value"

    return f"set to {value}"

La représentation est aussi plus claire :

>>> NOT_GIVEN
NOT_GIVEN

Les sentinelles préservent leur identité lors de copies, peuvent participer directement aux expressions de type et peuvent être sérialisées dans les conditions appropriées.

4. Le déballage dans les compréhensions réduit le boilerplate

Pour aplatir une liste de listes en 3.14 :

batches = [
    [101, 102],
    [103, 104],
    [105],
]

flat = [
    item
    for batch in batches
    for item in batch
]

En 3.15 :

batches = [
    [101, 102],
    [103, 104],
    [105],
]

flat = [*batch for batch in batches]

print(flat)
# [101, 102, 103, 104, 105]

Même principe pour les sets et les dictionnaires :

parts = [
    {"region": "us"},
    {"environment": "prod"},
    {"retries": 3},
]

config = {**part for part in parts}

Ce n’est pas révolutionnaire, mais cela simplifie beaucoup de code de transformation Python.

5. UTF-8 devient l’encodage par défaut

Python 3.15 active le mode UTF-8 par défaut.

Ainsi :

with open("config.txt") as file:
    text = file.read()

utilise UTF-8 par défaut au lieu de dépendre de la locale de la plateforme.

Cela réduit les surprises entre postes développeur, conteneurs Linux et environnements Windows.

L’encodage explicite reste néanmoins une bonne pratique :

with open("config.txt", encoding="utf-8") as file:
    text = file.read()

Pourquoi continuer à l’écrire ? Parce que cela documente le contrat, fonctionne sur des versions Python antérieures et évite toute ambiguïté.

6. Python 3.15 améliore le profiling et l’observabilité

Python 3.15 ajoute un nouveau package profiling et un profiler statistique nommé Tachyon.

C’est important car un profiler par échantillonnage ne répond pas au même besoin qu’un profiler déterministe.

Tachyon peut notamment :

  • s’attacher à un processus Python existant ;
  • lancer et profiler un script ;
  • profiler un module ;
  • capturer des snapshots de stack ;
  • distinguer wall-clock, CPU, GIL et exceptions ;
  • produire des sorties adaptées aux flame graphs.

Python 3.15 active aussi les frame pointers par défaut sur les builds compatibles, ce qui améliore le déroulage natif pour les outils système.

Pour une application Python critique, ces améliorations peuvent être plus importantes qu’une nouvelle syntaxe.

7. Le JIT expérimental est bien plus capable

Python 3.14 avait déjà rendu le JIT expérimental plus accessible dans les binaires officiels Windows et macOS.

Python 3.15 l’améliore fortement :

  • nouveau frontend de tracing ;
  • support plus large du bytecode et du contrôle de flux ;
  • allocation de registres de base ;
  • davantage d’optimisations ;
  • meilleur code machine ;
  • meilleur support du déroulage.

Selon la documentation de Python 3.15, pyperformance montre environ 7–8 % d’amélioration moyenne géométrique du JIT par rapport à l’interpréteur optimisé standard sur Linux x86-64, et 11–12 % par rapport à l’interpréteur tail-calling sur macOS AArch64.

Mais ces chiffres demandent du contexte.

Les benchmarks individuels vont d’environ 15 % plus lent à plus de 100 % plus rapide.

La bonne conclusion n’est donc pas :

Python 3.15 est 8 % plus rapide.

Mais :

Le JIT expérimental de Python 3.15 est nettement plus mature, mais son bénéfice dépend toujours de la charge de travail.

8. Il existe aussi des accélérations ciblées de la bibliothèque standard

Python 3.15 contient aussi des optimisations ciblées :

  • Base64 : encodage environ 2× plus rapide et décodage environ 3× plus rapide ;
  • réécritures Base32/Base85 avec gains importants sur certaines opérations ;
  • csv.Sniffer.sniff() jusqu’à 1,6× plus rapide.

Ce sont des gains réels mais spécifiques à certaines charges.

9. Windows et macOS reçoivent aussi des changements de runtime

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

La documentation officielle rapporte des gains importants dans la configuration de test documentée, mais il ne faut pas généraliser à toutes les applications Windows.

Sur macOS, les binaires officiels installent désormais par défaut le support free-threading, ce qui rend l’expérimentation plus simple.

Python 3.15 est-il plus rapide que Python 3.14 ?

Parfois. Mais il n’existe pas un pourcentage unique responsable pour « Python 3.15 vs 3.14 ».

La performance dépend de :

  • système d’exploitation ;
  • architecture CPU ;
  • build de l’interpréteur ;
  • JIT activé ou non ;
  • proportion de code natif ;
  • startup vs exécution longue ;
  • I/O vs CPU ;
  • correspondance avec les opérations optimisées.

C’est pourquoi l’article performance doit traiter la mesure comme partie intégrante de la décision.

Ce que Python 3.15 signifie pour les data engineers

Pour la data engineering, les changements les plus utiles ne sont pas toujours les chiffres de benchmark.

Meilleur démarrage

Les CLI, scripts d’orchestration, outils de déploiement et fonctions serverless peuvent profiter des imports paresseux.

Configuration plus propre

frozendict est adapté aux configurations immuables et snapshots de métadonnées.

Meilleure sémantique de valeur manquante

sentinel() aide lorsque None est une valeur métier valide.

Fichiers texte plus prévisibles

UTF-8 par défaut réduit les écarts entre plateformes.

Meilleur diagnostic

Tachyon et les améliorations d’observabilité aident à identifier les goulots Python.

Mais les runtimes managés sont différents

Une nouvelle version CPython ne signifie pas automatiquement que Microsoft Fabric, Spark, Databricks, Azure Functions ou un autre environnement managé supporte Python 3.15.

Il faut toujours distinguer :

Python 3.15 exists

de :

My platform supports Python 3.15

Faut-il migrer de Python 3.14 vers 3.15 ?

Situation Recommandation
Développement local et apprentissage Mettre à niveau et expérimenter
Outils CLI sensibles au démarrage Très bon candidat ; tester les imports paresseux
Service CPU-bound en Python pur Tester 3.15 et le JIT séparément
Backend stable en production Passer par tests et staging
Application avec beaucoup d’extensions natives Vérifier chaque dépendance
Runtime cloud managé Attendre le support explicite
PySpark / Spark managé Vérifier la version Python supportée
Mainteneur de bibliothèque Ajouter tôt Python 3.15 à la CI

Checklist de migration

Avant la production :

  1. Installer Python 3.15 à côté de 3.14.
  2. Créer un environnement virtuel propre.
  3. Réinstaller les dépendances.
  4. Exécuter toute la suite de tests.
  5. Exécuter analyse statique et type checking.
  6. Inspecter warnings et dépréciations.
  7. Vérifier les extensions natives.
  8. Tester le démarrage si c’est important.
  9. Benchmarker les charges critiques sur le même matériel.
  10. Tester le JIT séparément.
  11. Vérifier CI et images conteneur.
  12. Vérifier les runtimes managés.
  13. Passer par staging avant production.

Une mise à niveau Python est un changement logiciel. Traitez-la comme telle.

Conclusion

Python 3.14 était déjà une version importante. Python 3.15 est intéressant car il transforme plusieurs patterns historiques en fonctionnalités de premier ordre.

Les changements les plus utiles au quotidien sont probablement :

  • imports paresseux explicites ;
  • frozendict ;
  • sentinel() ;
  • UTF-8 par défaut ;
  • déballage dans les compréhensions ;
  • nouvelle pile de profiling.

Le JIT amélioré est techniquement intéressant, mais doit être mesuré plutôt que supposé.

Pour la méthode de benchmark et le détail du JIT, poursuivez avec l’analyse des performances de Python 3.15. Si vous partez d’une version plus ancienne, le guide Python 3.11 à 3.15 couvre l’historique de compatibilité.

Références officielles

Étiquettes

  • Python
  • Performance
  • Concurrence
  • Observabilité