Ранее мы изучили основные типы Type Hints, int, str и простые составные типы list, tuple, dict. Далее узнайте о различиях между модулями набора текста List, Dict и Tuple.

Список модулей ввода

В следующих примерах и a, и b объявляют тип списка.

• член но intтипа
• Член b но стртип.

a: list = [1, 2, 3, 4, 5, 6, 7]  
b: list = ["a", "b", "c", "d", "e", "f", "g"]  

print(a)  
print(b)

Чтобы более точно объявить, что члены списка имеют тип int или str, вам необходимо использовать модуль типизации.

from typing import List  

a: List[int] = [1, 2, 3, 4, 5, 6, 7]  
b: List[str] = ["a", "b", "c", "d", "e", "f", "g"]  

print(a)  
print(b)

Разница между списком и списком:

• список может указывать только тип,Невозможно объявить, какие члены
• List Вы можете объявить, какие члены

Пример в функции

from typing import List  


def demo_list(a: List[str], index: int) -> str:  
    res = a[index]  
    return res  


r = demo_list(['aa', 'bb', 'cc'], 1)  
print(r)

Когда нам нужно получить значение из списка, а затем вызвать соответствующий метод, редактор автоматически распознает метод объекта str.

Например, список чисел или строк можно объявить как:

def fun_a(a: List[int or str]) -> List:  
    return a  


r = fun_a(['a', ['aa']])

Вы также можете вкладывать объявления

x: List[List[int]]

Последовательность

Итерируемые объекты (Iterable) относятся к объектам, которые можно зациклить с помощью for..in. Как мы обычно знаем: list, str, tuple, dict и т. д. являются итерируемыми объектами. Последовательность — это последовательность, встроенные типы последовательностей: список, строка, кортеж, байты. Обратите внимание, что dict - это не пара ключ-значение, здесь нет значения индекса, вы можете искать только на основе того, что можете. Иногда нас не волнует, является ли переданный объект списком или кортежем, потому что нам может потребоваться просто перебрать объект.

from typing import Sequence  


def demo_seq(s: Sequence, by: str) -> str:  
    return by.join(s)  


r1 = demo_seq('hello', '_')  
print(r1)  

r2 = demo_seq(('a', 'b', 'c'), '_')  
print(r2)

Вы также можете указать, что член последовательности должен быть строкой.

Тип слова

dict — это формат пары ключ-значение, и тип dict в нижнем регистре не может точно объявить конкретные типы ключей и значений. Например, я хочу объявить, что ключ — str, а значение — int.

from typing import Dict  


def demo_dict(d: Dict[str, int]) -> Dict:  
    d.update({"aa": 22})  
    return d  


r = demo_dict({"x": 1, "y": 2})  
print(r)

Сопоставление и MutableMapping

Dict, словарь, — это общий тип dict, Mapping — это универсальный тип Collections.abc.Mapping. Согласно официальной документации, для аннотирования возвращаемых типов рекомендуется использовать Dict, а для аннотирования параметров — Mapping. Все они используются одинаково, после чего следует квадратная скобка, в которой объявляются имя ключа и тип значения ключа соответственно, например: ``

from typing import Mapping, Dict  


def size(rect: Mapping[str, int]) -> Dict[str, int]:  
    return {'width': rect['width'] + 100, 'height': rect['width'] + 100}

Здесь Dict используется в качестве аннотации типа возвращаемого значения, а Mapping используется в качестве аннотации типа параметра. MutableMapping — это подкласс объекта Mapping, и MutableMapping часто используется вместо Mapping во многих библиотеках.

Любой любой тип

Если значение имеет любой тип, вы можете использовать Any

from typing import Dict, Any  


def demo_dict(d: Dict[str, Any]) -> Dict:  
    d.update({"aa": 22})  
    return d  


r = demo_dict({"x": 1, "y": "A", "z": ["a", "b"]})  
print(r)

Tuple

Тип пустого кортежа можно записать как Tuple[()]

def fun_a(a: Tuple[()]) -> Tuple:  
    return a  


r = fun_a(())

В кортеже только один член

def fun_a(a: Tuple[str]) -> Tuple:  
    return a  


r = fun_a(('aa', ))  
print(r)

Тип кортежа,Tuple[X, Y] Аннотировал тип кортежа, первый элемент которого имеет тип X А тип второго элемента — Y.

def fun_a(a: Tuple[str, int]) -> Tuple:  
    return a  


r = fun_a(('aa', 12))  
print(r)

Tuple[int, float, str] Представляет тройку, состоящую из целого числа, числа с плавающей запятой и строки.

def fun_a(a: Tuple[int, float, str]) -> Tuple:  
    return a  


r = fun_a((11, 12.1, "aa"))  
print(r)

Чтобы выразить кортеж переменной длины из одних и тех же элементов,Используйте литералы с многоточием,нравитьсяTuple[int, ...]。

def fun_a(a: Tuple[int, ...]) -> Tuple:  
    return a  


r = fun_a((11, 12, 13, 14))  
print(r)

одинокий Tuple Эквивалентно Tuple[Any, ...],а потом Эквивалентно tuple

Set、AbstractSet

Set, коллекция — это универсальный тип набора; AbstractSet — это универсальный тип коллекции.abc.Set. Согласно официальной документации, Set рекомендуется для аннотирования возвращаемых типов, а AbstractSet — для аннотирования параметров. Все они используются одинаково, за ними следует квадратная скобка, которая объявляет тип элементов в коллекции, например:

from typing import Set, AbstractSet  


def describe(s: AbstractSet[int]) -> Set[int]:  
    return set(s)

Здесь Set используется в качестве аннотации типа возвращаемого значения, а AbstractSet используется в качестве аннотации типа параметра.