python 类型提示

本文参考自：https://www.cnblogs.com/poloyy/p/15170297.html

简单入门

python 是一门动态语言，因此在你拿到一个变量之前，你无法知道一个变量到底是什么类型的，因此当你传递一个变量给一个函数，尽管你内心知道这个参数会是某个特定的类型，但是 IDE 不知道它会是什么类型，因此它不会给你任何的代码提示。

因此，Python 3.5、3.6 新增了两个特性 PEP 484 和 PEP 526，帮助 IDE 为我们提供更智能的提示（并不会影响语言本身），简单的写法：

# 声明变量时使用
num: int = 1
str1: str
    

# 函数参数也可以使用
def test(num: int = 1):  # -> 可以指明函数的返回值类型
    return num

在定义一个变量时，直接在后面 : 类型 就可以给这个变量指定一个类型，后面可以继续写赋值语句 = 1，不写赋值语句也不会出错

指定函数返回值类型

def test(num: int = 1) -> int:  # -> 可以指明函数的返回值类型
    return num


def test(num: int = 1) -> None:  # -> 可以指明函数的返回值类型
    return None

在函数的冒号之前， -> 可以指定函数的返回值类型

常用类型

• int, long, float: 整型,长整形,浮点型;
• bool, str: 布尔型，字符串类型；
• List, Tuple, Dict, Set: 列表，元组，字典, 集合;
• Iterable,Iterator: 可迭代类型，迭代器类型；
• Generator: 生成器类型；

导入类型

前两行小写的不需要 import，后面三行都需要通过 typing 模块 import ：

from typing import Dict, List, Tuple, Set, NewType

注意：我们上面没有提到 list, dict, set, tuple ，这些类型也可以作为类型提示使用，但是不能指定它们内部的元素类型：

def test(a: list, b: dict):
    pass

List，Set

List，Set 类型提示，只可以给它们的内部元素指定一种类型，否则会报错：

a: List[int] = []  # List[类型] ，只能指定一种类型

a.append(1)
a.append('2')  # 尽管指定了 int 类型，但是可以添加 str 类型的元素。

# ---------------  同理： Set[] ----------------------------

b: Set[int] = {1}

我们之前说过，类型提示只是进行提示用的，并不会真的校验我们给它的赋值。

List，Set后面跟的是 [Type]

Tuple

Tuple 可以指定多种类型。

c: Tuple[int, str] = (1, '2')

如果想给 Tuple 指定一种类型，但是你 Tuple 的长度大于1，需要加上 ...

c: Tuple[int, ...] = (1, 2, 3, 4)

Dict

Dict 可以指定两种类型：分别代表键值对的类型：

d: Dict[str, int] = {'1': 1}

嵌套类型

各个类型之间也可以嵌套：

e: Dict[str, List[int]] = {'1': [1,2]}

类型的重命名

其实类型的重命名，应该属于python的用法，不能作为类型提示的语法：

My_type = Dict[str, List[int]]  # 给类型重命名
e:  My_type = {'1': [1,2]}

自定义类型：NewType

和重命名有点类似，但是自定义类型相当于创建了某个类型的子类

UserId = NewType('UserId', int)  # 创建一个新类型(类型名字，类型)

num: UserId = UserId('1')
print(num, type(num))  # 1 <class 'str'>

可以看出，真实的数据类型还是 str , 说明了类型提示并不会对真实的代码产生影响，只是IDE类型提示时会显示该填入某种类型。

Optional

这个类型代表的是当前参数是一个可选参数，只能接受一种类型：

from typing import Optional

def test(x: Optional[int]=1):
    return x

Callable

Callable[[参数1, 参数2, ...], return] 可以用来提示一个可调用函数：

from typing import Callable

def test(a: int, b: int) -> int:  # 第一个函数，接受两个 int 参数，返回 int
    return a+b

def test2(func: Callable[[int, int], int]):  # 第二个函数，类型是可调用对象：这个可调用对象的参数是 2 个int, 返回值是一个 int
    return func(1, 2)

test2(test)

Callable 接受两个值，第一个值是包含可调用对象的所有参数类型的列表。第二个值是可调用对象的返回值类型。

多种类型

TypeVar

TypeVar 可以指定多种类型，或者任意类型

任意类型

from typing import TypeVar, List

T = TypeVar("T")  # 代表了任意类型

x: T = 2
y: T = 'abc'

指定类型

from typing import TypeVar, List


My = TypeVar('My', int, str, List[int])  # 自定义一个类型，可以是 int 或 str 或 List[int]

xx: My = 'ss'
yy: My = [1]

注意这里的 TypeVar() ，后面用的是 () ，不是 []

Union

Union 类似于 TypeVar，也可以指定多种类型。

from typing import TypeVar, List, Union

x:Union[int, str] = '1'  # 可以是 int 或 str 类型

Union 是不分顺序的，并且如果有多个重复的类型，会自动去重：

print(
    Union[int, str, int, Union[int, List[int]]] == Union[List[int], int, str]
)

# True

这个例子中，重复的 int 会自动去重，并且里面类型的顺序也不重要。等式前面的Union中还嵌套了一个 Union[int, List[int]] ，也会被提取出来