À partir de python3.5, python incorpore également le concept d'indices de type.
Pour l'utiliser, utilisez le type intégré ou utilisez ʻimport typing, et utilisez mypy` pour vérifier le type.
Tout d'abord, installez le paquet pour utiliser mypy.
$ pip install mypy
Créez mypy.ini comme suit et entrez les informations de réglage ici.
mypy.ini
[mypy]
python_version = 3.8
disallow_untyped_calls = True
disallow_untyped_defs = True
disallow_untyped_decorators = True
disallow_incomplete_defs = True
check_untyped_defs = True
pretty = True
[mypy-django.*]
ignore_missing_imports = True
Voir ici (https://mypy.readthedocs.io/en/latest/config_file.html) pour ce que vous pouvez configurer.
Le type intégré peut être utilisé tel quel.
num: int = 1
float_num: float = 1.11
is_something: bool = True
text: str = 'hoge'
byte_str: bytes = b'fuga'
arr: list = [0, 1, 2, 3]
Si vous ne savez pas quel type va dans la variable, utilisez ʻAny`. Si ce type est spécifié, aucune vérification de type ne sera effectuée.
something: Any = Something()
La classe de base de tous les types, ʻobject, peut être utilisée de la même manière, mais ʻobject est utilisé pour indiquer qu'une valeur peut être utilisée comme n'importe quel type de manière sûre, et ʻAny` l'est. Utilisé pour indiquer qu'une valeur est typée dynamiquement.
Si vous utilisez le type de dictionnaire, utilisez typing.Dict.
dictionary: Dict[str, int] = {'hoge': 1, 'fuga': 2}
Si vous voulez utiliser le type taple, utilisez typing.Tuple.
something: Tuple[str, int] = ('hoge', 1)
Si vous souhaitez utiliser le type d'ensemble, utilisez typing.Set.
Le type d'ensemble est une collection unique.
something: Set[int] = {6, 7}
Si vous souhaitez utiliser le type de séquence, utilisez typing.Sequence.
Le type de séquence est une structure de données à traiter dans l'ordre (séquentiel).
something: Sequence = [0, 1, 2]
Si vous souhaitez utiliser le type itérateur, utilisez typing.Iterator.
Le type d'itérateur est une classe itérable et doit avoir __iter__ ().
something: Iterator = IterableClass()
Si vous souhaitez utiliser le type de mappage, utilisez typing.Mapping.
Le type de mappage est une structure de données pour effectuer une recherche de clé arbitraire et est un type immuable.
something: Mapping[str, int] = {'hoge': 1, 'fuga': 2}
Si vous souhaitez utiliser le type union, utilisez typing.Union.
Les types d'union vous permettent de spécifier plusieurs types.
something_mapping: Mapping[str, int] = {'hoge': 1, 'fuga': 2}
something_union: Union[int, None] = something_mapping.get('hoge') # 1
something_union: Union[int, None] = something_mapping.get('piko') # None
«typing.Optional» est une image dans laquelle «Aucun» de type «typing.Union» est toujours sélectionné.
something_mapping: Mapping[str, int] = {'hoge': 1, 'fuga': 2}
something_optional: Optional[int] = something_mapping.get('hoge') # 1
something_optional: Optional[int] = something_mapping.get('piko') # None
Si vous souhaitez utiliser une fonction, utilisez typing.Callable.
def something() -> bool:
return True
something_callable: Callable = something
Utilisez typing.Literal si vous voulez garantir que seule une valeur fixe sera saisie.
mode: Literal['r', 'rb', 'w', 'wb'] = 'r' # OK
mode: Literal['r', 'rb', 'w', 'wb'] = 'a' # NG
Utilisez typing.AnyStr si vous voulez qu'il soit utilisé par une fonction qui autorise n'importe quel type de chaîne sans le mélanger avec d'autres types de chaînes.
def concat(a: AnyStr, b: AnyStr) -> AnyStr:
return a + b
concat(u"foo", u"bar") #OK unicode est sorti
concat(b"foo", b"bar") #Les octets OK sont émis
concat(u"foo", b"bar") #Une erreur se produira car unicode et des octets NG sont mélangés.
Vous pouvez définir l'ancien type avec n'importe quel nom de type.
Vector = List[float]
ConnectionOptions = Dict[str, str]
Address = Tuple[str, int]
Server = Tuple[Address, ConnectionOptions]
NewType
Utilisez typing.NewType pour créer différents types.
UserId = NewType('UserId', int)
some_id = UserId(524313)
Pour utiliser le type générique:
T = TypeVar('T')
#C'est la fonction générique
#Tout type peut être utilisé pour le type de séquence
def first(l: Sequence[T]) -> T:
return l[0]
Les types génériques définis par l'utilisateur peuvent être utilisés comme suit:
T = TypeVar('T')
class LoggedVar(Generic[T]):
def __init__(self, value: T, name: str, logger: Logger) -> None:
self.name = name
self.logger = logger
self.value = value
def set(self, new: T) -> None:
self.log('Set ' + repr(self.value))
self.value = new
def get(self) -> T:
self.log('Get ' + repr(self.value))
return self.value
def log(self, message: str) -> None:
self.logger.info('%s: %s', self.name, message)
logger: LoggedVar[str] = LoggedVar('hoge', 'Test', Logger())
logger.get() #T est traité comme type str
Une fois que vous voulez changer le type défini, lancez-le en utilisant typing.cast.
Afin de rendre le processus aussi rapide que possible, nous n'inspectons intentionnellement rien au moment de l'exécution.
a = [4]
b = cast(List[int], a)
c = cast(List[str], a) # [4]N'est jamais une chaîne, donc si vous voulez la convertir, ajoutez vous-même le processus de conversion
Si vous voulez utiliser des constantes, utilisez typing.Final.
SOMETHING: Final[str] = 'Something'
Comment était-ce? Je pense que vous pouvez créer une application plus puissante en utilisant pleinement les types. Cependant, veuillez noter que la spécification du type n'accélère pas le traitement spécial. Certains d'entre eux n'ont pas fonctionné, donc si vous trouvez quelque chose qui ne va pas, veuillez nous en informer.
https://docs.python.org/ja/3/library/typing.html
Recommended Posts