Аннотации и подсказки типа для Python 3.5 или выше.
Отказ от ответственности: Это «подробное резюме». Все здесь пришло от Tech с Tim Video о типинге Python. Я делаю этот пост для своего обучения, также для хранения в месте, которое я могу продолжать проверять каждый раз, когда мне нужно. Весь кредит должен идти к Тиму и его превосходному объяснению.
Видео Тима.
Зачем это?
Это просто для лучшего документирования вашего кода, чтобы облегчить автозаполнение, и для других разработчиков понять, что пройти. Следовательно, это не меняет функциональность вашего кода. Если вы пройдете int Вместо ожидаемого STR, это не будет крушение.
Инструмент анализа статического кода (Mypy)
Инструмент для проверки несоответствия типа – ошибки улавливания перед запуском вашего кода.
$ pip install mypy Usage: $ mypy /../Path/your_file.py
В Python вы, возможно, уже знаете, нам не нужно определять типы наших переменных, функций, параметров и т. Д. Мы можем просто написать это. Тем не менее, во многих других языках программирования, которые являются статичными и сильно напечатанными, вам необходимо объявить тип переменной, прежде чем вы сможете присвоить ей значение. И тогда эта переменная может содержать этот тип только на протяжении всего выполнения программы.
Например, на других языках, если вы объявите int и дайте ему str, инт , это собирается разбиться.
Но в Python, поскольку он динамически напечатан, мы можем просто сделать x Анкет
Переменная подсказка/аннотация:
Для X: , это не обеспечивает соблюдение этого x Хранить строку, это означает, что x должен хранить один. Следовательно, это не сбои, потому что это просто документация – не меняет поведение кода.
Для X: он возвращается:
error: Incompatible types in assignment (expression has type "int", variable has type "str") Found 1 error in 1 file (checked 1 source file)
Аннотация параметра:
def something(numb: float) -> int:
return 2021 + numb
OR if you don't return anything, just use None
def person(name: str, age: int, height: float) -> None:
print(f'{name} is {age} yo and {height} feet tall.')
numb: float означает, что он должен получить плавать и -> int должен вернуть int Анкет
Некоторые продвинутые типы:
Тип списка:
Так что во многих случаях у вас есть некоторые, ну, более продвинутые или более сложные типы, которые вы хотите передать в качестве аргумента функции. Например, возможно, мы хотим иметь список, в котором есть три других списка. И все эти списки имеют int внутри них. Ну, что такое тип для этого?
[[1, 2], [3, 4], [5, 6]] x: list[list[int] = [] No no no... This doesn't work! >>> TypeError: 'type' object is not subscriptable
Для этого нам нужно импортировать тип списка из модуля Typing.
from typing import List x: List[List[int] = [[1, 2], 3, 4]] with capital L $ mypy ../this_file.py >>> Success: no issues found in 1 source file. And now it's a valid type.
Тип словаря:
То же самое для словарей, но теперь нам просто нужно указать ключ и значение.
from typing import Dict
x: Dict[str: str] = {"State": "Capital"} with capital C
Тип набора:
from typing import Set
x: Set[str] = {"a", "b", "c"} with capital C
Пользовательский тип:
Это мой векторный тип. Итак, теперь, когда я это сделал, я могу использовать Vector и где бы я ни использовал векторный список плавать там как бы заменит там.
from typing import List, Dict, Set
Vector = List[float]
def foo(v: Vector) -> Vector:
print(v)
Autocomplete would be: foo(v: List[float]) -> List[float]
Where there's Vector, List[float] will replace it.
Вы можете сохранить тип внутри переменной и использовать переменную в качестве типа.
Vectors = List[Vector] (List[List[float]])
def foo(v: Vectors) -> Vector:
pass
Autocomplete would be: foo(v: List[List[float]]) -> List[float]
Необязательный тип:
def foo(output: bool=False):
pass
Здесь все в порядке – нет ошибок. Тем не менее, автозаполнение (foo (). Ctrl+Space) не показывает тип, потому что он не обязательно. Но чтобы сделать это наиболее правильным типом, который он может быть, вам нужно указать, что это необязательно.
from typing import Optional
def foo(output: Optional[bool]=False):
pass
Любой тип:
Это очень просто. Но если вы готовы что -либо принять, то просто используйте любой тип.
from typing import Any
def foo(output: Any):
pass
Writing this is the exact same thing as just doing def foo(output)
Потому что, если вы не даете ему типа, предполагается, что это может быть что -нибудь. Это просто более явное. Вы говорите, что это предназначено для того, чтобы на самом деле принять что -либо.
Тип последовательности:
Так что во многих случаях, когда вы пишете функцию, в Python вы хотите, чтобы один из параметров был чем -то, что является последовательности, вам все равно, какой это тип последовательности. Вы просто хотите, чтобы это было последовательности.
Вам понадобится это никакого способа указать, если параметр должен быть список или кортеж . Однако, если вы используете последовательность, вы говорите, что оба кортеж и список Считайте как последовательность. И вы также можете указать, какой тип должен хранить последовательность.
from typing import Sequence
def foo(seq: Sequence[str]):
pass
foo(("a", "b", "c"))
foo(["a", "b", "c"])
foo("hello") ("Strings are immutable sequences of Unicode")
$ mypy ../this_file.py
>>> Success: no issues found in 1 source file.
But if you give an *int* or a *set*:
foo(1)
foo({1, 2, 3})
str: "anything that can be indexed"
$ mypy ../this_file.py
>>> error: Argument 1 to "foo" has incompatible type "int"; expected "Sequence"
Found 1 error in 1 file (checked 1 source file)
Тип кортежа:
Это немного отличается от списка, поэтому вам нужно указать, что будет храниться в каждой позиции в кортеже.
from typing import Tuple x: Tuple[int] = (1, 2, 3) $ mypy ../this_file.py >>> error: Incompatible types in assignment (expression has type "Tuple[int, int, inti]", variable ha type "Tuple[int] Found 1 error in 1 file (checked 1 source file) x: Tuple[int, int, int] = (1, 2, 3) y: Tuple[int, str, int] = (5, "hello", 10) $ mypy ../this_file.py >>> Success: no issues found in 1 source file.
Каллируемый тип:
Это то, что вы используете, когда хотите принять функцию в качестве параметра. Ну, правильный тип для этой функции будет способным для вызова. И затем, в квадратных скобках, определите параметры, которые будет иметь вызов, а также тип возврата.
from typing import Callable
|parameters|return|
def foo(func: Callable[[int, int], int] -> None:
func(1, 3)
This function has to have two *int* parameters and return an int
def add(x: int, y: int) -> int:
return x + y
def foo(func: Callable[[int, int], int]) -> None:
func(1, 3)
foo(add)
$ mypy ../this_file.py
>>> Success: no issues found in 1 source file.
But if we remove or add one parameter, we get an error because this function doesn't have the correct parameters inside.
Чтобы вернуть образуемую функцию:
def foo() -> Callable[[int, int], int]:
def add(x: int, y: int) -> int:
return x + y
return add
foo()
OR with lambda
# normal
def foo() -> Callable[[int, int], int]:
return lambda x, y: x + y
# variables specified
def foo() -> Callable[[int, int], int]:
func: Callable[[int, int], int] = lambda x, y: x + y
return func
foo()
Они все в порядке.
Для более продвинутого, общего типа, проверьте: (TimeStamp уже в ссылке)
Оригинал: “https://dev.to/mrslima/python-typing-kl4”