Python

Python 3.15 vs 3.11 : nouveautés et guide de migration

Dé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.

Par JaviPublié Mis à jour 26 min de lectureIntermédiaire

Dans cet article

Python 3.15.0 est sorti le 9 octobre 2026. Si vous êtes encore sous Python 3.11, vous n’avez pas une version de retard, mais quatre. Et Python 3.11 ne reçoit plus que des correctifs de sécurité, jusqu’en octobre 2027.

Ce guide répond à une seule question :

Qu’est-ce qui a changé entre Python 3.11 et Python 3.15, et qu’est-ce qui compte vraiment pour les développeurs ?

Chaque fonctionnalité est associée à la version qui l’a réellement introduite. Une bonne partie de ce que l’on présente comme « nouveau dans 3.15 » est arrivée en 3.12, 3.13 ou 3.14. Si vous passez directement de 3.11 à 3.15, vous recevez tout d’un coup, y compris toutes les ruptures de compatibilité.

Tous les exemples de code ont été exécutés sur la version officielle de CPython 3.15.0. Chacun indique la version minimale requise.

Ce guide suit l’évolution de Python version par version, de 3.11 à 3.15. Le hub Python présente le parcours complet.

Réponse rapide

  • 3.15 est-elle une vraie montée de version depuis 3.11 ? Oui. Le langage, le typage, les messages d’erreur, les outils de profilage et le runtime ont tous nettement progressé. Certaines des nouveautés les plus utiles au code applicatif sont propres à 3.15 : lazy import, frozendict, sentinel et l’UTF-8 comme encodage par défaut.
  • Qui devrait migrer maintenant : les équipes qui maîtrisent leur runtime (API, CLI, conteneurs, workers d’automatisation) et dont les dépendances publient déjà des wheels pour 3.15.
  • Qui devrait attendre : les utilisateurs de plateformes managées (notebooks, Spark, serverless) qui ne proposent pas encore 3.15, et ceux dont les dépendances compilées ne sont pas prêtes.
  • Principale mise en garde : passer de 3.11 à 3.15, c’est encaisser quatre séries de suppressions et de changements de comportement. Les deux plus susceptibles de vous surprendre sont l’UTF-8 comme encodage texte par défaut (3.15) et les modules supprimés en 3.12 et 3.13 (distutils, imp, cgi, telnetlib, lib2to3, etc.).
  • Performances : il n’existe pas de chiffre officiel du type « 3.15 est X % plus rapide que 3.11 », et cet article n’en invente pas. Les chiffres vérifiés dépendent de la charge de travail et sont détaillés dans la section consacrée aux performances.

Vous utilisez déjà 3.14 ? Consultez la comparaison ciblée Python 3.15 vs 3.14. Pour les chiffres du JIT et un plan de mesure reproductible, lisez l’analyse des performances de Python 3.15.

De Python 3.11 à 3.15 : chronologie des versions

Version Sortie Support (oct. 2026) Principaux changements
3.11 Oct. 2022 Sécurité uniquement, jusqu’en oct. 2027 CPython plus rapide (environ 1,25× vs 3.10 en moyenne), localisation fine des erreurs dans les tracebacks, ExceptionGroup et except*, asyncio.TaskGroup, tomllib, typing.Self
3.12 Oct. 2023 Sécurité uniquement, jusqu’en oct. 2028 Instruction type et syntaxe générique def f[T](), f-strings plus souples, inlining des compréhensions, sys.monitoring, support de perf sous Linux, itertools.batched ; suppression de distutils
3.13 Oct. 2024 Sécurité uniquement, jusqu’en oct. 2029 Nouveau REPL interactif, tracebacks en couleur, build free-threaded expérimental, JIT expérimental (option de compilation), copy.replace(), warnings.deprecated ; 19 modules historiques supprimés
3.14 Oct. 2025 Corrections de bugs, jusqu’en oct. 2030 Build free-threaded officiellement supporté, annotations différées, template strings (t"..."), except A, B: sans parenthèses, concurrent.interpreters, compression.zstd, JIT inclus dans les binaires Windows/macOS (désactivé par défaut)
3.15 Oct. 2026 Corrections de bugs, jusqu’en oct. 2031 lazy import, frozendict, sentinel, UTF-8 par défaut, unpacking dans les compréhensions, package profiling avec le profileur par échantillonnage Tachyon, frame pointers par défaut, ABI stable abi3t pour les extensions free-threaded, JIT amélioré (toujours expérimental)

À partir de 3.13, chaque version reçoit deux ans de corrections de bugs puis trois ans de correctifs de sécurité. Python 3.15 est donc supporté jusqu’à octobre 2031 environ.

Python 3.11 vs 3.15 en un coup d’œil

