Quoi de neuf à partir d'avril 2021? – Vrai Python

By | mai 3, 2021

Formation Python

Si vous traînez assez longtemps avec les développeurs Python, vous finirez par entendre quelqu'un parler de la formidable communauté Python. Si vous voulez être au courant de ce qui s'est passé dans le Communauté Python dans Avril 2021, alors vous êtes au bon endroit pour obtenir votre nouvelles!

Des meilleurs messages d'erreur qui améliorent l'expérience utilisateur aux efforts de la communauté pour retarder un changement de CPython, avril 2021 a été un mois plein d'histoires qui nous ont rappelé que Python est meilleur grâce à sa communauté.

Python 3.10 aura des messages d'erreur améliorés

Le 9 avril 2021, le développeur principal de Python Pablo Galindo, qui est également le gestionnaire de publication de Python 3.10 et 3.11, a tweeté une question adressée aux enseignants Python:

Enseignants et utilisateurs Python: J'ai récemment travaillé sur l'amélioration des messages SyntaxError dans CPython. Quelle erreur (seulement SyntaxeErreurs pour l'instant 😅) les messages avec lesquels vous ou vos élèves avez du mal? Lesquels pensez-vous que nous devrions améliorer? 🤔 (Pls RT pour aider à atteindre plus de personnes 🙏). (La source)

Le tweet a suscité beaucoup d'engagement, y compris des demandes d'amélioration des messages d'erreur concernant la mission (=) et comparaison (==), des erreurs d'indentation et des deux-points manquants. Dans certains cas, Galindo a souligné qu'il avait déjà amélioré les erreurs que les gens ont mentionnées!

Par exemple, dans une requête d'extraction intitulée bpo-42997: Améliorer le message d'erreur pour les manquants: avant les suites, Galindo a amélioré les messages d'erreur pour les deux-points manquants. Dans Python 3.10, si vous oubliez de taper deux points (:) après avoir défini une fonction, vous verrez ce nouveau message amélioré:

>>>

>>> # Python 3.10a7
>>> def F()
  Déposer "", ligne 1
    def F()
          ^
Erreur de syntaxe: attendu ':'

Comparez cela au message d'erreur de Python 3.9:

>>>

>>> # Python 3.9.4
>>> def F()
  Déposer "", ligne 1
    def F()
           ^
Erreur de syntaxe: Syntaxe invalide

C'est un petit changement, mais souligner que l'interpréteur s'attendait à un deux-points plutôt que de simplement dire à l'utilisateur que sa syntaxe est invalide est beaucoup plus utile et pas seulement pour les débutants. Les développeurs ayant de l'expérience dans d'autres langages mais qui sont nouveaux dans la syntaxe Python apprécieront également les messages plus conviviaux.

Des messages d'erreur améliorés pour les comparaisons non valides ont été introduits dans un PR intitulé bpo-43797: Améliorer l'erreur de syntaxe pour les comparaisons non valides. Dans Python 3.10, si vous tapez accidentellement un opérateur d'affectation au lieu de l'opérateur de comparaison dans un si déclaration, vous verrez ce message:

>>>

>>> # Python 3.10a7
>>> une = 1
>>> b = 2
>>> si une = b:
  Déposer "", ligne 1
    si une = b:
       ^^^^^
Erreur de syntaxe: Syntaxe invalide. Peut-être vouliez-vous dire «==» ou «: =» au lieu de «=»?

Il s'agit d'une amélioration significative par rapport au message existant dans Python 3.9:

>>>

>>> # Python 3.9.4
>>> une = 1
>>> b = 2
>>> si une = b:
  Déposer "", ligne 1
    si une = b:
         ^
Erreur de syntaxe: Syntaxe invalide

En plus de mieux Erreur de syntaxe messages, AttributeError, NameError, et IndentationError les messages ont également été améliorés.

Un exemple que Galindo a partagé dans un Tweet du 14 avril montre comment Python 3.10 suggérera des attributs existants si vous saisissez mal le nom d'un attribut:

>>>

>>> # Python 3.10a7
>>> importer collections
>>> collections.namedtoplo
Traceback (dernier appel le plus récent):
  Déposer "", ligne 1, dans 
AttributeError: le module 'collections' n'a pas d'attribut 'namedtoplo'. Vouliez-vous dire: 'namedtuple'?

Certains utilisateurs se sont inquiétés du coût de la recherche de noms existants. Voici la réponse de Galindo:

Cela ne se produit que lors de l'affichage d'exceptions non interceptées, donc cela se produit lorsque l'interpréteur va se terminer afin que cela n'affecte pas l'exécution. Il a également de nombreuses limites (comme la longueur des chaînes ou le nombre de candidats) pour maintenir le coût minimal, même dans ce cas. (La source)

Dans l'ensemble, il semble que les messages d'erreur améliorés constituent une grande amélioration de l'expérience utilisateur de Python. Pour une liste complète des améliorations apportées aux messages d'erreur, consultez la page Quoi de neuf en Python 3.10 dans la documentation Python.

PEP 563, PEP 649 et l'avenir des annotations de type Python

PEP 484 a introduit les indicateurs de type en 2014. Les indicateurs de type vous permettent de spécifier des types sur les paramètres de fonction, les attributs de classe et les variables, qui peuvent ensuite être vérifiés de manière statique à l'aide d'outils tels que Mypy.

Par exemple, le code suivant définit la fonction ajouter(), qui ajoute deux entiers, X et y:

def ajouter(X: int, y: int) -> int:
    revenir X + y

Les indices de type spécifient que les deux paramètres X et y devrait être de type int et que la fonction renvoie un int valeur.

Comment les indices de type sont actuellement évalués

Actuellement, les indicateurs de type doivent être des expressions Python valides car ils sont évalués à temps de définition de la fonction. Une fois les indices de type évalués, ils sont stockés sous forme de chaînes dans un objet .__ annotations__ attribut:

>>>

>>> def ajouter(X: int, y: int) -> int:
...     revenir X + y
...
>>> ajouter.__annotations__
'x': 'int', 'y': 'int', 'return': 'int'

Vous pouvez généralement récupérer les objets de type réels en utilisant get_type_hints () du dactylographie module:

>>>

>>> importer dactylographie
>>> dactylographie.get_type_hints(ajouter)
'X': , 'y': , 'revenir': 

get_type_hints () fournit un support de base pour les outils permettant d'implémenter la vérification de type à l'exécution. Python, en tant que langage typé dynamiquement, ne prendra probablement jamais en charge la véritable vérification de type à l'exécution sans outils tiers.

L'évaluation des indices de type au moment de la définition de la fonction présente certains inconvénients. Par exemple, le nom du type doit être défini. Sinon, Python lèvera un NameError:

>>>

>>> def ajouter(X: Nombre, y: Nombre) -> Nombre:
...     revenir X + y
...
Traceback (dernier appel le plus récent):
  Déposer "", ligne 1, dans 
NameError: le nom 'Number' n'est pas défini

Vous pouvez éviter cela en définissant un alias de type en utilisant quelque chose comme dactylographie Union créer un Nombre alias qui permet int et flotter valeurs:

>>>

>>> de dactylographie importer syndicat
>>> Nombre = syndicat[[[[int, flotter]
>>> def ajouter(X: Nombre, y: Nombre) -> Nombre:
...     revenir X + y
...
>>> # Aucune erreur de nom n'est générée!

Une situation où vous ne peut pas définir un alias de type avant de l'utiliser, cependant, se produit lorsque vous devez renvoyer une instance d'une classe à partir d'une méthode dans la classe elle-même:

classer Point:
    def __init__(soi, X: flotter, y: flotter) -> Rien:
        soi.X = X
        soi.y = y

    @classmethod
    def origine(cls) -> Point:  # Le type de point n'est toujours pas défini
        revenir cls(0, 0)

L’utilisation d’un nom avant sa définition est connue sous le nom de référence avant. Pour contourner cette situation, PEP 484 nécessite l'utilisation d'une chaîne littérale pour le nom de type:

classer Point:
    def __init__(soi, X: flotter, y: flotter) -> Rien:
        soi.X = X
        soi.y = y

    @classmethod
    def origine(cls) -> "Point":
        revenir cls(0, 0)

L'évaluation de la chaîne est retardée jusqu'à ce que le module soit complètement chargé.

Un autre inconvénient de l'évaluation des annotations de type au moment de la définition de la fonction est qu'elle ajoute une surcharge de calcul lors de l'importation de modules typés.

Ce que PEP 563 proposait pour améliorer les annotations de type

En septembre 2017, la PEP 563 a proposé de passer de l'évaluation des annotations au moment de la définition de la fonction à leur conservation sous forme de chaîne dans le __annotations__ dictionnaire. Cela résout efficacement le problème de référence directe et élimine la surcharge de calcul liée à l'importation de modules typés.

À partir de Python 3.7, vous pouvez accéder à ce nouveau comportement en important annotations de __futur__. Cela vous permet d'utiliser un Nombre tapez un indice même s'il n'a pas été défini:

>>>

>>> de __futur__ importer annotations
>>> def ajouter(X: Nombre, y: Nombre) -> Nombre:
...     revenir X + y
...
>>> # Aucune erreur de nom n'est générée!
>>> ajouter.__annotations__
'x': 'Number', 'y': 'Number', 'return': 'Number'

Pour évaluer les indices de type, vous devez appeler get_type_hints (). En d'autres termes, l'évaluation des indices de type est reportée jusqu'à ce que get_type_hints () ou une autre fonction, telle que eval (), est appelé.

Initialement, le plan était d'introduire progressivement ce nouveau comportement et finalement de l'adopter comme valeur par défaut dans Python 4. Cependant, la décision a été prise après le Sommet du langage Python 2020 de reporter l'adoption de Python 3.10, qui sortira en octobre 2021.

En ce qui concerne la façon dont ce nouveau comportement affectera les utilisateurs de Python, PEP 563 dit ce qui suit:

Les vérificateurs de type statique ne verront aucune différence de comportement, tandis que les outils utilisant des annotations au moment de l'exécution devront effectuer une évaluation différée. (La source)

En d'autres termes, les outils ne peuvent plus s'attendre à ce que les indices de type soient évalués pour eux et doivent mettre à jour leur code pour évaluer les annotations explicitement si nécessaire.

Avec la PEP 563 acceptée et des plans en place pour changer le comportement par défaut, des projets comme FastAPI et pydantic, qui utilisent des annotations au moment de l'exécution, ont entrepris de prendre en charge le PEP.

Pourquoi les projets ont eu du mal à mettre en œuvre la PEP 563

Le 15 avril 2021, propriétaire de pydantic et contributeur principal Samuel Colvin a rédigé un numéro sur le référentiel GitHub de pydantic expliquant comment «essayer d'évaluer ces chaînes pour obtenir les objets d'annotation réels est vraiment difficile, voire impossible de toujours faire correctement».

Colvin a énuméré vingt-deux problèmes pydantic mettant en évidence la lutte que les responsables avaient rencontrée en essayant d'implémenter PEP 563. Il avait ceci à dire sur les raisons pour lesquelles l'implémentation était si difficile:

Les raisons sont compliquées mais fondamentalement typing.get_type_hints () ne fonctionne pas tout le temps, pas plus que les nombreux hacks que nous avons introduits pour essayer de résoudre ce problème. Même si typing.get_type_hints () était irréprochable, ce serait encore beaucoup plus lent que la sémantique actuelle. (La source)

Une recherche sur bugs.python.org pour "get_type_hints" révèle un certain nombre de problèmes en suspens et semble confirmer l'affirmation de Colvin selon laquelle typing.get_type_hints () ne fonctionne pas correctement dans tous les scénarios.

Comme solution, Colvin pointe vers PEP 649, qui a été rédigé par le développeur principal de Python Larry Hastings en janvier 2021. PEP 649 propose une évaluation différée des annotations au lieu de l'évaluation reportée de PEP 563.

En bref, la PEP 649 reporte l'évaluation des indices de type jusqu'à ce que .__ annotations__ l’attribut est accédé. Cela résout les deux problèmes traités par PEP 563 tout en résolvant simultanément les problèmes rencontrés par des projets tels que pydantic et FastAPI.

Colvin a exprimé son soutien à PEP 649 à la fois dans son numéro original sur le dépôt GitHub de pydantic ainsi que dans un message du 15 avril sur la liste de diffusion python-dev.

Comment les utilisateurs de Python et les développeurs principaux ont atteint une solution à l'amiable

Après que Colvin eut exprimé ses inquiétudes sur python-dev, les développeurs principaux ont commencé un discours avec lui sur la façon de résoudre le problème.

Lorsqu'un utilisateur a plaidé pour que le conseil de direction accepte la PEP 649 et évite de casser pydantic, développeur principal Paul Ganssle a répondu en soulignant que ce n'étaient pas les seules options et a proposé de garder PEP 563 facultatif jusqu'à la sortie de Python 3.11:

Je dois souligner que «accepter PEP 649» et «casser pydantic» ne sont pas
les seules options ici. La chose qui brisera pydantic est la fin de
Période de dépréciation de la PEP 563, et non un échec de mise en œuvre de la PEP 649.

D'autres options viables comprennent:

  • Laissez le PEP 563 opt-in jusqu'à ce que nous puissions nous mettre d'accord sur une solution au problème.
  • Laissez le PEP 563 opt-in pour toujours.
  • Abandonnez la PEP 563 et revenez au statu quo ante.

… En supposant qu'il s'agit d'un réel problème (et en partie en fonction du temps qu'il a fallu
pour qu'attrs obtienne le soutien dont il dispose pour la PEP 563… je ne serais pas
surpris si PEP 563 jette tranquillement une clé dans les travaux
plusieurs autres endroits), mon vote est de laisser le PEP 563 opt-in jusqu'à
au moins 3.11 plutôt que d'essayer de se précipiter dans une discussion sur et
mise en œuvre de PEP 649. (Source)

Même Pablo Galindo est intervenu sur le problème pydantic original de Colvin, exprimant son souhait que Colvin ait informé l'équipe principale plus tôt tout en confirmant également que l'équipe prenait au sérieux les commentaires de Colvin:

En tant que responsable de publication de Python 3.10, cela me rend triste que les premiers problèmes mentionnés ici … remontent à 2018, mais nous entendons parler de tous ces problèmes et de leur impact critique sur pydantic dangereusement proche du gel de la bêta. …

Dans tous les cas, pour nous, s'assurer que toute notre base d'utilisateurs est prise en compte est un très sérieux important afin que vous puissiez être sûr que nous en tiendrons compte lors de la discussion de la question globale. (La source)

Carol Willing, développeur principal de Python et membre du conseil de pilotage, a également posté sur le problème de Colvin afin de valider ses préoccupations et d'assurer à tout le monde qu'une solution pourrait être trouvée:

Permettez-moi de dire d’emblée que je suis un utilisateur très satisfait de pydantic et de FastAPI, et je suis très reconnaissant pour le travail et les contributions que les responsables et la communauté autour d’eux ont apportés.…

Je suis optimiste sur le fait que nous pouvons trouver une solution gagnant-gagnant pour pydantic / FastAPI et Python. Je pense que cela est possible si nous essayons de ne pas polariser prématurément la solution en «tout ou rien» ou «accepter ou rejeter 649». Pour y parvenir, nous devons examiner cela à travers le prisme de «ce qui est possible», équilibrer les compromis et travailler à une solution «bonne mais peut-être pas idéale». (La source)

Enfin, le 20 avril, cinq jours seulement après que Colvin a alerté les développeurs principaux de Python sur les problèmes auxquels pydantic était confronté, le conseil de direction a annoncé qu'il reporterait l'adoption de PEP 563 à Python 3.11:

Le Conseil de pilotage a soigneusement étudié la question, ainsi que de nombreux
proposé des alternatives et des solutions, et nous avons décidé qu'à ce stade,
nous ne pouvons tout simplement pas risquer la rupture de compatibilité de PEP 563. Nous devons rouler
revenir sur la modification qui a fait des annotations stringifiées la valeur par défaut, au moins pour
3.10. (Pablo y travaille déjà.)

Pour être clair, nous ne revenons pas à la PEP 563 elle-même. La future importation sera
continuer à fonctionner comme il le faisait depuis Python 3.7. Nous retardons la production de PEP 563
annotations basées sur des chaînes par défaut jusqu'à Python 3.11. Cela nous donnera
il est temps de trouver une solution qui convient à tous. (La source)

La décision du comité directeur a été saluée par Colvin et célébrée par les utilisateurs de pydantic et de FastAPI. La décision a également attiré les éloges du créateur de Python Guido van Rossum, qui a applaudi le conseil de pilotage:

Vous avez la sagesse de Salomon. Roulant
le code qui a fait de PEP 563 le comportement par défaut est le seul sensé
solution pour 3.10. (La source)

En fin de compte, les responsables de pydantic ont évité un sérieux casse-tête, tout comme les développeurs principaux de Python. Cependant, comme l'a souligné Galindo, il est important que les responsables de la maintenance qui rencontrent des problèmes lors de la mise en œuvre d'un PEP contactent les développeurs principaux dès que possible afin d'éviter une situation chaotique et de s'assurer que les besoins peuvent être satisfaits en temps opportun.

Il semble que Colvin a pris cette rétroaction à cœur. Dans sa réponse à Galindo après avoir entendu parler de la décision du conseil de direction, il a déclaré:

Cela a été une expérience vraiment positive pour moi et je me sens beaucoup plus positif de parler à la communauté python-dev.

À l'avenir, je m'engagerai dans le processus de publication et le traiterai comme quelque chose dont je fais (très peu) partie, plutôt que comme quelque chose qui m'arrive. (La source)

L'idée que les responsables de projet font partie du processus de publication de Python, plutôt que des spectateurs impuissants soumis aux caprices de développeurs sans visage, est une chose importante à retenir pour tout le monde.

En tant qu'utilisateurs de Python, nos commentaires sont essentiels pour aider les développeurs principaux de Python et le conseil de pilotage à prendre des décisions. Et même si nous ne sommes pas d’accord avec toutes les décisions qui sont prises, l’expérience de Colvin est la preuve que le conseil de direction nous écoute.

Quelle est la prochaine étape pour Python?

Le mois d'avril a vu de nouveaux développements passionnants dans Python. À Vrai Python, nous sommes enthousiasmés par l’avenir de Python et avons hâte de voir les nouveautés qui nous attendent dans Mai.

Quelle est votre pièce préférée de Actualités Python de avril? Avons-nous manqué quelque chose de notable? Faites-le nous savoir dans les commentaires, et nous pourrions vous présenter dans le tour d'horizon des actualités Python du mois prochain.

Joyeux Python!



[ad_2]