(Annotations de fonction) syntaxe pour réaliser la fonction de vérification du type de paramètre basé sur Python 3 nouveau commentaire

06/01/2016

python python 3 / annotations de fonction

Fonction Notes (Annotations de fonction)

Fonction syntaxe d'annotation vous permet de définir la fonction des annotations de valeur du temps de Rajouter paramètres et retour:

def foobar (a: int, b: "Il est b", c: str = 5) -> tuple: 
    retour a, b, c

a: int Ce paramètre est un commentaire
c: str = 5 Remarques il y a des valeurs de paramètres par défaut
-> tuple La valeur de retour est un commentaire.

annotations Le contenu peut être les deux types peuvent également être une chaîne, et même l'expression:

def toto (a: 1 + 1) -> 2 * 2: 
    retour d' un

Alors, comment pouvons-nous obtenir l'annotation de fonction pour définir? Il y a au moins deux façons:

__annotations__:

>>> foobar .__ annotations__ 
{ 'a': int, 'b': "Il est b", 'c': str, 'retour': tuple}

inspect.signature:

>>> Importation Vérifiez
 >>> SIG = Vérifier . Signature ( foobar ) >>> # Get paramètres de la fonction >>> SIG . Paraments mappingproxy ( OrderedDict ([( 'A' , < le paramètre "A: int" > ), ( 'B' , < le paramètre "B:" IT 'S B "">), (' C », <le paramètre "C:. STR = 5">)])) >>> # getters paramètres annotation >>>pour k , v danssig . paramètres . articles (): print ( '{k}: {a r!}' . format ( k = k , a = v . annotation )) a : < class ' int '> b : "Il est b" c : < class ' str « > >>> #返回值注解>> sig . return_annotation tuple

Étant donné que la fonction d'annotation peut être définie, nous pouvons utiliser le type de paramètre vérifier.

La vérification de type

interpréteur Python et le contrôle de type ne viendra pas la fonction d'annotation automatiquement en fonction, nous devons réaliser leur propre vérification de type:

>>> foobar .__ annotations__ 
{ 'a': int, 'b': "Il est b", 'c': str, 'retour': tuple} 

>>> foobar (a = 'a', b = 2, c = 3) 
( 'a', 2, 3)

Maintenant , par inspect.signature ce que nous pouvons obtenir les paramètres annotation ordre et fonction de la définition de la fonction, nous pouvons vérifier le type du paramètre passé à la fonction sont compatibles avec la fonction d'annotation en définissant un décorateur, fonction de décorateur mis en œuvre ici (check_type.py) comme suit:

# Codage: UTF8
 importation Collections
 d' importation functools importation Inspect DEF Vérifiez ( FUNC ): MSG = ( 'le type attendu {! Attendu R & lt} argument {argument de },' {! Valeur R & lt} Mais GOT type {! GOT R & lt} avec la valeur ' ) # Pour obtenir la fonction des paramètres définis SIG = Inspect . Signature ( FUNC ) paramètres = SIG . paramètres paramètre # dictionnaire ordonné arg_keys = tuple ( paramètres . clés ()) # nom du paramètrefunctools.wraps @ ( FUNC ) DEF warpper ( * args , ** kwargs ): CheckItem = Collections . namedtuple ( 'CheckItem' , ( 'Anno' , 'arg_name' , 'valeur' )) check_list = [] # * args la collecte args paramètre passé et l'annotation des paramètres de la fonction correspondant à I , la valeur dans les Énumérer ( args :) arg_name = arg_keys [ I ]Anno = Paramètres [ arg_name ] . Annotation check_list . Append ( CheckItem ( anno , arg_name , valeur )) # ** kwargs les arguments passés kwargs Collectionnez les paramètres et les annotations correspondantes pour arg_name , valeur en kwargs . Éléments (): anno = paramètres [ arg_name ] . Annotation check_list . append ( CheckItem ( Anno ,arg_name , valeur )) # type de contrôle pour l' article dans check_list : si pas isinstance ( article . valeur , point . anno ): erreur = msg . Format ( prévu = article . anno , l' argument = item . arg_name , obtenu = le type ( article . valeur ), valeur = item. valeur ) augmentation TypeError ( erreur ) retour func ( * args , ** kwargs ) retour emballage

Testons notre décoratrice:

@check 
def toto (a: int, b: str, c: float = 3,2) -> tuple: le 
    retour a, b, c

Ordre paramètre essai:

>>> toto (1, 'b') 
(1, 'b', 3,2) 

>>> toto (1, 'b', 3,5) 
(1, 'b', 3,5) 

>>> toto ( 'a' , 'b') 
... 
TypeError: Type attendu <class 'int'> pour un argument, mais le type obtenu <class 'str'> avec la valeur « un 

>>> foobar (1, 2) 
... 
TypeError: Estimé tapez <class 'str'> pour l' argument b, mais le type obtenu <class 'int'> avec la valeur 2 

>>> foobar (1, 'b', 3) 
... 
TypeError: Type attendu <class 'float'> pour c argument, mais le type obtenu <class 'int'> avec la valeur

paramètre mot-clé passe:

>>> toto (b = 'b', a = 2) 
(2, 'b', 3,2) 
>>> toto (b = 'b', a = 2, c = 3,5) 
(2, 'b', 3.5) 

>>> foobar (a = 'foo', b = 'bar') 
... 
TypeError: Type attendu <class 'int'> pour un argument, mais le type obtenu <class 'str'> avec la valeur 'foo' 

>>> foobar (b = 3, a = 2) 
... 
TypeError: Type attendu <class 'str'> b pour argument, mais le type obtenu <class 'int'> avec la valeur 3 

>>> foobar (a = 2 , b = 'bar', c = 3) 
... 
TypeError: Type attendu <class 'float'> pour l' argument c, mais le type obtenu <class 'int'> avec la valeur

Fonction Annotations au moyen d'un seul paramètre de type décorateur de vérification ainsi obtenus.