Domaine Python 3.11 Python 3.15 (et quand cela a changé)
Interpréteur Interpréteur adaptatif spécialisant (nouveau en 3.11) Même base, plus l’inlining des compréhensions (3.12) et un interpréteur tail-calling dans les binaires officiels Windows x64 (3.15)
JIT Aucun Expérimental et désactivé par défaut. Option de compilation en 3.13, inclus dans les binaires Windows/macOS en 3.14, nettement amélioré en 3.15
Threads multicœurs GIL toujours actif Build free-threaded optionnel : expérimental en 3.13, officiellement supporté en 3.14, ABI stable pour les extensions (abi3t) en 3.15
Démarrage/imports Tous les imports sont immédiats lazy import explicite (3.15)
Langage match, except* f-strings plus souples (3.12), templates t"..." (3.14), except A, B: (3.14), [*x for x in xs] (3.15)
Types natifs dict, sentinelles via object() Built-ins frozendict et sentinel (3.15)
Typage Self, LiteralString, TypeVarTuple Alias type et syntaxe [T] (3.12), @override (3.12), TypeIs et ReadOnly (3.13), annotations différées (3.14), TypedDict fermé et TypeForm (3.15)
Encodage texte par défaut Dépend de la locale (souvent cp1252 sous Windows) UTF-8 partout (3.15)
Profilage cProfile, profile sys.monitoring et support de perf (3.12), attachement sécurisé d’un débogueur externe (3.14), package profiling et Tachyon (3.15), frame pointers par défaut (3.15)
Messages d’erreur Localisation fine (nouveau en 3.11) Plus de suggestions « Did you mean » (3.12–3.15), tracebacks en couleur (3.13), suggestions venues d’autres langages comme .push → .append (3.15)
Suppressions Référence distutils, imp, asyncore (3.12) ; 19 modules « dead batteries » et lib2to3 (3.13) ; anciennes classes de nœuds ast (3.14) ; modules sre_* et load_module() (3.15)

Les principales nouveautés de Python 3.15

Ces fonctionnalités sont nouvelles en 3.15. Aucune n’existait en 3.14.

Imports lazy explicites (PEP 810)

De quoi s’agit-il : un mot-clé contextuel lazy. Un import lazy lie le nom immédiatement, mais ne charge le module qu’à la première utilisation de ce nom.

# Nécessite Python 3.15+
lazy import decimal
import sys

print("decimal loaded at startup?", "decimal" in sys.modules)
price = decimal.Decimal("19.99")
print("decimal loaded after use?", "decimal" in sys.modules)
print(price * 3)
decimal loaded at startup? False
decimal loaded after use? True
59.97

lazy from pathlib import Path fonctionne de la même manière.

Les règles à connaître :

  • lazy n’est autorisé qu’au niveau du module. Dans une fonction, un corps de classe ou un bloc try/except, c’est une SyntaxError.
  • lazy from module import * et lazy from __future__ import ... sont interdits.
  • Une erreur d’import n’apparaît plus au démarrage, mais à la première utilisation. Un module manquant échoue là où il est utilisé, pas là où il est importé :
# Nécessite Python 3.15+
lazy import does_not_exist

print("startup ok")       # ceci s'affiche
does_not_exist.run()      # ModuleNotFoundError levée ici
  • Vous pouvez rendre tous les imports lazy sans toucher au code avec -X lazy_imports=all ou PYTHON_LAZY_IMPORTS=all. La valeur par défaut est normal, qui ne respecte que le mot-clé lazy. Considérez all comme une expérimentation : les modules qui ont des effets de bord à l’import (enregistrement de plugins, patch d’autres modules) peuvent changer de comportement.

Les bibliothèques qui supportent encore d’anciennes versions ne peuvent pas utiliser le mot-clé lazy, qui est une erreur de syntaxe en 3.14 et avant. La PEP 810 prévoit une alternative compatible : une liste __lazy_modules__ au niveau du module. Python 3.15 rend les imports listés lazy, et les versions antérieures ignorent simplement la variable.

# Fonctionne sur tout Python 3 ; lazy uniquement en 3.15+
__lazy_modules__ = ["decimal"]

import decimal

Quand est-ce utile : CLI avec de nombreuses sous-commandes, applications avec de gros arbres de dépendances, jobs de courte durée, fonctions serverless, et tout code qui importe des bibliothèques lourdes sur des chemins que la plupart des exécutions n’empruntent jamais.

Est-ce important pour un développeur lambda ? Oui, si le temps de démarrage compte pour vous. C’est l’une des nouveautés 3.15 les plus pratiques. Mesurez avant et après avec python -X importtime (disponible depuis 3.7).

frozendict : un mapping immuable intégré (PEP 814)

De quoi s’agit-il : un nouveau type natif qui reprend la partie lecture seule de l’API de dict. Il est hashable si ses clés et ses valeurs le sont. Ce n’est pas une sous-classe de dict.

# Nécessite Python 3.15+
DEFAULTS = frozendict(env="dev", region="eu-west", retries=3)

prod = DEFAULTS | {"env": "prod"}   # crée un nouveau frozendict
print(prod)
print(DEFAULTS["env"])

