Quoi de neuf dans Python 3.11 et est-ce que cela vaut vraiment le coup ?

Python a remporté le prix TIOBE "Language of the Year" trois fois au cours des quatre dernières années. Le langage reste en tête de l’index TIOBE à la mi-2022.

Python domine l’index TIOBE de juin 2022.

Un score de 12,74 % pour Python signifie que le mot-clé « Python » apparaît dans environ 13 % de toutes les requêtes liées à la programmation sur les moteurs de recherche. Autrement dit, une question de programmation sur 7 ou 8 sur Internet concerne Python.

Aujourd’hui, Python est souvent associé aux avancées majeures en data science et en IA. Les praticiens apprécient sa simplicité, son vaste écosystème de bibliothèques natives et tierces couvrant une multitude de tâches, ainsi que sa communauté.

Avec la sortie de la version stable finale 3.11 prévue le 3 octobre 2022, la communauté Python peut s’attendre à plusieurs améliorations bienvenues, dont une hausse significative des performances, une meilleure gestion des erreurs et du débogage, et de nombreux perfectionnements pratiques des bibliothèques standard.

Quelles sont les nouveautés de Python 3.11 ?

Le changelog de Python 3.11 regroupe une liste quasi interminable de corrections de bugs, d’améliorations et d’ajouts, dont une grande partie passera inaperçue. En revanche, quelques nouvelles fonctionnalités clés pourraient nettement améliorer votre flux de travail en Python dès la sortie de la version stable. Elles sont résumées ci-dessous.

1. Gain de vitesse

La première évolution majeure qui va enthousiasmer les data scientists est l’augmentation de la vitesse : la suite de tests de référence standard s’exécute environ 25 % plus rapidement que sous 3.10. La documentation Python indique que 3.11 peut être jusqu’à 60 % plus rapide dans certains cas. Voici comment exécuter vous-même le test de performance pour mesurer ces gains.

Pour comparer les vitesses de Python 3.10 et 3.11, vous aurez besoin d’une installation de Docker. Après avoir vérifié que Docker Desktop est lancé, exécutez ces deux commandes dans le terminal pour télécharger les images correspondant aux deux versions de Python.

$ docker run -d python:3.10.4-bullseye

$ docker run -d python:3.11-rc-bullseye

Les images téléchargées apparaissent dans votre tableau de bord Docker, où vous pouvez aussi les démarrer.

Après avoir lancé les conteneurs, exécutez docker ps pour voir des détails comme l’ID du conteneur, l’image, son statut, etc.

Les conteneurs actifs sont également visibles dans l’onglet Containers de votre tableau de bord, avec des boutons CLI à côté de "Run/Stop". Cliquez dessus pour les deux conteneurs afin d’ouvrir deux onglets de terminal attachés aux conteneurs.

Dans les deux onglets, installez le paquet pyperformance via pip. Ensuite, lancez les commandes ci-dessous dans chaque terminal de conteneur.

Pour Python 3.10

$ pyperformance run -r -o py310.json

Pour Python 3.11

$ pyperformance run -r -o py310.jsone run -r -o py311.json

Ces commandes vont exécuter des benchmarks pour une soixantaine de fonctions Python issues des bibliothèques standard et produire des métadonnées au format JSON. J’ai ajouté en option l’argument -r pour indiquer à pyperformance que je souhaite des tests rigoureux, ce qui prend plus de temps. Dans mon cas, les deux conteneurs tournent sur une machine Windows avec un CPU AMD Ryzen 12 cœurs.

Nous avons désormais deux fichiers JSON dans deux conteneurs et il faut les réunir dans un même répertoire pour poursuivre le test de vitesse. Pour cela, utilisez la commande docker cp afin de copier le fichier JSON du conteneur Python 3.11 vers celui de 3.10.

Exécutez les commandes ci-dessous dans un autre onglet de terminal, en adaptant les chemins aux vôtres :

$ docker cp crazy_snyder:/py311.json C:/Users/bex/Desktop

$ docker cp C:/Users/bex/Desktop/py311.json charming_proskuriakova:/

Dans mon exemple, crazy_snyder et charming_proskuriakova sont les IDs des conteneurs actifs. Les deux fichiers JSON sont maintenant dans le conteneur Python 3.10. Pour finaliser le benchmark et enregistrer les résultats en CSV, lancez les commandes ci-dessous.

