PEP 3107 (annotations de fonction)

PEP 572 - Annotations de fonctions

Annotation à la norme

Justification

Principes de base de l'annotation des fonctionnalités

1. Les annotations pour les paramètres et les valeurs de retour des fonctions sont complètement facultatives.
2. Les annotations ne sont rien d'autre qu'un moyen d'associer des expressions arbitraires à différentes parties d'une fonction au moment de la compilation.
   
   Python lui-même ne prête aucune attention aux annotations. La seule chose est qu'il vous permet d'y accéder, ce qui est décrit dans la section «Accès aux annotations de fonctionnalités» ci-dessous.
   
   Les annotations n'ont de sens que lorsqu'elles sont interprétées par des bibliothèques tierces. Ils peuvent faire ce qu'ils veulent avec des annotations de fonction. Par exemple, une bibliothèque peut utiliser des annotations de chaînes pour fournir des données de référence améliorées, par exemple:
   
   

   def compile(source: "something compilable",
               filename: "where the compilable thing comes from",
               mode: "is this a single statement or a suite?"):
       ...

   
   Une autre bibliothèque peut utiliser des annotations de fonction et de méthode Python pour vérifier la correspondance de type. Cette bibliothèque peut utiliser des annotations pour montrer quels types de données d'entrée elle attend et quel type de données elle renverra. Ce sera peut-être quelque chose comme ça:
   
   

   def haul(item: Haulable, *vargs: PackAnimal) -> Distance:
       ...

   
   Nous le répétons encore une fois: les annotations d' aucun des exemples en eux-mêmes n'ont de sens. Ils n'acquièrent un véritable sens qu'en combinaison avec des bibliothèques tierces.
   
3. Comme il ressort du paragraphe 2, ce PEP n'essaie pas d'introduire de mécanisme standard pour le traitement des annotations, même pour les types intégrés. Tout ce travail est affecté à des bibliothèques tierces.

Syntaxe

Paramètres

def foo (a: , b:  = 5):
    ...

def foo(*args: expression, **kwargs: expression):
    ...

def foo((x1, y1: expression),
        (x2: expression, y2: expression)=(None, None)):
    ...

Valeurs de retour

def sum() -> expression:
    ...

decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE
decorators: decorator+
funcdef: [decorators] 'def' NAME parameters ['->' test] ':' suite
parameters: '(' [typedargslist] ')'
typedargslist: ((tfpdef ['=' test] ',')*
                ('*' [tname] (',' tname ['=' test])* [',' '**' tname]
                 | '**' tname)
                | tfpdef ['=' test] (',' tfpdef ['=' test])* [','])
tname: NAME [':' test]
tfpdef: tname | '(' tfplist ')'
tfplist: tfpdef (',' tfpdef)* [',']

Lambdas

1. Cela violerait la compatibilité descendante.
2. Les lambdas sont neutres et anonymes par définition
3. Les lambdas peuvent toujours être réécrits en tant que fonctions

Accédez aux annotations des fonctionnalités

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

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

Cas d'utilisation

• Fournir des informations sur le type
  • Vérification de type
  • Conseils IDE sur les types d'arguments attendus et retournés
  • Surcharge de fonctions / fonctions génériques [env. la surcharge de fonctions est populaire dans d'autres langages et consiste en l'existence de plusieurs fonctions avec les mêmes noms, mais en même temps, le nombre de paramètres acceptés par eux varie]
  • Des ponts entre différents langages de programmation
  • Adaptation
  • Fonctions logiques de prédicat
  • Mappage d'une requête de base de données
  • Marshaling des paramètres RPC [env. Le marshaling est le processus de conversion des informations stockées dans la RAM dans un format adapté au stockage ou à la transmission. RPC - Appel de procédure à distance]
• Fournir d'autres informations
  • Documentation des paramètres et des valeurs de retour

Bibliothèque standard

Pydoc et inspecter les modules

Lien avec d'autres PEP

Objets de signature de fonction

la mise en oeuvre

Offres refusées

• BDFL [. ] , , : « »
• stdlib , , . .
• , , .
• Malgré de nouvelles discussions, il a été décidé de ne pas normaliser le mécanisme d'interaction des annotations. Un tel accord à ce stade serait prématuré. Nous voulons permettre à ces accords de se développer de manière organique, sur la base d'une situation réelle, et ne pas essayer de forcer tout le monde à utiliser une sorte de schéma artificiel.