try:
    DEFAULTS["env"] = "prod"
except TypeError as exc:
    print(exc)

# Hashable : utilisable comme clé de dict ou de cache
row_counts = {frozendict(table="orders", day="2026-10-01"): 1_204}
print(row_counts[frozendict(day="2026-10-01", table="orders")])
print(isinstance(DEFAULTS, dict))
frozendict({'env': 'prod', 'region': 'eu-west', 'retries': 3})
dev
'frozendict' object does not support item assignment
1204
False

Quand est-ce utile : valeurs de configuration par défaut, métadonnées partagées entre threads, clés de cache construites à partir de plusieurs champs, et valeurs de retour que l’appelant ne doit pas modifier. json, pickle, copy et pprint le prennent en charge.

Attention : au code qui teste isinstance(x, dict). Un frozendict échoue à ce test. Testez plutôt collections.abc.Mapping si les deux types doivent être acceptés.

Avant 3.15, le contournement habituel était types.MappingProxyType. C’est une vue en lecture seule d’un dict, qui peut encore changer en dessous, et elle n’est pas hashable.

sentinel : un built-in pour « aucune valeur fournie » (PEP 661)

De quoi s’agit-il : un built-in qui crée des marqueurs uniques avec un repr lisible, le support de la copie et du pickle, et un usage possible dans les annotations de type.

# Nécessite Python 3.15+
MISSING = sentinel("MISSING")

def get_setting(name: str, default: str | None | MISSING = MISSING) -> str | None:
    settings = {"region": "eu-west", "proxy": None}
    if name in settings:
        return settings[name]
    if default is MISSING:
        raise KeyError(name)
    return default

print(get_setting("proxy"))                 # None : le paramètre existe et vaut None
print(get_setting("timeout", default=None)) # None : l'appelant a choisi None
print(MISSING)
None
None
MISSING

Quand est-ce utile : toute API où None est une valeur légitime, comme des paramètres de configuration, des mises à jour partielles ou des paramètres optionnels de bibliothèque. Il remplace le motif _MISSING = object(), dont le repr est un <object object at 0x...> peu parlant.

Est-ce important pour un développeur lambda ? C’est une petite amélioration pour le code applicatif, plus utile aux auteurs de bibliothèques.

L’UTF-8 devient l’encodage par défaut (PEP 686)

De quoi s’agit-il : Python 3.15 fonctionne par défaut en mode UTF-8, quelle que soit la locale du système. open(), Path.read_text() et les autres E/S texte sans encoding= explicite utilisent désormais l’UTF-8.

C’est probablement le changement de comportement le plus important pour qui vient de 3.11, en particulier sous Windows. Sur un poste Windows d’Europe occidentale, Python 3.11 utilisait cp1252 quand aucun encodage n’était précisé.

# Python 3.15
import sys, locale
print(sys.flags.utf8_mode)                   # 1
print(locale.getpreferredencoding(False))    # utf-8

Ce qui peut casser : les scripts qui lisent sans préciser l’encodage des fichiers écrits dans une page de code historique. Ils obtiennent désormais une UnicodeDecodeError ou des caractères corrompus au lieu du bon texte.

Comment s’y préparer en restant sous 3.11 :

# Python 3.10+ : avertit partout où l'encodage n'est pas précisé
python -X warn_default_encoding -m pytest

# Python 3.7+ : exécute les tests comme le fera 3.15
python -X utf8 -m pytest

Vous pouvez désactiver ce comportement en 3.15 avec PYTHONUTF8=0 ou -X utf8=0. La meilleure correction reste de passer encoding= explicitement partout où vous lisez ou écrivez des fichiers texte.

Unpacking dans les compréhensions (PEP 798)

# Nécessite Python 3.15+
batches = [["a.csv", "b.csv"], ["c.csv"], []]
files = [*batch for batch in batches]
print(files)   # ['a.csv', 'b.csv', 'c.csv']

partitions = [{"orders": 120}, {"customers": 40}, {"orders": 125}]
latest = {**p for p in partitions}
print(latest)  # {'orders': 125, 'customers': 40}

Cela remplace [x for batch in batches for x in batch] et itertools.chain.from_iterable. C’est agréable, mais pas une raison de migrer à elle seule.

Le package profiling et le profileur par échantillonnage Tachyon (PEP 799)

De quoi s’agit-il : un nouveau package profiling. profiling.tracing est le profileur déterministe, le même que cProfile, qui reste disponible. profiling.sampling est Tachyon, un nouveau profileur statistique par échantillonnage, capable d’échantillonner à très haute fréquence et de s’attacher à un processus déjà en cours d’exécution.

# Python 3.15+
python -m profiling.sampling run etl.py                                   # tableau des fonctions les plus coûteuses
python -m profiling.sampling run --flamegraph -o flame.html etl.py        # flame graph HTML
python -m profiling.sampling run -m mypackage.job                         # profiler un module
python -m profiling.sampling attach 12345                                 # s'attacher à un PID en cours
python -m profiling.sampling dump 12345                                   # instantané ponctuel de la pile

