Quelles sont les variables les annotations en Python 3.6?

Python 3.6 est sur le point d'être libéré. PEP 494 -- Python 3.6 Calendrier de mise en mentionne la fin du mois de décembre, je suis donc allé à travers Ce qui est Nouveau en Python 3.6 de voir la mention de la variable annotations:

PEP 484 introduit la norme pour les annotations de type des paramètres de la fonction, une.k.un. type de conseils. Ce PEP ajoute la syntaxe de Python pour annoter les types de variables, y compris les variables de classe et les variables d'instance:

  primes: List[int] = []

  captain: str  # Note: no initial value!

  class Starship:
     stats: Dict[str, int] = {}

Tout comme pour la fonction d'annotations, l'interpréteur Python ne fixez pas un sens particulier à la variable d'annotations et seulement les stocke dans un attribut spécial __annotations__ d'une classe ou d'un module. Contrairement aux déclarations de variables dans les langages à typage statique, l'objectif de l'annotation de la syntaxe est de fournir un moyen facile de spécifier de type structuré de métadonnées pour des tiers, des outils et des bibliothèques via l'arbre de syntaxe abstraite et la __annotations__ attribut.

Donc, à partir de ce que j'ai lu ils font partie du type de conseils venant de Python 3.5, décrit dans Quelles sont les préconisations en Python 3.5.

J'ai suivi les captain: str et class Starship exemple, mais vous ne savez pas à propos de la dernière: Comment primes: List[int] = [] expliquer? Est-ce la définition d'une liste vide qui va juste permettre entiers?

Type d'indicateurs n' pas n'importe quel type de vérification. primes: List[int] = [] est juste une liste vide comme primes = []. La différence, c'est que vous êtes revendiquant que primes signifie contiennent uniquement ints et les applications 3ème partie peut taper vérifier votre programme afin de vérifier cette affirmation, mais lorsque vous exécutez le code dans n'importe quel interpréteur python c'est juste le même que l'écriture de primes = [], et faisant ainsi primes: List[int] = []; primes.append("string") est toujours valide.
oui, bon point. Comme Jim Fasarakis-Hilliard décrit dans sa réponse à Quelles sont les préconisations en Python 3.5, pourquoi le type conseils → Aide à type de dames, aide à la documentation et Aide les IDEs de développer plus précis et robustes outils. Prises à partir de PEP 526 -- Syntaxe pour la Variable Annotations, Python restera un typées dynamiquement de la langue, et les auteurs n'ont aucun désir de toujours faire des préconisations obligatoires, même par convention.

