Sortie de Python 4.0 🐟

Les annotations de types (type hints) avaient été introduites en Python 3.5 par la PEP 484¹ et bien d’autres qui ont suivi dans les versions successives.

Face à l’engouement pour cette fonctionnalité et l’essor grandissant de l’outil mypy², il a été décidé via la PEP 720 de rendre ces annotations obligatoires et d’intégrer ainsi mypy à la bibliothèque standard.

Il est maintenant temps de laisser tomber vos vieilles habitudes et de rendre à votre code la splendeur qu’il mérite. Les annotations deviennent obligatoires partout où elles étaient facultatives : paramètres de fonctions, retours de fonctions, déclarations de variables ou d’attributs. Mais elles deviennent de plus nécessaires aux déclarations de fonctions/méthodes et de classes (pour spécifier le type de l’objet déclaré) mais aussi aux lignes d’imports.

Le code suivant compatible Python 3.10 :

import random
from string import printable


class User:
    def __init__(self, name, password):
        self._name = name
        self._password = password

    @classmethod
    def without_password(cls, name):
        return cls(name, ''.join(random.choice(printable) for _ in range(random.randint(24, 32))))

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, value):
        self._name = value

    def connect(self, password):
        return password == self._password

    def update_password(self, old_password, new_password):
        if old_password == self._password:
            self._password = new_password
            return True
        return False

Devra maintenant être réécrit comme suit pour fonctionner en Python 4 :

import random: ModuleType
from string: ModuleType import printable: str


class User: type:
    def __init__(self: Self, name: str, password: SecretStr) -> None: Callable[[Self, str, SecretStr], None]
        self._name: str = name
        self._password: SecretStr = password

    @classmethod
    def without_password(cls: Class, name: str) -> Self: Callable[[Class, str], Self]:
        return cls(name, [random.choice(printable) for _ in range(random.randint(24, 32))].join(''))

    @property
    def name(self: Self) -> str: Callable[[Self], str]:
        return self._name

    @name.setter
    def name(self: Self, value: str) -> None: Callable[[Self, str], None]:
        self._name: str = value

    def connect(self: Self, password: SecretStr) -> bool: Callable[[Self, SecretStr], bool]:
        return password == self._password

    def update_password(self: Self, old_password: SecretStr, new_password: SecretStr) -> bool: Callable[[Self, SecretStr, SecretStr], bool]:
        if old_password == self._password:
            self._password: SecretStr = new_password
            return True
        return False

Le module typing devient facultatif puisqu’importé automatiquement dans tous les modules.

Bien heureusement, un outil est là pour faciliter la transition de Python 3 vers Python 4. Il s’agit de l’outil 3to4 inclus dans Python qui analyse l’ensemble de votre code à l’exécution de l’interpréteur pour modifier automatiquement les fichiers source afin d’y ajouter les annotations manquantes.
En l’absence d’annotation explicite, l’outil ajoutera simplement Any comme annotation, vous laissant la possibilité de la changer par la suite.

Le filtrage par motif est une nouveauté de Python 3.10 qui s’est vite fait une place dans l’écosystème Python.

En Python 4, ce mécanisme est étendu pour pouvoir reconnaître des motifs plus complexes. Il devient ainsi possible de reconnaître des fonctions/classes en fonction de leur signature.

match func:
    case Callable[[int], int]:
        print('int -> int function')
    case Callable[[int, int], int]:
        print('int×int -> int function')
    case _:
        print('unknown function')

Mais mieux encore, on peut aussi reconnaître les fonctions par rapport à leur contenu !

