在Python语言发展的过程中，PEP提案发挥了巨大的作用，如PEP 3107 和 PEP 484提案，分别给我们带来了函数注解（Function Annotations）和类型提示（Type Hints）的功能.

PEP 3107：定义了函数注解的语法，允许为函数的参数和返回值添加元数据注解.

PEP 484：按照PEP 3107函数注解的语法，从Python语法层面全面支持类型提示，类型提示可以是内置类型、内置类、抽象基类、types模块中提供的类型和开发人员自定义的类.

另外 PEP 526, PEP 544, PEP 586, PEP 589, PEP 591 这些东西对 PEP 3107 和 PEP 484 进行了补充，比如添加了变量注释，字面量注释这些东西.

需要注意的是，类型提示仅有提示的作用，这里的提示是指用户阅读Python代码的时候的提示，仅在语法层面支持， 对代码的运行没有任何影响，Python 解释器在运行代码的时候会忽略类型提示 ，也就是说，Python的类型提示仅是为了提升代码可读性，一定程度上缓解"动态语言一时爽，代码重构火葬场"的尴尬.

下面将函数注解和类型提示，统称为类型注解.

类型注解优点

1、可以使Python拥有部分静态语言的特性，利用类型注解可以实现一种类似类型声明的效果，提升代码的可读性及后续的可维护性.

2、类型注解可以让IDE（如pycharm）像静态语言那样分析我们的代码，及时给我们相应的提示，如下图对比:

VS

3、多多使用类型注解，不仅可以让Python拥有强类型语言的严谨，还能保持Python作为动态类型语言的灵活性.

普通变量类型注解

在声明变量时，变量的后面可以加一个冒号，后面再写上变量的类型，如 int、list 等等，以此实现类型注解.

                        
                          a: int = 22
b: str = "name"
c: float = 55.5
d: bool = True
e: list = [1, 2, 3]
f: set = {1, 2, 3}
g: dict = {"name": "ming", "age": 22}
h: tuple = (1, 2, 3)
i: bytes = b'world'
j: bytearray = bytearray("world")

                        
                      

函数参数及返回值类型

函数参数的类型声明就是冒号+类型即可，和普通变量类型声明没区别.

函数返回值的类型声明是用箭头指向具体的类型，如果是返回值有多个，使用元组包裹即可（因为函数的多个返回值就是以元组形式返回的），需要注意的是，箭头左右两边都要留有空格.

                        
                          def handler(a: int, b: int) -> int:
    return a + b


def handler2(a: int, b: int, *args: int) -> int:
    return a + b + sum(args)


def handler3(a: int, b: int, *args: int, **kwargs: int) -> (int, str):
    return a + b + sum(args) + sum(kwargs.values()), ""

                        
                      

typing模块

typing模块的加入不会影响程序的运行，也不会报正式的错误，pycharm支持检测基于typing注解的错误，不符合规定类型注解时会出现黄色警告，但不会影响程序运行.

容器类型 & 复合类型

列表、字典、元组等包含元素的复合类型，用简单的 list，dict，tuple 不能够明确说明内部元素的具体类型.

此外，Python本身就是动态类型的语言，如果我们强制使用某种类型，一定程度上会丧失Python作为动态语言的优势，因此 typing 模块提供了一种复合类型注解的语法，即一个参数即可以是类型A，也可以是类型B或者类型C 。

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

# 字典
d: Dict[str, int] = {"a": 1, "b": 2}
d1: Dict[str, int or str] = {"a": 1, "b": "2"}  	# 使用or表示支持多个类型

# 列表
l: List[int] = [1, 2, 3]
l1: List[int or str] = [1, 2, "3"]

# 元组
t: Tuple[str, int] = ("a", 1)		# 代表了构成元组的第一个元素是 str 类型，第二个元素是 int 类型
t1: Tuple[str, ...] = ("a", "b", "c", "d", "e", "f", "g")		# 代表接受多个 str 类型的元素
t2: Tuple[str or int, ...] = ("a", "b", 2)		# 代表接受多个 str 或 int 类型的元素

# 集合
s: Set[int] = {1, 2, 3, 4}
s1: Set[Union[int, str, float]] = {1, "2", 3.333, 4}	# Union 同 or

                        
                      

TypedDict

TypedDict声明一个字典类型，该类型期望它的所有实例都有一组固定的keys，其中每个key都与对应类型的值关联.

                        
                          from typing import TypedDict


class Student(TypedDict):
    name: str
    age: int
    height: float


s1: Student = {
    "name": "xiao ming",
    "age": 22,
    "height": 55.5
}

s2: Student = {
    "name": "xiao hong",
    "age": 21,
}

                        
                      

可以看出，pycharm也会警告我们字典实例中缺失的key.

同时，在我们生成字典实例的时候，pycharm也会给我们key的提示.

类型别名

类型别名是通过将类型分配给别名来定义的，类型别名可用于简化复杂类型提示.

                        
                          from typing import Union

Number = Union[int, float]

def process(v: Number) -> Number:
    return v

x: Number = 2
y: Number = 2.2
process(x)
process(22)		# 类型检查成功，类型别名和原始类型是等价的

                        
                      