Il propose aussi --mode cpu|wall|gil|exception, --async-aware pour les tâches asyncio, et une vue terminal --live.

Pourquoi c’est important : un profileur par traçage enregistre chaque appel et ralentit le programme, ce qui peut fausser le résultat. Un profileur par échantillonnage inspecte la pile à intervalles réguliers. Il convient donc mieux aux charges longues ou proches de la production. Pouvoir « s’attacher à un PID » est exactement ce qu’il faut quand un worker est bloqué ou lent et que vous ne pouvez pas le relancer avec le profilage activé.

Dépréciation : le module profile, écrit en Python pur, est déprécié et sa suppression est prévue en 3.17. cProfile reste.

Frame pointers activés par défaut (PEP 831)

CPython 3.15 est compilé avec les frame pointers sur les plateformes compatibles. Vous ne le verrez pas dans votre code. C’est important pour les ingénieurs plateforme et performance : les profileurs système (perf, outils basés sur eBPF, profileurs continus) reconstruisent de façon plus fiable les piles d’appels mixtes Python/natif.

Typage : TypedDict fermé, TypeForm, disjoint_base

# Nécessite Python 3.15+ (le type checker applique ces règles, pas le runtime)
from typing import TypedDict

class Row(TypedDict, closed=True):        # aucune clé en dehors de celles-ci
    id: int
    name: str

class Metrics(TypedDict, extra_items=float):  # clés supplémentaires autorisées, valeurs float
    run_id: str

m: Metrics = {"run_id": "r1", "rows_per_sec": 1250.0}

Les TypedDict fermés (PEP 728) servent à typer des payloads JSON et des enregistrements où une clé inattendue est un bug. TypeForm (PEP 747) permet d’annoter des fonctions qui reçoivent un type comme valeur, comme les validateurs et les helpers de type cast. @typing.disjoint_base (PEP 800) concerne surtout les auteurs de type checkers et de stubs.

Votre type checker doit supporter ces PEP pour qu’elles soient utiles. Vérifiez votre version de mypy ou de pyright.

Autres changements 3.15 à connaître

  • De meilleurs messages d’erreur. Ces suggestions apparaissent dans les tracebacks :
AttributeError: 'list' object has no attribute 'push'. Did you mean '.append'?
AttributeError: 'dict' object has no attribute 'put'. Use d[k] = v.
  • math.integer : un nouveau module qui regroupe les fonctions sur les entiers (comb, factorial, gcd, isqrt, lcm, perm).
  • Fichiers de démarrage de packages (PEP 829) : les packages peuvent déclarer des points d’entrée de démarrage dans des fichiers .start. Les lignes import des fichiers .pth sont désormais dépréciées sans avertissement. Cela compte si vous maintenez des outils qui s’appuient sur des astuces .pth.
  • bytearray.take_bytes() récupère des bytes depuis un bytearray sans copie.
  • ABI stable free-threaded (abi3t, PEP 803) : les extensions C peuvent désormais publier une seule wheel pour les builds free-threaded au lieu d’une par version de Python. C’est invisible pour les développeurs d’applications, mais cela devrait aider les packages à supporter le free-threading.

Exemples de code pratiques : ce que 3.12 à 3.14 vous apportent aussi

Si vous venez de 3.11, ces fonctionnalités plus anciennes sont aussi nouvelles pour vous. Chaque exemple indique sa version minimale. Tous fonctionnent en 3.15.

# Nécessite Python 3.12+ : syntaxe générique, alias de type, f-strings, batched
from itertools import batched

type Batch[T] = list[T]

def first[T](items: list[T]) -> T:
    return items[0]

print(list(batched(range(7), 3)))       # [(0, 1, 2), (3, 4, 5), (6,)]

tables = ["orders", "customers"]
print(f"tables: {", ".join(tables)}")   # réutiliser le même guillemet est une SyntaxError en 3.11
# Nécessite Python 3.13+ : copy.replace pour les enregistrements immuables
import copy
from dataclasses import dataclass

@dataclass(frozen=True)
class Job:
    name: str
    retries: int = 3

print(copy.replace(Job("load_orders"), retries=5))
# Job(name='load_orders', retries=5)
# Nécessite Python 3.14+ : template strings et except sans parenthèses
from string.templatelib import Interpolation

table = "orders"
query = t"SELECT * FROM {table}"
values = [part.value for part in query if isinstance(part, Interpolation)]
print(type(query).__name__, values)   # Template ['orders']

try:
    int("x")
except ValueError, TypeError:
    print("caught")

Les template strings sont utiles parce que, contrairement aux f-strings, elles ne produisent pas immédiatement une chaîne. Une bibliothèque reçoit séparément les parties littérales et les valeurs interpolées, et peut donc échapper ou paramétrer ces valeurs de façon sûre. SQL et HTML sont les cas d’usage évidents.

