Quels sont les bons usages pour Python3 ' s « Fonction Annotations »

Question

Fonction des Annotations: PEP-3107

J'ai couru à travers un extrait de code montrant Python3 la fonction d'annotations. Le concept est simple mais je ne vois pas pourquoi elles ont été mises en œuvre dans Python3 ou toutes les bonnes utilisations pour eux. Peut-être peut m'éclairer?

Comment il fonctionne:

def foo(a: 'x', b: 5 + 6, c: list) -> max(2, 9):
    ... function body ...

Le tout en suivant le côlon après un argument est une "annotation", et de l'information à la suite de la -> est une annotation pour la fonction de valeur de retour.

foo.func_annotations serait de retour d'un dictionnaire:

{'a': 'x',
 'b': 11,
 'c': list,
 'return': 9}

Quelle est la signification de cette disposition?

Answer 1

Les annotations de fonction sont ce que vous faites d’eux.

Ils peuvent être utilisés pour la documentation :

Ils peuvent être utilisés pour la vérification de la condition préalable :

Voir aussi http://www.python.org/dev/peps/pep-0362/ pour un moyen d’implémenter la vérification du type.

Answer 2

Je pense que c'est en fait une grande.

Venant d'un milieu universitaire, je peux vous dire que les annotations se prouver avec le travail inestimable pour l'activation de smart analyseurs statiques de langues comme Java. Par exemple, vous pouvez définir la sémantique comme les restrictions imposées par l'état, les threads qui sont autorisés à accéder, à des limitations de leur architecture, etc., et il y a un certain nombre d'outils qui peuvent ensuite lire ces processus et de leur donner des assurances au-delà de ce que vous obtenez à partir de compilateurs. Vous pouvez même écrire des choses qui vérifient les conditions préalables/postconditions.

Je sens quelque chose comme ceci est particulièrement nécessaire en Python, en raison de sa plus faible de frappe, mais il n'y avait vraiment pas de constructions qui fait de ce simple et la partie officielle de la syntaxe.

Il y a d'autres façons de les utiliser au-delà de l'assurance. Je peux voir comment je pourrais appliquer mes Java d'outils de Python. Par exemple, j'ai un outil qui vous permet d'assigner mises en garde spéciales de méthodes, et vous donne des indications lorsque vous les appelez, que vous devez lire leur documentation (E. g., imaginez que vous avez une méthode qui ne doit pas être appelée avec une valeur négative, mais elle n'est pas intuitive du nom). Avec des annotations, j'ai pu technicall écrire quelque chose comme ceci pour Python. De même, un outil qui organise des méthodes dans une classe basée sur des tags peut être écrit si il y a un officiel de la syntaxe.

Answer 3

Juste pour ajouter un exemple d'une bonne utilisation de ma réponse ici, couplé avec des décorateurs d'un mécanisme simple pour multimethods peut être fait.

# This is in the 'mm' module

registry = {}

class MultiMethod(object):
    def __init__(self, name):
        self.name = name
        self.typemap = {}
    def __call__(self, *args):
        types = tuple(arg.__class__ for arg in args) # a generator expression!
        function = self.typemap.get(types)
        if function is None:
            raise TypeError("no match")
        return function(*args)
    def register(self, types, function):
        if types in self.typemap:
            raise TypeError("duplicate registration")
        self.typemap[types] = function

def multimethod(function):
    name = function.__name__
    mm = registry.get(name)
    if mm is None:
        mm = registry[name] = MultiMethod(name)
    types = tuple(function.__annotations__.values())
    mm.register(types, function)
    return mm

et un exemple d'utilisation:

from mm import multimethod

@multimethod
def foo(a: int):
    return "an int"

@multimethod
def foo(a: int, b: str):
    return "an int and a string"

if __name__ == '__main__':
    print("foo(1,'a') = {}".format(foo(1,'a')))
    print("foo(7) = {}".format(foo(7)))

Cela peut être fait par l'ajout des types pour le décorateur comme Guido de l'original post montre, mais en annotant les paramètres eux-mêmes est préférable car elle permet d'éviter la possibilité d'un mauvais appariement des paramètres et types.

Remarque: En Python, vous pouvez accéder aux annotations function.__annotations__ plutôt que d' function.func_annotations le func_* style a été supprimé sur Python 3.

Answer 4

URI a déjà donné une réponse correcte, alors voici la moins grave : que vous puissiez faire votre code plus court.

Answer 5

La première fois que j’ai vu les annotations, je pensais que « grand ! Enfin je peux opter pour des vérifications de type ! » Bien sûr, je n’avais pas remarqué que les annotations ne sont pas réellement appliquées.

Alors j’ai décidé d’écrire un décorateur de fonction simple pour faire respecter:

Je l’ai ajouté à la bibliothèque de s’assurer .