$ pyperformance compare py310.json py311.json --csv comparison.csv

$ docker cp charming_proskuriakova:/comparison.csv C:/Users/bex/Desktop/articles

Enfin, chargeons le CSV dans Pandas pour l’analyser :

import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns

df = pd.read_csv("data/comparison.csv")
df.rename({"Base": "py310", "Changed": "py311", "Benchmark": "function"},
                   axis=1,
                   inplace=True)

>>> df.shape

(59, 3)

>>> df.sample(5)

Chaque ligne du dataframe indique le temps nécessaire (en millisecondes) aux deux versions pour exécuter la fonction Python considérée. Traçons un histogramme des accélérations.

df["speed_up"] = (df["py310"] / df["py311"]).round(3)

fig, ax = plt.subplots()

sns.histplot(df["speed_up"], bins=11)
ax.set(xlabel="Speedup (times)", 
           title="Python 3.10 vs. Python 3.11 - speedup comparison")

plt.show()

Le graphique montre clairement que la majorité des fonctions dans Python 3.11 sont environ 1,2 fois (20 %) plus rapides. On peut confirmer cette estimation avec la moyenne et la médiane.

>>> df["speed_up"].mean()

1.2605593220338982

>>> df["speed_up"].median()

1.207

On observe même un cas où l’augmentation d’exécution dépasse 60 %.

>>> df["speed_up"].max()

1.899

Il existe aussi quatre cas où Python 3.10 est plus rapide que la nouvelle version.

>>>  (df["speed_up"] <= 1).sum() 

4

Si les gains sont manifestes sur le papier, leur impact concret variera selon les usages, et la version stable finale de Python 3.11 n’est pas encore sortie. Le benchmark s’appuie sur des fonctions Python pures, que vous n’utilisez peut-être pas tant que cela au quotidien. Installer Docker pour Python 3.10 et 3.11 vous permettra toutefois d’estimer les gains pour vos cas d’usage spécifiques.

2. De meilleurs messages d’erreur

Autre nouveauté intéressante : des messages d’erreur plus précis, qui pointent l’emplacement exact du problème. Plutôt que de renvoyer une traceback de 100 lignes se terminant par un message sibyllin, Python 3.11 indique l’expression précise qui a causé l’erreur.

Dans l’exemple ci-dessus, l’interpréteur met en évidence le x qui a fait planter le script à cause de sa valeur None. L’erreur aurait été ambiguë dans les versions actuelles de Python puisqu’il existe deux objets avec l’attribut « x ». La gestion des erreurs en 3.11 désigne clairement l’expression posant problème.

Cet exemple montre aussi comment 3.11 repère une erreur au sein d’un dictionnaire fortement imbriqué et peut indiquer clairement à quelle clé elle se rattache.

On retrouve la même précision dans des expressions arithmétiques complexes.

Ces messages d’erreur enrichis sont une excellente nouvelle, en particulier pour les data scientists qui peinent parfois à déboguer leurs scripts.

3. Notes d’exception

« L’explicite vaut mieux que l’implicite. »

Cette phrase est la deuxième ligne du Zen of Python, la liste des 20 principes de conception de Python. Elle rappelle que le code Python doit être aussi expressif que possible.

Pour renforcer ce principe, Python 3.11 introduit les notes d’exception (PEP 678). Désormais, dans vos clauses except, vous pouvez appeler la fonction add_note() et passer un message personnalisé lors du relèvement d’une erreur.

import math

try:
  math.sqrt(-1)
except ValueError as e:
  e.add_note("Negative value passed! Please try again.")
  raise

Si vous avez écrit une classe d’exception personnalisée comme ci-dessous, vous pouvez ajouter plusieurs notes à la classe dans l’attribut protégé de niveau classe __notes__ :

import math

class MyOwnError(Exception):
   # Doit être une liste de chaînes de caractères
   __notes__ = ["This is a custom error!"]

try:
   math.sqrt(-1)
except:
   raise MyOwnError

Désormais, quand l’interpréteur rencontre l’erreur, il affiche le message personnalisé après le corps du message standard.

