Python 学会typing的类型注解面向泛型编程

---

---

文章开篇

Python的魅力，犹如星河璀璨，无尽无边；人生苦短、我用Python！

---

typing模块简介

Python 3.5前，为弱类型语言，类型不显式声明，运行时可根据上下文推断变量或参数类型；
Python 3.5后，引入的typing模块支持Python的静态类型注解，可显式注明变量、函数参数和返回值的类型；
在现代编程中，类型提示成为了提高代码可读性、可维护性和安全性的重要工具之一；

---

typing模块作用

1.类型注释：

• typing模块为开发人员提供了多种类型注释工具。
• 类型注释可以用于变量、函数、类、方法、属性等数据结构，帮助清晰地表示数据类型。
• 类型注释有助于其他人更好地理解代码。

2.类型检查：

• typing模块支持静态类型检查。
• 这种检查在代码运行之前进行，有助于提前发现和修复类型相关的错误。
• 通过类型检查，可以提高代码质量和减少运行时的错误。

3.数据容器：

• typing模块提供了多种数据容器类型，如List、Tuple、Dict和Set。
• 这些容器帮助开发人员更有效地操作数据结构，并提供准确的标注和注释方式。

4.泛型编程支持：

• typing模块提供了定义泛型类和函数的快捷方式。
• 这为泛型编程提供了强大的支持，使开发人员能够更轻松地思考和解决泛型问题。

5.类型别名：

• typing模块允许开发人员创建自己的类型别名。
• 类型别名可以提高代码的可读性和可维护性，使类型字典更加简洁，并确保与代码实际使用的类型一致。

6.增强可读性：

• 使用typing模块提供的类型注释可以增强代码的可读性和可理解性。
• 这有助于开发人员更好地阅读和理解代码，提高代码的可维护性。

总的来说，typing模块在Python中提供了强大的类型支持，帮助开发人员提高代码质量、减少错误、增强可读性，并为泛型编程提供了便利。

---

基本类型注解

python内置的基本类型，可以直接用作类型注解，不需要依赖typing模块

类型	释义	示例
int	整数	var: int = 10086
float	浮点数	var: float = 99.5
str	字符串	var: str = “你好”
bool	布尔值	var: bool = True
bytes	字节串	var: bytes = b"Hello, World!"
bytearray	可变字节串	var: bytearray = bytearray(b"Mutable bytes")
list	列表	var: list = [1, 3, 5, 7, 9]
tuple	元祖	var: tuple = (1, 3, 5, 7, 9)
set	集合	var: set = {1, 3, 5, 7, 9}
dict	字典	var: dict = {“name”: “zhangsan”}

另需要注意，类型注解仅仅只是标注和释义作用，依旧可以存储与此不匹配的数据

var: int = 10086
print(type(var), var)   # <class 'int'> 10086

var: str = 10086
print(type(var), var)   # <class 'int'> 10086

虽说，类型注解没有强制要求存储数据类型，但是在使用时就发生了变化

1.不使用类型注解

2.使用类型注解

---

泛型

类型	释义
List[T]	指定元素类型为T的列表
Tuple[T]	指定元素类型为T的元祖
Set[T]	指定元素类型为T的集合
Dict[ KT, VT]	指定键类型为KT，值类型为VT的字典

---

1.List

List是list的泛型，其后紧跟一个方括号，里面代表了构成这个列表的元素类型；
如果List[int]代表了构成列表的元素是int类型（不强制存储类型匹配的数据）；

from typing import List

# 声明一个整数列表
int_list: List[int] = [1, 2, 3]

# 声明一个字符串列表
str_list: List[str] = ["hello", "world"]


def sort_numbers(numbers: List[int]) -> List[int]:
    """
    接收一个整数列表，并返回按照升序排列后的列表。
    """
    return sorted(numbers)


print(sort_numbers([3, 5, 9, 7, 1]))  # [1, 3, 5, 7, 9]

---

2.Tuple

Tuple是tuple的泛型，其后紧跟一个方括号，方括号中按照顺序声明了构成本元组的元素类型；
如Tuple[int, str]代表了构成元组的第一个元素是int类型，第二个元素是str类型；

from typing import Tuple

# 声明一个整数和字符串组成的元组
mixed_tuple: Tuple[int, str] = (42, "answer")

# 声明一个由两个整数组成的元组
int_tuple: Tuple[int, int] = (1, 2)

---

3.Set

Set是set的泛型；其后跟一个中括号，里面代表了构成这个集合的元素类型；

from typing import Set