NewType

使用NewType辅助类来创建不同的类型 。

                        
                          from typing import NewType

Number = NewType("Number", int)

def process(v: Number) -> Number:
    return v

x: Number = Number(22)
process(x)
process(22)     # 类型检查异常：Expected type 'Number', got 'int' instead 
# 原因就是NewType创建的是原始类型的“子类型”

                        
                      

因此，类型别名 和 NewType 具体使用哪个，要视情况而定，不知道使用哪个，可以先使用类型别名.

NoReturn

当一个方法没有返回结果时，为了注解它的返回类型，我们可以将其注解为 NoReturn.

因为Python 的函数运行结束时隐式返回 None ，这和真正的无返回值是有区别的.

                        
                          from typing import NoReturn

def process() -> NoReturn:
    pass

                        
                      

可选类型 ：Optional

使用 Optional[] 表示可能为 None 的值 。

                        
                          from typing import Optional

def handler(x: int) -> Optional[int]:
    if x % 2 == 0:
        return x

                        
                      

可调用对象：Callable

若一个变量类型是可调用函数，则可以用 Callable[[Arg1Type, Arg2Type], ReturnType] 实现类型提示 。

                        
                          from typing import Optional, Callable

def handler(x: int) -> Optional[int]:
    if x % 2 == 0:
        return x

def handler2(func: Callable[[int], Optional[int]]):
    pass

handler2(handler)

                        
                      

字面量：Literal

指示相应的变量或函数参数只接收与提供的字面量(或多个字面量之一)等效的值，可以理解为规定了某个参数或变量的所有枚举值.

                        
                          from typing import Literal, NoReturn

Mode = Literal["r", "w"]


def process(mode: Mode) -> NoReturn:
    pass


process("s")

                        
                      

可以看出，pycharm检查出了我们输入的值并不符合字面量规定的值，进而出现了黄色警告.

Any

是一种特殊的类型，每种类型都视为与Any兼容，同样，Any也与所有类型兼容。可以对Any类型的值执行任何操作或方法调用，并将其分配给任何变量。将Any类型的值分配给更精确的类型(more precise type)时，不会执行类型检查，所有没有返回类型或参数类型的函数都将隐式地默认使用Any.

使用Any，说明值是动态类型.

把所有的类型都注解为 Any 将毫无意义，因此 Any 应当尽量少使用 。

                        
                          from typing import Any

def foo() -> Any:
    pass

                        
                      

抽象基类

                        
                          # 在某些情况下，我们可能并不需要严格区分一个变量或参数到底是列表 list 类型还是元组 tuple 类型
# 可以使用一个更为泛化的类型，叫做 Sequence，其用法类似于 List
class typing.Sequence(Reversible[T_co], Collection[T_co])


# collections.abc.Iterator的泛型版本
# 注释函数参数中的迭代类型时，推荐使用的抽象集合类型
class typing.Iterable(Generic[T_co])

def print_iterable(x: Iterable):
    for i in x:
        print(i)



# collections.abc.Mapping的泛型(generic)版本
# 注释函数参数中的Key-Value类型时，推荐使用的抽象集合类型
class typing.Mapping(Sized, Collection[KT], Generic[VT_co])

                        
                      

泛型：TypeVar

先抛出问题:

假设有一个函数，要求它既能够处理字符串，又能够处理数字。那么你可能很自然地想到了 Union ，如下:

                        
                          from typing import Union

AddValue = Union[int, str]


def add(a: AddValue, b: AddValue) -> AddValue:
    return a + b


if __name__ == "__main__":
    print(add(1, 2))        # 类型检查通过，输出 3
    print(add("1", "2"))    # 类型检查通过，输出 12
    print(add("1", 2))      # 类型检查通过，报错 TypeError: can only concatenate str (not "int") to str

                        
                      

在类型检查通过的情况下，我们完成并运行了这段代码，可是代码却报错了！ 。

原因就是我们的初衷是数字和数字相加实现求和，字符串和字符串相加实现拼接，没有考虑到字符串与数字混用的问题，从而引发错误.

根据以上问题，我们可以引入泛型来解决这个问题:

                        
                          from typing import TypeVar

AddT = TypeVar("AddT", int, str)


def add(a: AddT, b: AddT) -> AddT:
    return a + b


if __name__ == "__main__":
    print(add(1, 2))		# 类型检查通过，输出 3
    print(add("1", "2"))	# 类型检查通过，输出 12
    print(add("1", 2))		# 类型检查失败，pycharm告警 Expected type 'str' (matched generic type 'AddT'), got 'int' instead

                        
                      

""" 通过告警，我们提前发现了混用类型的问题，避免了程序运行时发生异常的可能。 """ 。

泛型很巧妙地 对类型进行了参数化 ，同时又保留了函数处理不同类型时的灵活性.

引用

1、 Python 标准库 typing 类型注解标注 。

2、 Python类型注解，你需要知道的都在这里了 。

最后此篇关于Python类型注解的文章就讲到这里了,如果你想了解更多关于Python类型注解的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。