Ce qui a changé entre 3.11 et 3.15 au-delà de la syntaxe

Interpréteur et runtime

  • 3.12 a inliné les compréhensions de listes, de dicts et d’ensembles, ce qui les rend jusqu’à 2× plus rapides selon les notes de version de 3.12.
  • 3.13 a livré un build free-threaded expérimental (un interpréteur distinct, généralement nommé python3.13t) et un JIT expérimental à activer à la compilation. Elle a aussi défini la sémantique de locals() (PEP 667), ce qui peut affecter les débogueurs et le code qui modifie locals().
  • 3.14 a rendu le build free-threaded officiellement supporté (PEP 779), avec un ralentissement d’environ 5 à 10 % en mono-thread selon les notes de version. Les binaires Windows et macOS ont commencé à inclure le JIT, désactivé par défaut. 3.14 a aussi ajouté concurrent.interpreters et InterpreterPoolExecutor pour exécuter plusieurs interpréteurs isolés dans un même processus (PEP 734).
  • 3.15 a amélioré le JIT et fait passer les binaires officiels Windows x64 à l’interpréteur tail-calling. Sur macOS, l’installeur officiel installe désormais le support du free-threading par défaut.

Typage

  • 3.12 : type Alias = ..., def f[T](x: T) -> T, @override et TypedDict pour **kwargs.
  • 3.13 : valeurs par défaut des paramètres de type, TypeIs, ReadOnly et @warnings.deprecated.
  • 3.14 : les annotations sont évaluées de façon différée (PEP 649/749), les références avant n’ont donc plus besoin de guillemets. Le code qui lit __annotations__ directement devrait passer à annotationlib.get_annotations(). from __future__ import annotations est désormais déprécié, mais fonctionne toujours.
  • 3.15 : TypedDict fermé, TypeForm, disjoint_base. La forme par mots-clés NamedTuple("P", x=int) n’est plus supportée.

Bibliothèque standard

  • 3.11 : tomllib, asyncio.TaskGroup, asyncio.timeout().
  • 3.12 : itertools.batched, pathlib.Path.walk().
  • 3.13 : copy.replace().
  • 3.14 : compression.zstd (Zstandard dans la bibliothèque standard), introspection asyncio et coloration syntaxique dans le REPL.
  • 3.15 : frozendict, sentinel, profiling, math.integer, et base64, base32, base85 et csv.Sniffer plus rapides.

Démarrage et imports

Python 3.11 a accéléré le démarrage d’environ 10 à 15 % en gelant les modules du cœur. Python 3.15 est la première version qui vous permet de différer vous-même vos imports, avec lazy import. Rien entre 3.12 et 3.14 ne le permettait.

Débogage et observabilité

  • 3.12 : sys.monitoring (PEP 669) pour des profileurs, débogueurs et outils de couverture à faible surcoût, et intégration avec perf sous Linux via -X perf.
  • 3.13 : un nouveau REPL avec édition multiligne et des tracebacks en couleur par défaut.
  • 3.14 : une interface sécurisée pour débogueurs externes (PEP 768), qui permet à un débogueur de s’attacher à un processus en cours.
  • 3.15 : Tachyon, frame pointers et de meilleures suggestions d’erreur.

Packaging et workflow

  • 3.12 : venv n’installe plus setuptools, et distutils a disparu. Les anciens workflows basés sur setup.py qui dépendaient de l’un ou de l’autre ont besoin de pip install setuptools ou d’un passage à pyproject.toml.
  • 3.14 : sous Linux et les autres Unix hors macOS, multiprocessing et ProcessPoolExecutor démarrent désormais les processus avec forkserver au lieu de fork. Le code qui comptait sur l’héritage de l’état global par les processus enfants peut échouer avec des NameError ou des erreurs de pickle.
  • 3.15 : les téléchargements officiels pour Windows renvoient vers le gestionnaire d’installation Python (py install 3.15).

Performances : ce qui est réellement vérifié

Il faut distinguer les fonctionnalités du langage des améliorations de l’implémentation CPython. Les imports lazy sont une fonctionnalité du langage : ils fonctionnent sur toute implémentation de Python 3.15 et vous les contrôlez dans le code. Le JIT, l’interpréteur tail-calling et les frame pointers sont des détails d’implémentation de CPython : leur effet dépend du build, de la plateforme et de la charge de travail.

Voici les chiffres publiés par le projet CPython lui-même. Cet article n’en ajoute aucun autre.