OriginalL'auteur fedorqui | 2016-10-11

  1. 31

    Tout entre : et la = est un type d'indice, de sorte primes est en effet définie comme List[int], et initialement fixé à une liste vide (et stats est un dictionnaire vide au départ, défini comme Dict[str, int]).

    List[int] et Dict[str, int] ne font pas partie de la prochaine syntaxe cependant, elles ont été déjà définies dans le Python 3.5 tapant conseils PEP. Le 3.6 PEP 526 – la Syntaxe pour la Variable Annotations proposition seulement définit la syntaxe d'accorder les mêmes conseils à des variables; avant que vous ne pouviez vous joindre type allusions à des variables avec des commentaires (par exemple primes = [] # List[int]).

    Les deux List et Dict sont Générique types, indiquant que vous avez une liste ou un dictionnaire avec cartographie spécifique (béton) table des matières.

    Pour List, il y a un seul "argument" (les éléments de l' [...] syntaxe), le type de chaque élément dans la liste. Pour Dict, le premier argument est le type de clé, et la seconde, le type de la valeur. Donc tous valeurs dans le primes liste sont des entiers, et tous paires clé-valeur dans la stats dictionnaire sont (str, int) paires, de la cartographie des chaînes de nombres entiers.

    Voir le taper.List et taper.Dict définitions, la la section Génériques, ainsi que PEP 483 – La Théorie de Type Conseils.

    Comme type de conseils sur les fonctions, leur utilisation est facultative et sont aussi considérés comme des annotations (à condition qu'il existe un objet à attacher, de sorte globales dans les modules et les attributs sur les classes, mais pas les habitants dans les fonctions que vous pouvez connaître via le __annotations__ attribut. Vous pouvez joindre arbitraire info de ces annotations, vous ne sont pas strictement limitée à type d'informations.

    Vous voudrez peut-être lire le proposition complète; il contient des fonctionnalités supplémentaires au-dessus et au-delà de la nouvelle syntaxe; elle indique quand ces annotations sont évalués, comment introspecter et comment déclarer quelque chose comme un attribut de classe contre l'instance d'attribut, par exemple.

    Puis-je considérer que le type de conseils comme une sorte de "machine-readable" des commentaires, car ils n'affectent pas le fonctionnement de ce code (à l'exception d'une obj.__annotations__ attribut)?
    les annotations sont lisibles à la machine des commentaires, dans la mesure où les commentaires sont lisibles par l'homme annotations de toute façon. 🙂

    OriginalL'auteur Martijn Pieters

  2. 37

    Quelles sont les variables les annotations?

    Variable annotations sont juste la prochaine étape de # type commentaires, tels qu'ils ont été définis dans PEP 484; la justification de ce changement est mis en évidence dans le section correspondante de PEP 526.

    Ainsi, au lieu de la consigne du type:

    primes = []  # type: List[int]

    Nouvelle syntaxe a été introduite pour permettre directement l'annotation du type avec une affectation de la forme:

    primes: List[int] = []

    qui, comme @Martijn a souligné, dénote d'une liste d'entiers en utilisant des types disponibles dans en tapant et l'initialisation d'une liste vide.

    Ce qui change-t-il?

    Le premier changement a été nouvelle syntaxe qui vous permet d'annoter un nom avec un type, soit de manière autonome, après la : caractère ou éventuellement d'annoter tout en attribuant une valeur:

    annotated_assignment_stmt ::=  augtarget ":" expression ["=" expression]

    Donc l'exemple à la question:

       primes: List[int] = [ ]
#    ^        ^         ^
#  augtarget  |         |
#         expression    |
#                  expression (optionally initialize to empty list)

    Des modifications supplémentaires ont également été introduites avec la nouvelle syntaxe; les modules et les classes ont maintenant une __annotations__ attribut (comme des fonctions l'ont eu depuis PEP 3107 -- Fonction des Annotations) dans lequel le type de métadonnées est joint:

    from typing import get_type_hints  # grabs __annotations__

    Maintenant __main__.__annotations__ détient la déclaration de types:

    >>> from typing import List, get_type_hints
>>> primes: List[int] = []
>>> captain: str
>>> import __main__
>>> get_type_hints(__main__)
{'primes': typing.List<~T>[int]}

    captain ne actuellement en get_type_hints parce que get_type_hints renvoie uniquement les types qui peuvent également être accessible à partir d'un module; c'est à dire, il a besoin d'une valeur première:

    >>> captain = "Picard"
>>> get_type_hints(__main__)
{'primes': typing.List<~T>[int], 'captain': <class 'str'>}

    à l'Aide de print(__annotations__) montrera 'captain': <class 'str'> mais vous ne devriez pas accéder __annotations__ directement.

    De même, pour les classes:

    >>> get_type_hints(Starship)
ChainMap({'stats': typing.Dict<~KT, ~VT>[str, int]}, {})

    Où un ChainMap est utilisé pour saisir les annotations pour une classe donnée (situé dans la première cartographie) et toutes les annotations définies dans les classes de base trouvé dans son mro (à la suite des mappages, {} pour l'objet).

    Avec la nouvelle syntaxe, une nouvelle ClassVar type a été ajouté pour désigner les variables de classe. Yup, stats dans votre exemple est en fait un variable d'instance, pas un ClassVar.

    Vais-je être obligée de l'utiliser?

    Comme type de conseils de PEP 484, ce sont complètement facultatif et sont d'une utilisation principale de type outils de vérification (et tout ce que vous pouvez construire sur cette base d'informations). Il est provisoire quand la version stable de Python 3.6 est sorti, de sorte que de petites modifications pourraient être ajoutées dans le futur.

    OriginalL'auteur Jim Fasarakis Hilliard