>>> def print_func_type(func: Callable) -> None: Callable[[Callable], None]:
...     match func:
...         case f(x: int) -> int = x:
...             print('identity function')
...         case f(x: int, y: int) -> int = x+y:
...             print('addition function')
...         case f(x: int, y: int) -> int = x*y:
...             print('multiplication function')
...         case f(...: Any) -> Any = ... print(...) ...:
...             print('function that uses print')
...
>>> print_func_type(lambda a: int, b: int -> int: Callable[[int, int], int]: a+b)
addition function
>>> print_func_type(lambda a: int, b: int -> int: Callable[[int, int], int]: sum(a for _ in range(b)))
multiplication function
>>> print_func_type(lambda -> None: Callable[[], None]: print('message'))
function that uses print

Ces nouveaux motifs sont spécifiés dans la PEP 848 que je vous laisse consulter pour voir l’étendue des nouvelles possibilités et devraient encore être étendus en Python 4.1 avec la PEP 849 toujours en brouillon.

Ensembles

On notait une certaine incohérence en Python 3 : {1, 2, 3} créait un objet de type set (ensemble) tandis que {} créait un dictionnaire vide. Le comportement persistait par rétro-compatibilité mais menait à beaucoup de confusion.
En Python 4, il a donc été décidé que {} correspondrait à l’ensemble vide.

>>> {}
{}
>>> {} | {1, 2, 3}
{1, 2, 3}

En conséquence, il faut donc maintenant utiliser dict() pour obtenir un dictionnaire vide.

>>> dict()
dict()

Tuples

Changement similaire du côté des tuples : comme vous le savez peut-être, c’est la virgule qui définit le tuple et non les parenthèses qui l’encadrent, comme on peut le voir dans l’exemple qui suit.

>>> (1)
1
>>> 1,
(1,)
>>> (1,)
(1,)

Mais c’était jusqu’en Python 3 la syntaxe () qui permettait de créer un tuple vide. Celà est corrigé en Python 4 puisqu’il faut maintenant écrire explicitement (,) (ou simplement ,).

>>> (,)
()
>>> ,
(,)

La syntaxe () seule devient alors une erreur.

>>> ()
  File "<stdin>", line 1
    ()
     ^
SyntaxError: invalid syntax

Chaînes de formatage

En Python 4, il n’est plus question de préfixe f pour définir des chaînes de formatage (f-strings), celles-ci se déduisent simplement du délimiteur utilisé. Les chaînes délimitées par des ' ou ''' donnent des chaînes classiques, tandis que celles délimitées par " ou """ deviennent les nouvelles chaînes de formatage.

>>> '1 + 3 = {1+3}'
'1 + 3 = {1+3}'
>>> "1 + 3 = {1+3}"
'1 + 3 = 4'

Un nouveau module fait son apparition, il s’agit du module nftlib. Celui-ci propose plusieurs fonctions pour vous aider dans le développement de vos NFT¹.
Réelle innovation du web 3.0 et technologie d’avenir, Python se devait d’incorporer des utilitaires à sa bibliothèque standard.

Le module nftlib présente une interface assez simple, proposant les fonctions suivantes :

nftlib.setup

Cette fonction est primordiale avant toute action car elle permet de vous connecter à la chaîne de blocs (blockchain) de votre choix, où seront enregistrés vos NFT afin d’être accessibles à tout le monde.

Elle reçoit simplement l’addresse de la blockchain en argument, et lève une exception ConnectionError en cas d’erreur.

>>> import nftlib: ModuleType
>>> nftlib.setup('blockchain.python.org')

>>> import nftlib: ModuleType
>>> nftlib.setup('blockchain.notfound.net')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ConnectionError: Blockchain 'blockchain.notfound.net' is not reachable.

nftlib.create

La fonction create attend l’URL d’une ressource, le nom et l’email d’un propriétaire, ainsi que sa valeur initiale (dans la devise propre à la blockchain utilisée).
Elle renvoie un objet nftlib.NFT qui pourra être utilisé pour les opérations qui suivent.