Changement Version Chiffre publié Contexte
Faster CPython 3.11 10 à 60 % plus rapide que 3.10 ; environ 1,25× en moyenne Suite de benchmarks pyperformance
Inlining des compréhensions 3.12 Compréhensions jusqu’à 2× plus rapides Micro-benchmarks centrés sur les compréhensions
Build free-threaded 3.14 Ralentissement de 5 à 10 % en mono-thread Le prix de la suppression du GIL ; les gains ne viennent que des threads parallèles
JIT 3.15 7 à 8 % en moyenne géométrique sur x86-64 Linux ; 11 à 12 % sur AArch64 macOS Selon les benchmarks, d’environ 15 % plus lent à plus de 100 % plus rapide
Interpréteur tail-calling 3.15 (binaires Windows x64) 15 à 20 % vs l’interpréteur switch-case Moyenne géométrique pyperformance sous Windows x86-64
base64 3.15 Encodage 2× plus rapide, décodage 3× plus rapide Seulement si votre charge encode ou décode du base64
Base32 / Base85 / Ascii85 / Z85 3.15 Environ deux ordres de grandeur plus rapides Réécrits en C
csv.Sniffer.sniff() 3.15 Jusqu’à 1,6× plus rapide Détection du délimiteur uniquement, pas csv.reader

Ce que cela signifie en pratique :

  • Il n’existe pas de chiffre officiel de bout en bout « 3.11 → 3.15 ». Votre gain dépend de votre charge de travail. En data, une grande partie du temps d’exécution se passe souvent dans des bibliothèques natives (NumPy, Arrow, drivers de bases de données), que les améliorations de l’interpréteur n’accélèrent pas.
  • Le JIT est toujours expérimental et désactivé par défaut. Dans les binaires officiels Windows et macOS, on l’active avec PYTHON_JIT=1. Mesurez votre propre charge avec et sans. Certains benchmarks ralentissent.
  • Le free-threading est un autre build, pas un réglage à activer. Il aide le code Python CPU-bound réparti sur plusieurs threads, et seulement si toutes vos extensions C le supportent. Le code mono-thread tourne un peu plus lentement.
  • Mesurez le démarrage et le régime établi séparément. Les imports lazy améliorent le temps de démarrage. Le JIT et le travail sur l’interpréteur concernent les boucles longues.
# Démarrage : quels imports coûtent le plus ?
python -X importtime -c "import mypackage.cli" 2> imports.log

# Régime établi : comparer la même charge selon les versions
python3.11 bench_transform.py
python3.15 bench_transform.py
PYTHON_JIT=1 python3.15 bench_transform.py

Ruptures de compatibilité et suppressions (3.11 → 3.15)

Passer directement de 3.11 à 3.15, c’est encaisser d’un coup toutes les suppressions de 3.12 à 3.15. Voici celles qui risquent le plus de toucher de vrais projets.

Modules et API supprimés

Supprimé en Quoi Remplacement
3.12 distutils setuptools, builds basés sur pyproject.toml
3.12 imp importlib
3.12 asynchat, asyncore asyncio
3.13 cgi, cgitb, crypt, telnetlib, pipes, nntplib, imghdr, sndhdr, uu, xdrlib, aifc, audioop, chunk, mailcap, msilib, nis, ossaudiodev, spwd, sunau (PEP 594) Packages tiers ou équivalents via email, subprocess, shlex
3.13 2to3 et lib2to3 Parseurs modernes comme LibCST ou Parso
3.14 ast.Num, ast.Str, ast.Bytes, ast.NameConstant, ast.Ellipsis ast.Constant
3.14 pkgutil.find_loader(), pkgutil.get_loader() importlib.util.find_spec()
3.15 sre_compile, sre_constants, sre_parse re
3.15 Loader.load_module() d’importlib exec_module()
3.15 http.server.CGIHTTPRequestHandler Un vrai serveur d’applications
3.15 PurePath.is_reserved(), platform.java_ver(), types.CodeType.co_lnotab Voir le What’s New de 3.15

Changements de comportement qui cassent sans erreur d’import

  • Encodage UTF-8 par défaut (3.15). Voir plus haut. C’est le plus fréquent.
  • asyncio.get_event_loop() (3.14) lève une RuntimeError en l’absence de boucle d’événements courante. Utilisez asyncio.run() ou asyncio.Runner.
  • Méthode de démarrage de multiprocessing (3.14) : c’est forkserver sous Linux. Passez get_context("fork") explicitement si vous avez vraiment besoin de fork.
  • Séquences d’échappement invalides (3.12) comme "\d" : elles émettent une SyntaxWarning au lieu d’une DeprecationWarning, donc des avertissements apparaissent dans du code qui était silencieux. Utilisez des chaînes brutes : r"\d".
  • Annotations (3.14) : elles sont évaluées de façon différée. Les bibliothèques qui inspectent __annotations__ à la création des classes peuvent se comporter différemment.
  • sqlite3.connect() (3.15) : tous les paramètres sauf database sont désormais keyword-only. sqlite3.connect("db", 5.0) lève une TypeError ; écrivez timeout=5.0.
  • argparse (3.15) : avec add_argument("-f", "-foo"), dest vaut désormais "foo" au lieu de "f".
  • base64.urlsafe_b64decode() (3.15) n’exige plus le padding. Passez padded=True si votre validation reposait sur l’erreur.
  • assertWarns*() de unittest (3.15) n’avale plus les avertissements sans rapport, donc des avertissements auparavant masqués peuvent apparaître pendant les tests.
  • datetime.strptime() (3.15) avec %d mais sans année lève désormais une ValueError.
  • Typage (3.15) : NamedTuple("P", x=int) et un TypedDict("TD") sans champ ne sont plus supportés.

