
Python 3.10 nous a donné de meilleurs messages d'erreur à divers égards, mais Python 3.11 vise à les améliorer encore plus. Certaines des choses les plus importantes qui sont ajoutées aux messages d'erreur dans Python 3.11 sont :
Emplacements exacts des erreurs dans les retraçages
Jusqu'à présent, dans un traçage, la seule information que vous obteniez sur l'endroit où une exception a été déclenchée était la ligne. Le problème aurait pu être n'importe où sur la ligne, donc parfois cette information n'était pas suffisante.
Voici un exemple*:
Code Python : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | def get_margin(data): margin = data['profits']['monthly'] / 10 + data['profits']['yearly'] / 2 return margin data = { 'profits': { 'monthly': 0.82, 'yearly': None, }, 'losses': { 'monthly': 0.23, 'yearly': 1.38, }, } print(get_margin(data)) |
Ce code génère une erreur, car l'un de ces champs dans le dictionnaire est None. Voici ce que nous obtenons*:

Sur la version 3.11 cependant :

Pour pouvoir restituer ces informations, les données end_line et end_col ont été ajoutées aux objets de code Python. Vous pouvez également accéder à ces informations directement via la méthode obj.__code__.co_positions().
Les notes pour les exceptions
Pour rendre les traces encore plus riches en contexte, Python 3.11 vous permet d'ajouter des notes aux objets d'exception, qui sont stockées dans les exceptions et affichées lorsque l'exception est déclenchée.
Prenez ce code par exemple, où nous ajoutons des informations importantes sur une logique de conversion de données d'API*:
Code Python : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | def get_seconds(data): try: milliseconds = float(data['milliseconds']) except ValueError as exc: exc.add_note( "The time field should always be a number, this is a critial bug. " "Please report this to the backend team immediately." ) raise # re-raises the exception, instead of silencing it seconds = milliseconds / 1000 return seconds get_seconds({'milliseconds': 'foo'}) # 'foo' is not a number! |
Cette note ajoutée est imprimée juste en dessous du message d'exception*:

La bibliothèque standard a maintenant un support intégré pour lire les fichiers TOML, en utilisant le module tomllib*:
Code Python : | Sélectionner tout |
1 2 3 4 | import tomllib with open('.deepsource.toml', 'rb') as file: data = tomllib.load(file) |
tomllib est en fait basé sur une bibliothèque d'analyse TOML open source appelée tomli. Et actuellement, seule la lecture des fichiers TOML est prise en charge. Si vous devez plutôt écrire des données dans un fichier TOML, envisagez d'utiliser le package tomli-w.
Groupes de travail asynchrones
Lorsque vous faites de la programmation asynchrone, vous rencontrez souvent des situations où vous devez déclencher de nombreuses tâches à exécuter simultanément, puis prendre des mesures lorsqu'elles sont terminées. Par exemple, télécharger un tas d'images en parallèle, puis les regrouper dans un fichier zip à la fin.
Pour ce faire, vous devez collecter des tâches et les transmettre à asyncio.gather. Voici un exemple simple de tâches exécutées en parallèle avec la fonction de gather*:
Code Python : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 | import asyncio async def simulate_flight(city, departure_time, duration): await asyncio.sleep(departure_time) print(f"Flight for {city} departing at {departure_time}PM") await asyncio.sleep(duration) print(f"Flight for {city} arrived.") flight_schedule = { 'boston': [3, 2], 'detroit': [7, 4], 'new york': [1, 9], } async def main(): tasks = [] for city, (departure_time, duration) in flight_schedule.items(): tasks.append(simulate_flight(city, departure_time, duration)) await asyncio.gather(*tasks) print("Simulations done.") asyncio.run(main()) |
Mais devoir maintenir une liste des tâches soi-même pour pouvoir les attendre est un peu maladroit. Aussi, une nouvelle API est ajoutée à asyncio appelée Groupes de tâches*:
Code Python : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | import asyncio async def simulate_flight(city, departure_time, duration): await asyncio.sleep(departure_time) print(f"Flight for {city} departing at {departure_time}PM") await asyncio.sleep(duration) print(f"Flight for {city} arrived.") flight_schedule = { 'boston': [3, 2], 'detroit': [7, 4], 'new york': [1, 9], } async def main(): async with asyncio.TaskGroup() as tg: for city, (departure_time, duration) in flight_schedule.items(): tg.create_task(simulate_flight(city, departure_time, duration)) print("Simulations done.") asyncio.run(main()) |
Lorsque le gestionnaire de contexte asyncio.TaskGroup() se ferme, il s'assure que toutes les tâches créées à l'intérieur ont fini de s'exécuter.
Groupes d'exceptions
Une fonctionnalité similaire a également été ajoutée pour la gestion des exceptions dans les tâches asynchrones, appelées groupes d'exceptions.
Supposons que de nombreuses tâches asynchrones s'exécutent ensemble et que certaines d'entre elles génèrent des erreurs. Actuellement, le système de gestion des exceptions de Python ne fonctionne pas bien dans ce scénario.
Voici une courte démo de ce à quoi cela ressemble avec 3 tâches simultanées qui ont planté*:
Code Python : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 | import asyncio def bad_task(): raise ValueError("oops") async def main(): tasks = [] for _ in range(3): tasks.append(asyncio.create_task(bad_task())) await asyncio.gather(*tasks) asyncio.run(main()) |
Lorsque vous exécutez ce code*:

