Qu'y a-t-il dans Python 3.13 ?

La semaine dernière, j'ai parlé du GIL en Python.

Pour résumer, le GIL (Global Interpreter Locker) empêche un processus d'exécuter plus d'UN thread à la fois, comme illustré ci-dessous :

En d'autres termes, alors qu'un processus peut avoir plusieurs threads, UN SEUL thread peut s'exécuter à un moment donné.

Python 3.13 nous permet de désactiver le GIL, ce qui signifie qu'un processus peut utiliser pleinement tous les cœurs du processeur (CPU).

En plus de cela, il y a plusieurs autres mises à jour que je veux partager aujourd'hui.

C’est parti !

Sommaire

• Amélioration de l'interprète interactif

• Annotations de type

  • 1) ReadOnly

  • 2) Annotation pour marquer les dépréciations

• Désactiver le GIL

• JIT

Amélioration de l'interprète interactif

Pour commencer, considérons que nous avons un code multiligne dans l'interpréteur :

Supposons que l’on souhaite à la place définir x = i**2.
Avant Python 3.13, il fallait revoir tout le code ligne par ligne :

Mais Python 3.13 prend en charge l'édition multiligne - pour cela appuis une fois sur la touche fléchée vers le haut et tu récupères l'intégralité du code :

Une chose que tu as peut-être remarquée est la différence de couleur avec “>>>” et “...”

Cette différence de couleur est également visible dans les messages d'erreur :

Tout comme le shell dispose de la commande clear, Python 3.13 en dispose également :

La prochaine mise à jour du REPL est également intéressante (et c'est quelque chose qui m'a toujours semblé manquer).

Remarque également que le fait d'appuyer sur ‘Entrée’ après avoir écrit une définition de fonction ou tout autre bloc d'indentation n'entraîne pas l'auto-indentation de la ligne suivante :

Python 3.13 le fait automatiquement :

Enfin, le REPL prend désormais en charge les commandes quit et help. Auparavant, il fallait les invoquer en tant que fonctions - quit() et help().

Annotations de type

Bien que Python n'impose jamais les annotations de type, elles sont extrêmement utiles pour améliorer la qualité et la maintenabilité du code et pour indiquer aux autres utilisateurs les types de données attendus.

Voici quelques ajouts que j'ai trouvés très utiles :

1) ReadOnly

Pour définir les attributs d'un TypedDict en lecture seule, tu peux utiliser le type ReadOnly.
La démonstration est faite ci-dessous :

• student_id est en lecture seule. Par conséquent, sa mise à jour déclenche le vérificateur de type statique (bien que le code ne soulève aucune erreur lors de son exécution).

Note que ReadOnly n'est supporté qu'à l'intérieur d'un TypedDict.

2) Annotation pour marquer les dépréciations

Si une partie de ton code (fonctions, etc.) est dépréciée, il est conseillé de la marquer comme dépréciée.

Python 3.13 fournit un décorateur @warnings.deprecated pour marquer les objets comme obsolètes avec un message :

Cela dit, si tu ne connais pas encore les annotations de type (type hints), nous les avons déjà abordés dans ce post :

Désactiver le GIL

Comme nous l'avons vu précédemment et dans la suite de ce post, Python 3.13 nous permet de désactiver le GIL.

Je vais te montrer l'amélioration des performances à l'aide d'une simple démonstration.

• Tout d'abord, nous commençons par quelques importations et définissons une longue fonction :

• Ensuite, nous avons un code single-threaded et un code multi-threaded :

Maintenant, si nous l'exécutons avec Python 3.13, nous obtenons :

La durée d'exécution est le même car le GIL est toujours activé ici.

Le problème c’est que dans Python 3.13, un nouvel exécutable appelé python3.13t a été introduit dans le cadre du mode expérimental free-threaded. L'exécutable python3.13t est donc une version spéciale de Python qui s'exécute sans le GIL.

Nous devons donc utiliser Python 3.13t à la place :

Cette fois, nous avons obtenu des performances plus rapides.

JIT

L'interpréteur par défaut de Python - CPython est un interpréteur standard pour Python et offre peu d'optimisation intégrée.

Cela affecte profondément les performances d'exécution du programme, en particulier lorsqu'il s'agit de code Python natif.

Une solution consiste à utiliser un compilateur Just-In-Time (JIT), qui prend ton code Python existant et génère un code machine rapide (à l'exécution). Ainsi, après la compilation, ton code s'exécute à la vitesse du code machine natif.

Le compilateur JIT n'est pas une nouveauté, bien sûr. Il existe des outils externes, comme Numba, qui peuvent le faire :

Cependant, le JIT est désormais intégré à Python 3.13.

Cela dit, il s'agit encore d'une phase préliminaire et expérimentale, qui sera améliorée dans les prochaines versions.

Bien qu'il y ait beaucoup d'autres mises à niveau, je pense que celles couvertes ci-dessus figurent parmi les plus pertinentes !

👉 À toi de jouer : Ai-je oublié quelque chose d'important ?