Dernières fonctionnalités de Python

Cet article explique les dernières fonctionnalités de Python.

Nous expliquerons les fonctionnalités remarquables des versions Python 3.12 à 3.13 étape par étape, dans une optique pratique d'applications 'immédiatement utilisables'.

YouTube Video

Dernières fonctionnalités de Python

Ces dernières années, Python a évolué en mettant l'accent non seulement sur la 'facilité d'écriture', mais aussi sur la 'robustesse, la vitesse et la lisibilité'. Ci-dessous, nous présentons les fonctionnalités notables des générations Python 3.12 à 3.13.

Améliorations spectaculaires des messages d'erreur (Python 3.12)

Dans Python 3.12, les erreurs sont désormais affichées de manière plus concrète et visuelle. Vous pouvez identifier instantanément où se trouvent les erreurs et réduire considérablement le temps de débogage.

1def calc_total(price, tax):
2    return price + price * tax
3
4result = calc_total(100, )

• Les arguments manquants sont indiqués avec la ligne et l'emplacement concernés, ce qui évite toute confusion lors de l'identification de la cause.

Utilisation pratique de l’instruction 'match' (correspondance de motifs structurelle)

L’instruction 'match' permet de décrire de manière déclarative des branchements conditionnels complexes et la distinction de structures de données. La gestion des dictionnaires et des structures imbriquées devient particulièrement plus lisible.

1user = {"status": "active", "name": "Alice"}
2
3match user:
4    case {"status": "active", "name": name}:
5        print(f"Welcome back, {name}!")
6    case {"status": "inactive"}:
7        print("Please activate your account.")
8    case _:
9        print("Unknown user status.")

• Puisque vous pouvez réaliser des branchements conditionnels et extraire des données simultanément, l’imbrication de conditions 'if' devient inutile.

Correspondance de motifs intuitive pour la gestion des données imbriquées

L’instruction 'match' est également efficace pour les données structurées telles que les fichiers JSON ou les réponses d’API.

1data = {"user": {"name": "Bob", "age": 25}}
2
3match data:
4    case {"user": {"name": name, "age": age}}:
5        print(f"{name} is {age} years old.")

• Vous pouvez extraire uniquement les éléments nécessaires en toute sécurité, ce qui réduit le besoin en code défensif.

