introduction

Toutes les personnes. Vous écrivez en Python? Récemment, j'ai réaffirmé l'importance des types, j'ai donc écrit cet article avec l'espoir que tout le monde écrirait des types en Python.

En guise de mise en garde, cet article ne mentionne pas les éléments suivants:

Comment installer l'outil de vérification de type (mypy, pyrite, etc.)

Ce contenu est un supplément à l'article que j'ai écrit plus tôt, veuillez donc vous référer à l'article précédent si vous le souhaitez.

Entraine toi! !! Introduction au type Python (conseils de type)

Pourquoi écrire des types en Python en premier lieu?

Python est un langage typé dynamiquement, donc votre programme fonctionnera sans écrire aucun type. En n'écrivant pas le type, la quantité de code est réduite, et je pense que c'est un avantage que le langage soit facile à apprendre pour les débutants. Cependant, lors de l'écriture d'un certain nombre de lignes de code, lors de la maintenance d'un programme par plusieurs personnes, les problèmes suivants se produisent s'il n'y a pas de type.

Vous ne pouvez pas dire à quoi ressemble la valeur de retour simplement en regardant la fonction
Je ne sais pas si une valeur inattendue est attribuée à une variable

Donc, du point de vue du maintien du programme pendant une longue période, je pense qu'avoir un type a un avantage.

Par exemple, considérez la fonction suivante.

def add(a, b):
    """Renvoie le résultat de l'ajout d'arguments"""
    return a + b

def add_type(a: int, b: int) -> int:
    """Renvoie le résultat de l'ajout d'arguments"""
    return a + b

Fonctions avec le même contenu, mais l'une a un type et l'autre pas de type. Vous pouvez en fait l'utiliser comme ceci, mais si le créateur de la fonction ne s'attendait pas à ce qu'elle contienne une chaîne, la fonction add_type avec un type affichera une erreur dans l'éditeur.

print(add('1', '2'))
print(add_type('1', '2'))

Le créateur et l'utilisateur d'une fonction ne sont pas toujours les mêmes, et même une fonction créée par vous-même oubliera son contenu avec le temps. En donnant un type, vous pouvez vous attendre à ce que la fonction soit utilisée comme prévu.

Introduction au moule

Type intégré (liste, dict, tuple)

En ce qui concerne la liste, etc., la méthode d'écriture est différente entre Python 3.8 et 3.9. La méthode de typage traditionnelle a été déconseillée et la méthode de type intégrée a été recommandée.

Pour Python 3.8

from typing import Dict, List, Tuple

val_e: Dict[str, int] = {'size': 12, 'age': 24}
val_f: List[str] = ['taro', 'jiro']
val_g: Tuple[str, int] = ('name', 12)

Pour Python 3.9

val_e: dict[str, int] = {'size': 12, 'age': 24}
val_f: list[str] = ['taro', 'jiro']
val_g: tuple[str, int] = ('name', 12)

À propos de Final

Final est disponible par défaut depuis Python 3.8. Vous pouvez l'empêcher d'être réaffecté en définissant une constante (non réaffectable).

from typing import Final
TABLE_NAME: Final[str] = 'sample'

J'obtiens une erreur lorsque j'essaie de réaffecter.

Utiliser activement le tuple pour les constantes

Puisque list et tuple ont des fonctions similaires, j'ai tendance à utiliser list, mais je vais l'introduire car le tuple peut avoir plus d'avantages. Dans le cas d'une liste, il est possible de réécrire les informations internes, mais dans la plupart des cas, ce qui est défini comme une constante ne souhaite pas que les informations internes soient réécrites. Dans un tel cas, si vous le définissez avec tuple, vous n'avez pas à vous soucier de la modification des informations internes.

Pour Python 3.8

from typing import Final, Tuple, List

#Puisqu'il s'agit d'un tuple, il ne peut pas être modifié
NAME_TUPLE: Final[Tuple[str, str]] = ('taro', 'jiro')

#la liste peut être modifiée
NAME_LIST: Final[List[str]] = ['taro', 'jiro']
NAME_LIST[0] = 'saburo'

Pour Python 3.9

from typing import Final

#Puisqu'il s'agit d'un tuple, il ne peut pas être modifié
NAME_TUPLE: Final[tuple[str, str]] = ('taro', 'jiro')

#la liste peut être modifiée
NAME_LIST: Final[list[str]] = ['taro', 'jiro']
NAME_LIST[0] = 'saburo'

Utiliser activement le tuple nommé pour les constantes

Je pense qu'il y a des cas où dict est utilisé pour les constantes. Dans ce cas, vous pouvez être assuré que l'utilisation de namedtuple ne modifiera pas les informations internes.

from typing import NamedTuple, TypedDict

class StudentInfoTuple(NamedTuple):
    name: str
    age: int

class StudentInfoDict(TypedDict):
    name: str
    age: int

#En cas de namedtuple, les informations internes ne peuvent pas être réécrites
TARO: Final[StudentInfoTuple] = StudentInfoTuple('taro', 12)
#La ligne suivante entraînera une erreur
# TARO.name = 'taro2'

#Dans le cas de dict, les informations internes peuvent être réécrites
JIRO: Final[StudentInfoDict] = {'name': 'jiro', 'age': 9}
JIRO['name'] = 'jiro2'

À propos des arguments facultatifs de TypedDict

Premièrement, il existe deux manières d'écrire TypedDict. Dans l'exemple ci-dessous, MovieA et MovieB peuvent être utilisés comme types synonymes.

from typing import TypedDict

MovieA = TypedDict('MovieA', {'name': str, 'year': int})

class MovieB(TypedDict):
    name: str
    year: int

cat: MovieA = {'name': 'cat', 'year': 1993}
dog: MovieB = {'name': 'dog', 'year': 2000}

Alors que faire si vous voulez déterminer si un type appelé Movie a un attribut appelé author ou non? Dans ce cas, écrivez comme suit.

from typing import TypedDict

class MovieRequiredType(TypedDict):
    name: str
    year: int

class MovieOptionalType(TypedDict, total=False):
    author: str

class MovieType(MovieRequiredType, MovieOptionalType):
    pass

#MovieType peut avoir ou non l'attribut author
rabbit: MovieType = {'name': 'rabbit', 'year': 2002}
deer: MovieType = {'name': 'deer', 'year': 2006, 'author': 'jack'}

Bien entendu, si le nom et l'année des attributs requis ne sont pas présents, une erreur se produira sur l'éditeur.

Il existe deux façons d'écrire TypedDict, mais le style de classe a l'avantage de pouvoir être hérité plusieurs fois. Par conséquent, je pense que de nombreuses personnes l'utilisent activement.

finalement

J'espère que vous comprenez l'importance des types en Python. Écrire un type peut sembler gênant, mais plus le code est complexe, plus vous pouvez comprendre la valeur du type. Enfin, la notation Python 3.9 n'est pas prise en charge par certains outils (comme mypy), donc soyez prudent lorsque vous l'utilisez. (À partir d'octobre 2020)

Maîtriser le type avec Python [compatible Python 3.9]