Mais en Python 3.11, le comportement est un peu meilleur*:
Code Python : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 | import asyncio async def bad_task(): raise ValueError("oops") async def main(): async with asyncio.TaskGroup() as tg: for _ in range(3): tg.create_task(bad_task()) asyncio.run(main()) |

La gestion des exceptions avec ces groupes d'exceptions est également intéressante, vous pouvez soit faire except ExceptionGroup pour intercepter toutes les exceptions en une seule fois :
Code Python : | Sélectionner tout |
1 2 3 4 | try: asyncio.run(main()) except ExceptionGroup as eg: print(f"Caught exceptions: {eg}") |

Code Python : | Sélectionner tout |
1 2 3 4 | try: asyncio.run(main()) except* ValueError as eg: print(f"Caught ValueErrors: {eg}") |

Le module typing a vu beaucoup de mises à jour intéressantes dans cette version. Voici quelques-uns des plus intéressantes :
Génériques variadiques
La prise en charge des génériques variadiques a été ajoutée au module typing dans Python 3.11.
Cela signifie que vous pouvez désormais définir des types génériques pouvant contenir un nombre arbitraire de types. Il est utile pour définir des méthodes génériques pour les données multidimensionnelles.
Par exemple:
Code Python : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 | from typing import Generic from typing_extensions import TypeVarTuple, Unpack Shape = TypeVarTuple('Shape') class Array(Generic[Unpack[Shape]]): ... # holds 1 dimensional data, like a regular list items: Array[int] = Array() # holds 3 dimensional data, for example, X axis, Y axis and value market_prices: Array[int, int, float] = Array() # This function takes in an `Array` of any shape, and returns the same shape def double(array: Array[Unpack[Shape]]) -> Array[Unpack[Shape]]: ... # This function takes an N+2 dimensional array and reduces it to an N dimensional one def get_values(array: Array[int, int, *Shape]) -> Array[*Shape]: ... # For example: vector_space: Array[int, int, complex] = Array() reveal_type(get_values(vector_space)) # revealed type is Array[complex] |
Les génériques variadiques peuvent être très utiles pour définir des fonctions qui mappent sur des données à N dimensions. Cette fonctionnalité peut être très utile pour la vérification de type des bases de code qui s'appuient sur des bibliothèques de science des données telles que numpy ou tensorflow.
L'équipe responsable du développement de Python explique que : « La nouvelle syntaxe Generic[*Shape] n'est prise en charge que dans Python 3.11. Pour utiliser cette fonctionnalité dans Python 3.10 et versions antérieures, vous pouvez utiliser la fonction intégrée typing.Unpack à la place de Generic[Unpack[Shape]] ».
singledispatch prend désormais en charge les unions
functools.singledispatch est un moyen pratique de surcharger les fonctions en Python, basé sur des indications de type. Cela fonctionne en définissant une fonction générique et en se servant de @singledispatch. Ensuite, vous pouvez définir des variantes spécialisées de cette fonction, en fonction du type des arguments de la fonction*:
Code Python : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | from functools import singledispatch @singledispatch def half(x): """Returns the half of a number""" return x / 2 @half.register def _(x: int): """For integers, return an integer""" return x // 2 @half.register def _(x: list): """For a list of items, get the first half of it.""" list_length = len(x) return x[: list_length // 2] # Outputs: print(half(3.6)) # 1.8 print(half(15)) # 7 print(half([1, 2, 3, 4])) # [1, 2] |
En...
La fin de cet article est réservée aux abonnés. Soutenez le Club Developpez.com en prenant un abonnement pour que nous puissions continuer à vous proposer des publications.