Sortie de débogage f-string améliorée (notation =` / Python 3.8 et ultérieures, convivialité accrue)

Avec les f-strings, vous pouvez maintenant ajouter = pour afficher à la fois l'expression elle-même et son résultat d'évaluation. Cette fonctionnalité est spécialisée pour le débogage et se révèle extrêmement pratique pour vérifier rapidement le contenu d’une variable.

1x = 10
2y = 20
3print(f"{x=}, {y=}, {x+y=}")

• Comme les noms de variables et leurs valeurs sont affichés ensemble, le débogage temporaire avec des instructions print() devient plus lisible.
• Vous pouvez écrire des sorties de logs et du code de vérification de manière plus concise et expressive.

Annotations de type simplifiées et alias 'type' (Python 3.12 : nouvelle syntaxe d’alias de type)

Dans Python 3.12, une syntaxe dédiée pour définir des alias de type — l’instruction type — a été introduite. Cela permet aux annotations de type de servir non seulement d’information supplémentaire, mais aussi d’élément du langage pour exprimer clairement l’intention de conception.

1type UserId = int
2type UserName = str
3
4def greet(user_id: UserId, name: UserName) -> str:
5    return f"Hello, {name} (id={user_id})"

• En donnant un sens à UserId ou UserName, les différences de rôle peuvent être clarifiées même si les deux utilisent le même type int ou str.
• Les définitions de type deviennent plus concises, ce qui réduit le coût de compréhension lors des revues de code et de la maintenance.
• Auparavant, les alias de type tels que UserId = int étaient créés par affectation, mais l’utilisation de l’instruction type rend explicite que 'c’est une définition de type'. C'est particulièrement efficace pour améliorer la lisibilité du design dans des bases de code de taille moyenne ou plus importantes.

Annotations de type naturelles avec les types intégrés (génériques simplifiés à partir de Python 3.9+)

Depuis Python 3.9, vous pouvez utiliser directement les types intégrés comme list ou dict en tant que génériques.

Cela permet d'écrire des annotations de type intuitives et lisibles sans importer de types du module typing.

1def sum_numbers(numbers: list[int]) -> int:
2    return sum(numbers)
3
4print(sum_numbers([1, 2, 3, 4]))

• Les annotations de type ne servent pas de 'contraintes', mais de 'documentation qui explique le contenu du traitement'.

Chaînage de méthodes sécurisé avec le type Self (Python 3.11 et ultérieurs)

Depuis Python 3.11, il est possible de spécifier Self comme type de retour pour les méthodes qui renvoient la classe elle-même.

Cela permet d’écrire du code de chaînage de méthodes en toute sécurité, sans perdre l’information de type.

 1from typing import Self
 2
 3class Counter:
 4    def __init__(self, value: int = 0) -> None:
 5        self.value = value
 6
 7    def increment(self) -> Self:
 8        self.value += 1
 9        return self
10
11counter = Counter()
12counter.increment().increment()
13print(counter.value)

• Même pour les méthodes qui renvoient self, le bon type de retour est conservé.
• Les IDE et les vérificateurs de type peuvent comprendre précisément le chaînage de méthodes.

Manipulation de chaînes plus claire (removeprefix / removesuffix | Python 3.9 et ultérieures)

À partir de Python 3.9, les méthodes spécialisées str.removeprefix() et str.removesuffix() ont été ajoutées pour supprimer en toute sécurité les préfixes et suffixes des chaînes. Grâce à cela, vous pouvez exprimer précisément dans votre code l’intention de 'supprimer uniquement le début ou la fin'.

1filename = "report_2026.txt"
2
3clean_name = filename.removeprefix("report_")
4name_without_ext = clean_name.removesuffix(".txt")
5
6print(name_without_ext)

• La chaîne spécifiée est supprimée uniquement si elle se trouve au début ou à la fin, évitant ainsi des remplacements non désirés.
• Cette approche offre une meilleure lisibilité et sécurité que l’utilisation de replace() ou des découpages (slicing).
• En particulier pour le traitement des 'chaînes à format défini', comme les noms de fichiers ou le pré-traitement d’URL, ces méthodes peuvent réduire considérablement le risque de bugs.

Comparaison de chaînes robuste pour l’internationalisation (str.casefold() | Support Unicode)

str.casefold() en Python est une méthode de comparaison insensible à la casse prenant en compte l’Unicode. Contrairement à un simple lower() ou upper(), elle normalise les chaînes, y compris la conversion de caractères spécifique à la langue.

1text1 = "Stra\u00dfe"
2text2 = "strasse"
3
4print(text1)
5print(text2)
6
7print(f"Comparison Result: {text1.casefold() == text2.casefold()}")

• Elle gère correctement les différences dépendant de la langue, comme le ß et ss en allemand.
• C’est une technique essentielle pour les applications axées sur le multilinguisme ou l’internationalisation.

Prise en charge TOML standard (tomllib | Python 3.11 et ultérieures)

À partir de Python 3.11, le module tomllib pour lire les fichiers de configuration TOML a été ajouté à la bibliothèque standard. La gestion de la configuration peut désormais être entièrement réalisée en Python, sans dépendre de bibliothèques externes.

 1import tomllib
 2
 3with open("config.toml", "rb") as f:
 4    config = tomllib.load(f)
 5
 6print(config["database"]["host"])
 7
 8# config.toml
 9# title = "TOML Example"
10# [database]
11# host = "192.168.1.1"
12# ports = [ 8001, 8001, 8002 ]

• Les paquets externes comme toml ne sont plus nécessaires, ce qui simplifie vos dépendances.
• Le chargement des fichiers de configuration est standardisé, ce qui facilite la distribution, l’exploitation et la gestion des environnements d’intégration continue (CI).

Gestion des exceptions à l’ère du traitement parallèle (ExceptionGroup / except* | Python 3.11 et ultérieures)

Python 3.11 a introduit ExceptionGroup pour gérer plusieurs exceptions ensemble ainsi que la syntaxe except* pour les traiter de manière sécurisée dans des branches distinctes. Il s'agit d'une nouvelle fonctionnalité pour gérer les 'erreurs simultanées' apparaissant lors de traitements asynchrones ou parallèles.

 1def process(values):
 2    errors = []
 3    for v in values:
 4        if v < 0:
 5            errors.append(ValueError(f"Negative value: {v}"))
 6    if errors:
 7        raise ExceptionGroup("Invalid values", errors)
 8
 9try:
10    process([1, -2, -3])
11except* ValueError as e:
12    print("Handled:", e)

• Plusieurs exceptions peuvent désormais être levées et classées lors d’une seule opération.
• Cela répond au problème, dans les traitements asynchrones, où seule la première erreur était visible.
• Dans des opérations comme asyncio.gather() ou un traitement par lots parallèle, plusieurs causes d’échec peuvent survenir simultanément. L’utilisation de ExceptionGroup facilite l’organisation de la collecte des erreurs, de la journalisation (logging) et des stratégies de nouvelle tentative.

Les performances s'améliorent simplement en mettant à jour vers la dernière version

À partir de Python 3.11, de nombreux traitements ont été accélérés grâce à des optimisations internes.

1def count_up(n):
2    total = 0
3    for i in range(n):
4        total += i
5    return total
6
7print(count_up(1_000_000))

• Un avantage majeur est que des gains de vitesse sont obtenus sans avoir à réécrire votre code.

Contrôle du ramassage des ordures (gestion explicite via le module gc)

En Python, l’utilisation du module standard gc permet de désactiver temporairement ou d’exécuter manuellement la collecte des ordures. C’est une technique d’optimisation efficace dans des scénarios tels que le traitement par lots de grands ensembles de données ou les opérations critiques en termes de performance.

1import gc
2
3gc.disable()
4# heavy batch processing
5gc.enable()
6gc.collect()

• Supprimer des déclenchements inutiles de collecte des ordures permet de réduire les fluctuations du temps de traitement.
• Il est possible d’exécuter explicitement la collecte à des intervalles définis, ce qui facilite le suivi de l’utilisation de la mémoire.
• Cependant, cette technique ne doit pas être utilisée comme optimisation par défaut, mais seulement envisagée si le profilage révèle que la GC est un goulot d’étranglement. Pour la plupart des applications, il est plus sûr de s’appuyer sur la collecte automatique des ordures de Python.

Résumé

Avec l’amélioration des messages d’erreur et l’évolution des annotations de type dans les générations Python 3.12 à 3.13, comprendre et maintenir le code est devenu plus facile que jamais. De plus, des améliorations telles que de meilleures expériences de débogage et des gains de performance issus d’optimisations internes contribuent concrètement à la productivité sur le terrain. Il n’est pas nécessaire d’utiliser toutes ces fonctionnalités d’un coup ; il est pratique de commencer avec la dernière version de Python puis d’incorporer graduellement les fonctionnalités selon les besoins. Cette adoption progressive conduit à un code Python plus lisible et plus robuste.

Vous pouvez suivre l'article ci-dessus avec Visual Studio Code sur notre chaîne YouTube. Veuillez également consulter la chaîne YouTube.

YouTube Video