Une nouvelle syntaxe permet aussi de lever des exceptions avec la clause except*, à utiliser avec la nouvelle classe ExceptionGroup. La PEP 654 indique que vous pouvez vous en servir pour lever simultanément plusieurs erreurs indépendantes dans divers scénarios. La plupart de ces cas sont assez spécifiques (web sockets, programmation concurrente avec asyncio, etc.), rarement rencontrés en data science au quotidien, mais si le sujet vous intéresse, vous pouvez en apprendre davantage sur la nouvelle syntaxe ici.

4. Nouvelle fonctionnalité de typage : Self

Les langages à typage statique améliorent la lisibilité et facilitent le débogage de votre code. Définir le type exact des variables, des entrées et des sorties de fonctions peut vous épargner des heures de débogage et rendre votre code plus clair pour les autres. Les annotations de type permettent aussi aux IDE modernes d’afficher les signatures au fil de la saisie, ce qui facilite l’interprétation de vos fonctions.

Jusqu’ici, le puissant module typing de Python proposait des classes pour quasiment tous les types de données, sauf pour les classes dont les méthodes retournent une instance d’elles-mêmes. Dans les versions actuelles de Python, l’exemple ci-dessous n’est pas possible :

from typing import Self
class Language:

  def __init__(self, name, version, release_date):
      self.name = name
      self.version = version
      self.release_date = release_date

  def change_version(self, version) -> Self:
      self.version = version

      return Language(self.name, self.version, self.release_date)

Avec Python 3.11, la classe Self fait son apparition : vous pouvez l’utiliser dans la définition d’une fonction si sa valeur de retour est self ou une nouvelle instance de la classe elle-même.

5. Améliorations des bibliothèques standard

D’autres améliorations pratiques concernent les bibliothèques standard. Tout d’abord, deux fonctions très attendues rejoignent le module math.

>>> import math
>>> math.cbrt(9)  # Racine cubique de x
2.080083823051904
>>> math.cbrt(27)
3.0000000000000004
>>> math.exp2(5)  # 2 puissance x
32.0

Qu’il ait fallu 28 ans à Python pour ajouter la racine cubique a de quoi surprendre, mais mieux vaut tard que jamais.

Le module fractions ajoute lui aussi une nouveauté permettant de créer des fractions à partir de chaînes de caractères :

>>> from fractions import Fraction
>>> Fraction("22/7")  # Nouveau dans Python 3.11
Fraction(22, 7)
>>> Fraction(numerator=22, denominator=7)
Fraction(22, 7)
>>> Fraction("3e-4")
Fraction(3, 10000)
>>> Fraction("-73/41")
Fraction(-73, 41)
>>> Fraction(3.1415)  # Fraction la plus proche du flottant donné
Fraction(7074029114692207, 2251799813685248)

Comme vous le voyez, le module fractions peut être très utile pour certains calculs. J’aime notamment la possibilité de trouver la fraction qui approche au mieux un flottant donné. Vous pouvez aller plus loin encore en imposant une limite au dénominateur :

>>> from math import pi
>>> Fraction(pi).limit_denominator(100000)
Fraction(312689, 99532)

Un nouveau module tomllib fait aussi son entrée pour analyser des documents TOML. TOML (Tom's Obvious Minimal Language) est un format prisé pour écrire des fichiers de configuration lisibles par l’humain. Voici une image issue de la page d’accueil du projet :

import tomllib

toml_str = """
python-version = "3.11.0"
release_date = "2022-10-22"
"""

data = tomllib.loads(toml_str)
print(data)  # {'python-version': '3.11.0', 'release_date': '2022-10-22'}
print(data['python-version'])  # 3.11.0
print(data['release_date'])  # 2022-10-22

Date de sortie de Python 3.11

Le développement de Python 3.11 a débuté le 5 mai 2021. Depuis, sept versions alpha sont sorties, la première version bêta ayant été publiée le 8 mai 2022. À partir de cette date et jusqu’à la sortie officielle, aucune nouvelle fonctionnalité ne sera ajoutée à Python.

La version finale et stable sortira le 3 octobre 2022, après trois autres bêtas et deux release candidates entre-temps. Pour aller plus loin avec Python, consultez les ressources ci-dessous.