# 声明一个整数集合
int_set: Set[int] = {1, 2, 3, 4}

# 声明一个字符串集合
str_set: Set[str] = {"apple", "banana", "cherry"}

---

4.Dict

Dict是dict的泛型；其后跟一个中括号，里面代表了构成这个字典的键名、键值的类型；

from typing import Dict

# 声明一个字符串到整数的字典
string_int_dict: Dict[str, int] = {"one": 1, "two": 2}

# 声明一个整数到字符串的字典
int_string_dict: Dict[int, str] = {1: "one", 2: "two"}


def user_info(name: str, age: int) -> Dict[str, Union[str, int]]:
    """
    接受用户名和年龄，返回一个包含用户名和年龄的字典。
    """
    user = {}
    user['name'] = name
    user['age'] = age
    return user

print(user_info("张三", 18))  # {'name': '张三', 'age': 18}

---

特殊类型

类型	释义
Any	任何类型
Union[T1,T2]	T1或T2类型
Optional[T]	T类型或None
Callable[[Arg1Type, Arg2Type, …], ReturnType]	表示一个可调用的对象，接受指定类型的参数并返回指定类型的值

1.Any

Any是一个特殊的类型，表示“不确定或任意类型”的类型；

from typing import Any

# 使用Any类型注解变量
def process_data(data: Any) -> None:
    # 这里可以处理任何类型的data，因为类型注解是Any
    print(data)

# 调用函数并传入不同类型的参数
process_data(42)          # 传入整数
process_data("hello")     # 传入字符串
process_data([1, 2, 3])   # 传入列表

2. Union

Union联合类型，Union[X, Y]代表要么是X类型，要么是Y类型。

from typing import Union

# 使用Union类型注解变量
def process_data(data: Union[int, str]) -> None:
    # 这里只可以期待int类型或str类型的参数值
    print(data)

# 调用函数并传入不同类型的参数
process_data(42)          # 传入整数
process_data("hello")     # 传入字符串

process_data([1, 2, 3])   # 传入列表（再次强调，类型注解不强制要求必须与此匹配）
# 与注解类型不匹配依旧可以存储数据或执行函数，但IDE会给出“非期待类型”的警告

2. Optional

Optional，意思是说这个参数可以为空或已经声明的类型，例如Optional[X]等价于Union[X, None]；
但值得注意的是，这个并不等价于可选参数，当它作为参数类型注解的时候，不代表这个参数可以不传递了，而是说这个参数可以传为None；

from typing import Optional

# 使用Optional类型注解变量
def hello(name: Optional[str]) -> None:
    # 这里只可以期待str类型的参数值或者None值
    if name is not None:
        print(name, "你好呀！")
    else:
        print("我还不知道你的名字呢～")


# 调用函数并传入不同类型的参数
hello("张三")    # 传入字符串
hello(None)     # None值
hello(10086)    # 数值类型，不在期待类型范围内

4. Callable

Callable是一个泛型，用于表示可调用的对象，允许指定一个函数或方法的参数类型和返回类型；

from typing import Callable


# 定义一个函数，它接受一个整数参数并返回一个字符串
def greet(name: str) -> str:
    return f"你好, {name}!"


# 现在我们可以使用这个类型来注解变量，表示它们应该是指向符合这个签名的函数
def register_greeting(name: str, func: Callable[[str], str]) -> None:
    # 这个函数可以接收任何符合GreetingFunction类型的函数作为参数
    print(func(name))


# 使用register_greeting函数，并传入greet函数作为参数
register_greeting("张三", greet)  # 你好, 张三!


# 尝试传入一个不符合签名的函数将会导致类型错误（如果进行了类型检查）
def incorrect_greet(age: int) -> str:
    return f"我今年{age}岁了..."


register_greeting(18, incorrect_greet)  # 这将引发IDE的非期待类型范围的警告，因为incorrect_greet的参数类型不匹配

---

类型别名

类型别名是一种自定义命名方式，用于简化复杂或常用类型的表示，从而提高代码的可读性。

from typing import List, Union, Dict

Vector = List[Dict[str, Union[str, int]]]

# 类型注解过于长和繁杂
# def print_list(list_data: List[Dict[str, Union[str, int]]]):
def print_list(list_data: Vector):
    """期待一个列表嵌套字典的数据结构，其中字典的value可以是str或int类型"""
    print(list_data)


print_list(10086)    # IDE给出非期待类型范围的警告提示，应为类型 'List[List[Union[str, int]]]'，但实际为 'List[int]'
print_list("hello")  # IDE给出非期待类型范围的警告提示，应为类型 'List[List[Union[str, int]]]'，但实际为 'List[int]'