Dépréciations à traiter dès maintenant

  • Module profile : suppression en 3.17. Utilisez profiling.tracing ou cProfile.
  • Système de policies d’asyncio (set_event_loop_policy() et API associées) : suppression en 3.16. Utilisez asyncio.run(..., loop_factory=...) ou asyncio.Runner.
  • typing.ByteString et collections.abc.ByteString : suppression en 3.17. Utilisez collections.abc.Buffer.
  • Lignes import dans les fichiers .pth : dépréciées par la PEP 829. Elles sont ignorées quand un fichier .start correspondant existe.

Checklist de compatibilité

Avant de migrer :

  • Dépendances : chaque package épinglé a une version qui supporte 3.15. Vérifiez les classifiers PyPI, les changelogs et les fichiers publiés pour chaque version, pas seulement que « ça s’installe ».
  • Packages compilés/natifs : des wheels cp315 existent pour chaque OS et chaque CPU sur lesquels vous déployez. Sans elles, pip se rabat sur une compilation depuis les sources, qui échoue ou se comporte différemment en CI.
  • Tests : la suite complète passe en 3.15 avec les avertissements visibles (-W default ou -X dev).
  • Encodage : les tests passent sous 3.11 avec -X utf8, et -X warn_default_encoding ne signale aucun argument encoding= manquant.
  • Modules supprimés : cherchez avec grep distutils, imp, cgi, telnetlib, pipes, lib2to3, ast.Num, sre_ et pkgutil.find_loader.
  • Images CI : l’image de runner ou l’action de setup de votre CI propose 3.15.
  • Images Docker de base : le tag 3.15 exact que vous comptez utiliser existe pour votre distribution (slim, Alpine, distroless).
  • Linters, formateurs et type checkers : votre version de Ruff, Black, mypy ou pyright sait parser lazy import et comprend les nouveautés de typage. Un outil qui ne sait pas parser la syntaxe échouera sur tout fichier qui l’utilise.
  • pandas, PySpark et bibliothèques data : chacune supporte officiellement 3.15 dans la version que vous épinglez (voir la section suivante).
  • Runtimes cloud : votre plateforme serverless ou managée propose un runtime 3.15. Ne le supposez pas.
  • Agents d’observabilité : les agents d’APM, de tracing et de profilage qui s’accrochent à l’interpréteur supportent 3.15.

Python 3.15 pour les data engineers

La distinction essentielle

Une nouvelle version de CPython ne signifie pas que votre plateforme data l’exécute. Les runtimes Spark managés, les services de notebooks, Microsoft Fabric, Databricks, les fonctions cloud et les services d’orchestration décident chacun de la version de Python qu’ils proposent, et ils sont généralement en retard sur les nouvelles versions de CPython. Tant que la documentation du runtime de votre plateforme ne mentionne pas Python 3.15, aucune des nouveautés 3.15 de cet article n’est disponible pour vos notebooks ou vos jobs sur cette plateforme.

Avec PySpark, il y a une contrainte supplémentaire : le driver et les workers doivent exécuter la même version mineure de Python. Vous ne pouvez pas faire tourner 3.15 sur le driver si les workers du cluster utilisent une version plus ancienne.

Ce qui aide là où vous maîtrisez le runtime

  • Scripts ETL et CLI : lazy import peut réduire sensiblement le temps de démarrage des outils qui importent pandas, PyArrow, des SDK cloud et des drivers de bases de données sur des chemins que la plupart des exécutions n’empruntent pas. C’est important pour les jobs courts et fréquemment planifiés.
  • Orchestration : les ordonnanceurs qui parsent régulièrement les fichiers de définition de pipelines paient le coût des imports à chaque fois. Les imports lazy dans ces modules de définition sont un choix naturel, une fois que votre orchestrateur supporte 3.15.
  • Gestion des fichiers : l’UTF-8 par défaut élimine toute une catégorie de bugs CSV du type « ça marche sous Linux, ça casse sous Windows » avec les modules standard open() et csv. read_csv de pandas utilisait déjà l’UTF-8 par défaut, son comportement ne change donc pas. Les fichiers historiques exportés en cp1252 ou latin-1 exigent désormais un encoding= explicite.
  • Configuration : frozendict convient bien à une configuration de job partagée entre threads ou utilisée comme clé de cache.
  • Diagnostic : le mode attach de Tachyon permet de profiler un worker Python lent et de longue durée sans le redémarrer. Gardez en tête qu’avec PySpark, l’essentiel du travail s’exécute dans la JVM et le profileur ne voit que la partie Python.
  • Free-threading : il peut rendre les threads utiles pour des transformations CPU-bound en Python pur, mais seulement quand toute votre pile native (NumPy, pandas, PyArrow, drivers) supporte le build free-threaded. Testez-le comme un projet à part, pas dans le cadre de la migration.

