Une introduction détaillée à la vérification de type en Python

Avant-propos

Tout le monde sait que Python est un langage de vérification de type dynamique et fortement typé. Le type dit dynamique signifie que lors de la définition d'une variable, nous n'avons pas besoin de spécifier le type de la variable. L'interpréteur Python la vérifiera automatiquement au moment de l'exécution.

Par rapport aux langages typés statiquement (tels que C), il ne s'agit pas seulement d'écrire quelques caractères de déclaration de type en moins :

#include <stdlib.h>
#include <stdio.h>

#define BUFF 100

char* greeting(char* name){ 
 char* msg = (char *) malloc(sizeof(char) * BUFF);
 sprintf(msg, "Hello, %s!", name);
 return msg;
}

int main(){ 
 printf("Greeting: <%s>\n", greeting("C99"));
 return 0;
}

def greeting(name): 
 return "Hello, {}!".format(name)
def main(): 
 print("Greeting: <%s>" % greeting("Python35"))
if __name__ == &#39;__main__&#39;: 
 main()

La saisie dynamique libère dans une certaine mesure notre réflexion de la simulation du travail informatique, nous permettant de nous concentrer davantage sur les problèmes à résoudre : tout comme Dans l'exemple ci-dessus, nous n'avons pas besoin de penser aux types de paramètres acceptés par la fonction de message d'accueil ni au type de valeur de retour, mais nous devons uniquement considérer les fonctions que la fonction de message d'accueil doit implémenter.

Bien sûr, cela ne signifie pas que les types dynamiques sont nécessairement meilleurs que les types statiques. Il est injuste de comparer l'exemple ci-dessus avec le langage C et Python si vous passez au langage Go :

package main

import "fmt"

func greeting(name string) string { 
 return fmt.Sprintf("Hello, %s", name)
}
func main() { 
 fmt.Printf("Greeting: <%s>", greeting("Go"))
}

L'avantage (et dans une certaine mesure l'inconvénient) du typage statique est qu'un protocole (interface) obligatoire est formulé lors de la définition d'une méthode, et ce n'est qu'en suivant le protocole qu'il peut être utilisé correctement. Ceci est très utile pour la coopération à plusieurs personnes, le développement de bibliothèques tierces, la localisation rapide de bogues, etc. Un autre avantage majeur du typage statique est qu'il permet à l'IDE d'accélérer l'utilisation de l'interface et la vérification du type, améliorant ainsi encore l'efficacité. Puisqu’il y a tant d’avantages, devriez-vous également apprendre Python ? En fait, le PEP 484 dans Python 3.5 et le PEP 526 dans Python 3.6 ont respectivement ajouté la syntaxe des indices de type (Les indices de type PEP 484 concernent principalement la syntaxe de déclaration de type des paramètres et les valeurs de retour des fonctions, méthodes, classes et). PEP 526 ajoute Déclaration de type de variable :

def greeting(name: str) -> str: 
 return "Hello, {}!".format(name)

Mypy

Mypy est officiellement recommandé Outils de vérification de type statique :

python3 -m pip install mypy

Vous pouvez utiliser la commande mypy pour vérifier directement les programmes Python :

mypy greeting.py

Pour faciliter l'utilisation, vous pouvez l'appliquer à l'IDE. En prenant Atom comme exemple, vous pouvez installer le plug-in linter-mypy :

python3 -m pip install typed-ast 
apm install linter 
apm install linter-mypy

Les types courants pris en charge par Mypy sont indiqués dans le tableau suivant (extrait de la documentation officielle) :

où List/Dict/Iterable/Sequence/Any provient du typage de la bibliothèque standard. La Séquence et l'Iterable correspondent ici respectivement à

et collections.abc.Sequence Pour distinguer simplement, la Séquence peut être indexée par indice numérique, tandis que l'Iterable peut représenter le générateur : collections.abc.Iterable

.

Python 2.x

Le code avec des annotations de type ajoutées peut être exécuté directement via l'interpréteur Python 3.5, mais il est totalement incompatible avec Python 2.x. Si vous souhaitez l'utiliser dans Python 2.x, vous devez d'abord installer le typage :

pip install typing

Ensuite, vous pouvez l'ajouter de force dans le formulaire d'un commentaire sur une seule ligne :

def send_email(address, # type: Union[str, List[str]] 
  sender, # type: str
  cc,  # type: Optional[List[str]]
  bcc,  # type: Optional[List[str]]
  subject='',
  body=None # type: List[str]
  ):
 # type: (...) -> bool
 """Send an email message. Return True if successful."""
 pass

Pour une introduction plus détaillée à la vérification de type en Python et des articles connexes, veuillez faire attention au site Web PHP chinois !