print([{"name": "zhangsan", "age": 18}])  # [{'name': 'zhangsan', 'age': 18}]

1.TypeVar

TypeVar用于表示一个泛型类型变量，通常用于定义泛型类、泛型函数或泛型方法的类型注解；
它是一个占位符，在定义泛型类或函数时表示一个尚未指定的类型；
当泛型类或函数被实际使用时，这个占位符会被具体的类型所替换，从而实现类型安全和灵活性；

from typing import TypeVar, List

# 定义一个TypeVar，名为T，表示任意类型
T = TypeVar('T')

# 定义一个泛型函数，接受一个T类型的参数，返回一个T类型的值
def identity_function(x: T) -> T:
    return x

# 定义一个泛型类，接受一个T类型的参数
class GenericBox(object):
    def __init__(self, value: T):
        self.value = value

# 使用泛型类和函数
box = GenericBox[int](42)  # T被替换为int
print(identity_function[str]("hello"))  # T被替换为str

2. NewType

NewType用于创建一个新的类型，它在运行时与现有类型相同，但在类型检查时被视为独立类型，有助于区分表面上相似但含义不同的类型，减少错误，并提高代码的可读性和可维护性。

from typing import NewType

# 使用NewType创建一个新的类型，它本质上与int相同，但在类型检查时被视为不同的类型
UserId = NewType('UserId', int)

# 现在UserId和int在运行时是兼容的，但在类型检查时是不同的
def get_user_by_id(user_id: UserId) -> str:
    # ...
    return "User Info"

# 尝试传入一个int类型的值将会导致类型错误
# get_user_by_id(42)  # TypeError: Argument 1 to "get_user_by_id" has incompatible type "int"; expected "UserId"

# 需要使用UserId来包装int值
user_id = UserId(42)
print(get_user_by_id(user_id))  # 输出: "User Info"

---

更多技巧

1.NoReturn和None

当一个方法没有返回结果时，为了注解它的返回类型，可以使用NoReturn或None；

from typing import NoReturn

def hello1() -> NoReturn:
    print("hello 1")

def hello2() -> None:
    print("hello 2")


print(hello1()) # None
print(hello2()) # None

2.Sequence

Sequence 是 collections.abc.Sequence 的泛型，可以用于泛化表示列表或元组等序列类型，无需严格区分。其用法类似于 List，适用于需要处理不同类型序列的情况。

from typing import Sequence

def process_sequence(data: Sequence[int]) -> None:
    """
    处理一个整数序列，并打印出每个元素。
    
    :param data: 一个整数序列（列表、元组等）
    :return: 无返回值
    """
    for item in data:
        print(item)

# 使用示例
my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3)

# 调用函数，传入列表
process_sequence(my_list)
# 输出:
# 1
# 2
# 3
# 4
# 5

# 调用函数，传入元组
process_sequence(my_tuple)
# 输出:
# 1
# 2
# 3

3. Generator

Generator生成器对象的泛型，允许为生成器函数的返回类型、发送类型以及返回值的类型提供注解；
它的声明比较特殊，其后的中括号紧跟着三个参数；

• YieldType：yield关键字后面紧跟的变量类型；
• SendType：yield返回的结果类型；
• ReturnType：最后生成器return的结果类型；

通常生成器只需要yieldType参数，不需要SendType和ReturnType可以将其设置为空；

from typing import Generator, Iterable, TypeVar

# 定义一个泛型变量，表示生成器返回的元素类型
T = TypeVar('T')

# 定义一个生成器函数，它接受一个可迭代对象，并逐个产生其元素
def generate_elements(iterable: Iterable[T]) -> Generator[T, None, None]:
    for item in iterable:
        yield item

# 使用示例
# 创建一个整数生成器
int_generator: Generator[int, None, None] = generate_elements([1, 2, 3, 4, 5])

# 使用生成器
for number in int_generator:
    print(number)
# 输出:
# 1
# 2
# 3
# 4
# 5

# 创建一个字符串生成器
str_generator: Generator[str, None, None] = generate_elements(["hello", "world"])

# 使用生成器
for word in str_generator:
    print(word)
# 输出:
# hello
# world

---

总结

Python的typing模块是一个强大的工具，用于在代码中添加类型提示，提高代码质量和可维护性；
开发者可以更明确地定义函数和类的参数及返回值类型，使得代码更易于理解和维护；
学习和使用typing模块能够编写更健壮、更易读的Python代码，提升开发效率和代码质量。