pandas, notebooks et bibliothèques partagées

  • Vérifiez les versions de Python supportées dans les notes de version des versions exactes de pandas, NumPy et PyArrow que vous épinglez. Ne supposez pas que « le dernier pandas » supporte une version de Python sortie la semaine dernière.
  • Les kernels de notebooks suivent l’environnement dans lequel ils tournent. Un kernel 3.15 a besoin de son propre environnement avec des packages compatibles 3.15.
  • Les bibliothèques internes partagées entre notebooks managés et jobs auto-hébergés doivent continuer à supporter la version de Python la plus ancienne de vos plateformes. Utilisez __lazy_modules__ plutôt que le mot-clé lazy, et évitez les built-ins propres à 3.15 dans le code partagé tant que toutes les plateformes ne proposent pas 3.15.

Pour de la pratique data, consultez la lecture de fichiers CSV avec pandas, l’inspection d’un DataFrame, le filtrage de lignes avec pandas et l’accélération des notebooks Fabric.

Faut-il migrer de Python 3.11 vers 3.15 ?

Migrez maintenant si… Testez d’abord si… Attendez si…
Vous maîtrisez le runtime (conteneur, VM, CLI) Vous utilisez beaucoup d’extensions compilées ou de packages natifs de niche Votre plateforme managée (Spark, notebooks, serverless) ne propose pas 3.15
Vos dépendances clés publient déjà des wheels 3.15 Vous tournez sous Windows et lisez ou écrivez des fichiers sans encoding= Une dépendance critique n’a pas annoncé le support de 3.15
Le temps de démarrage compte et les imports lazy aideraient Vous comptez sur multiprocessing avec la sémantique de fork sous Linux Vos linters, type checkers ou agents APM ne gèrent pas encore 3.15
Vous démarrez un nouveau service Votre code ou vos bibliothèques lisent __annotations__ directement Vous êtes en pleine release sur un système régulé ou gelé
Vous voulez une version supportée jusqu’en 2031 Vous voulez évaluer le JIT ou le free-threading

Si vous ne pouvez pas passer directement à 3.15, migrer de 3.11 vers 3.14 est une étape intermédiaire raisonnable. Vous obtenez l’essentiel des améliorations cumulées, avec un écosystème plus largement compatible aujourd’hui et un support jusqu’en 2030.

Plan de migration

  1. Créez un environnement 3.15 à côté de l’existant : py install 3.15 sous Windows, le package de votre distribution ou l’installeur officiel ailleurs, puis python3.15 -m venv .venv315.
  2. Installez les dépendances depuis votre lock file. Tout package qui tente une compilation depuis les sources vous indique une wheel manquante.
  3. Exécutez toute la suite de tests avec les avertissements visibles : python -X dev -m pytest.
  4. Lancez linters et type checkers dans des versions qui supportent 3.15.
  5. Examinez avertissements et dépréciations. Corrigez dès maintenant tout ce dont la suppression est prévue en 3.16 ou 3.17, tant que ce n’est qu’un avertissement.
  6. Mesurez les charges critiques. Mesurez séparément le temps de démarrage et le débit en régime établi, sous 3.11 et 3.15, avec et sans PYTHON_JIT=1 si le JIT vous intéresse.
  7. Déployez progressivement : d’abord la matrice CI, puis la préproduction, puis une instance canari. Comparez taux d’erreur, CPU, mémoire et latence avant d’étendre à toutes les instances.

Conclusion

Python 3.15 n’est pas un changement spectaculaire unique. C’est le moment où quatre ans de travail sur CPython deviennent réellement exploitables : un runtime mûr, un build free-threaded optionnel, un JIT qui commence à porter ses fruits, un profilage bien meilleur et des ajouts pratiques au langage comme lazy import, frozendict et sentinel.

Pour une équipe sous 3.11, la décision dépend surtout des dépendances et des plateformes, pas de Python lui-même. Si vous maîtrisez votre runtime et que vos dépendances supportent 3.15, commencez les tests dès maintenant, en commençant par le changement d’encodage UTF-8. Si une plateforme managée décide de votre version de Python, planifiez la migration pour le moment où elle proposera 3.15, et gardez le code partagé compatible avec l’ancienne version d’ici là.

Dans tous les cas, 3.11 arrive en fin de vie en octobre 2027. La migration aura lieu de toute façon, et elle est plus facile à faire à votre propre rythme.

Sources officielles

Étiquettes

  • Python
  • Performance
  • Concurrence
  • Observabilité