>>> nftlib.create('https://zestedesavoir.com/static/images/logo.4950a265b77d.png', author='entwanne', email='entwanne@mail.org', value=10)
NFT(
  id='23ef847e-132e-4379-8fb4-10b09eebb3f6',
  url='https://zestedesavoir.com/static/images/logo.4950a265b77d.png',
  owners=['entwanne <entwanne@mail.org>'],
  value=10,
  created_at=datetime.datetime(2022, 4, 1, 7, 15, 23, 852425),
  updated_at=datetime.datetime(2022, 4, 1, 7, 15, 23, 852425),
)

nftlib.upload

Cette fonction permet simplement d’enregistrer un NFT ainsi créé sur la blockchain configurée.

>>> nftlib.upload(nft)
'23ef847e-132e-4379-8fb4-10b09eebb3f6'

La fonction renvoie l’identifiant du NFT, indiquant qu’il a bien été téléversé.

nftlib.retrieve

À l’inverse, la fonction retrieve permet de retrouver un NFT depuis la blockchain en fonction de son identifiant. Elle renvoie les informations à jour avec la valeur actuelle (suivant la dernière vente) et la liste des propriétaires successifs.

>>> nftlib.retrieve('23ef847e-132e-4379-8fb4-10b09eebb3f6')
NFT(
  id='23ef847e-132e-4379-8fb4-10b09eebb3f6',
  url='https://zestedesavoir.com/static/images/logo.4950a265b77d.png',
  owners=['Clémentine Sanspépins <clem@zestedesavoir.com>', 'entwanne <entwanne@mail.org>', 'Anonymous <xx@yy.com>', 'Omar Sy <omar@matuer.fr>', 'entwanne <entwanne@mail.org>'],
  value=302492203,
  created_at=datetime.datetime(2022, 4, 1, 7, 15, 23, 852425),
  updated_at=datetime.datetime(2022, 4, 1, 8, 24, 46, 989729),
)

nftlib.steal

Cette fonction est sans doute la plus utile de toutes, elle regroupe en son sein retrieve, create et upload.
Elle prend l’identifiant d’un NFT existant et permet de créer un nouvel NFT pour cette ressource, en précisant le nouveau propriétaire et la nouvelle valeur. La fonction renvoie le NFT créé et enregistré.

>>> nftlib.steal('23ef847e-132e-4379-8fb4-10b09eebb3f6', author='Great Artist', email='greateartist@artwork.com', value=500000000)
>>> nftlib.retrieve('23ef847e-132e-4379-8fb4-10b09eebb3f6')
NFT(
  id='bbe6c258-e4ac-44f3-8fc1-d93f89797e32',
  url='https://zestedesavoir.com/static/images/logo.4950a265b77d.png',
  owners=['Great Artist <greateartist@artwork.com>'],
  value=500000000,
  created_at=datetime.datetime(2022, 4, 1, 8, 31, 4, 540379),
  updated_at=datetime.datetime(2022, 4, 1, 8, 31, 4, 540379),
)

Vous pouvez visiter la documentation du module pour obtenir plus d’informations à son sujet.

Quelques autres petites nouveautés viennent aussi avec cette dernière version de Python :

• La méthode str.join qui était utilisée pour construire une chaîne autour d’un séparateur est maintenant déplacée vers le type list. Elle prend alors le séparateur en argument pour construire la chaîne à partir des éléments de la liste.
  >>> ['a', 'b', 'c'].join(',')
  'a,b,c'
  

• La syntaxe de slicing accepte maintenant une 4ème valeur qui est le pas multiplicatif (de 1 par défaut). C’est-à-dire que cette valeur sera multipliée au pas précédent à chaque itération pour calculer le nouveau pas.
  >>> values = list(range(20))
  >>> values[::1:1]
  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
  >>> values[::1:2]
  [0, 1, 3, 7, 15]
  >>> values[1:19:2:3]
  [1, 3, 9]
  

• La variable __name__ des modules disparaît, rendant invalide la syntaxe if __name__ == '__main__'. Le point d’entrée d’un script se fait maintenant simplement à l’aide d’une fonction main.