如何更好的使用 Python 的类型提示?

使用动态语言一时爽，代码重构火葬场。相信你一定听过这句话，和单元测试一样，虽然写代码的时候花费你少量的时间，但是从长远来看，这是非常值得的。本文分享如何更好的理解和使用 Python 的类型提示。

1、类型提示仅在语法层面有效

类型提示（自 PEP 3107 开始引入）用于向变量、参数、函数参数以及它们的返回值、类属性和方法添加类型。

Python 的变量类型是动态的，可以在运行时修改，为代码添加类型提示，仅在语法层面支持，对代码的运行没有任何影响，Python 解释器在运行代码的时候会忽略类型提示。

因此类型提示一个直观的作用就是提升代码的可读性，方便调用者传入/传出恰当类型的参数，便于代码重构。

Python 内置的基本类型可以直接用于类型提示：

变量的类型提示示例：

a: int = 3
b: float = 2.4
c: bool = True
d: list = ["A", "B", "C"]
e: dict = {"x": "y"}
f: set = {"a", "b", "c"}
g: tuple = ("name", "age", "job")

函数的类型提示：

def add_numbers(x: type_x, y: type_y, z: type_z= 100) -> type_return:
    return x + y + z

这里的 type_x , type_y , type_z , type_return 可以是内置的基本类型，也可以是自定义类型。

类的类型提示：

class Person:
    first_name: str = "John"
    last_name: str = "Does"
    age: int = 31

2、用 mypy 检查类型提示

假如有这样一段代码：

# script.py
x: int = 2
# ...
x = 3.5

用 Python 解释器执行是不会有任何错误的：

借助于 mypy 就可以，先 pip install mypy 安装一下，然后 mypy script.py 即可：

更多 mypy 相关可以参考前文mypy 这个工具，让Python的类型提示变得非常实用。

3、类型提示的好处

如果解释器没有强制执行类型提示，为什么还要编写类型提示呢？确实，类型提示不会改变代码的运行方式：Python 本质上是动态类型的，这一点不太可能会改变。但是，从开发人员经验的角度来看，类型提示有很多好处。

1、使用类型提示，尤其是在函数中，通过类型提示来明确参数类型和所产生结果的类型，非常便于阅读和理解。

2、类型提示消除了认知开销，并使代码更易于阅读和调试。考虑到输入和输出的类型，你可以轻松推断对象以及它们如何调用。

3、类型提示可改善代码编辑体验。IDE 可以依靠类型检测来静态分析你的代码并帮助检测潜在的错误（例如，传递错误类型的参数、调用错误的方法等）。另外，还可以根据类型提示为每个变量提供自动补全。

IDE 的类型检查

IDE 的类型检查

IDE 类型检查后的自动补全

4、List 用法

假如你需要列表 list 内部是 float 的类型提示，这样做是不行的：

def my_dummy_function(l: list[float]):
   return sum(l)

标准库 typing 考虑到了这个问题，你可以这样：

from typing import List

def my_dummy_function(vector: List[float]):
   return sum(vector)

5、Dict 用法

假如要提示这样的类型：

my_dict = {"name": "Somenzz", "job": "engineer"}

借助于 Dict，你可以这样定义类型：

from typing import Dict
my_dict_type = Dict[str, str]
my_dict: my_dict_type = {"name": "Somenzz", "job": "engineer"}

6、TypedDict 用法

假如你需要提示这样的类型，那该怎么办？

d = {"name": "Somenzz", "interests": ["chess", "tennis"]}

借助于 TypedDict ，你可以这样：

TypedDict

7、Union 用法

从 Python 3.10 开始，Union 被替换为 | 这意味着 Union[X, Y] 现在等价于 X | Y。

Union[X, Y]（或 X | Y）表示 X 或 Y。

假设你的函数需要从缓存目录中读取文件并加载 Torch 模型。此缓存目录位置可以是字符串值（例如 /home/cache ），也可以是 Pathlib 库的 Path 对象，在这种情况下，代码如下：

def load_model(filename: str, cache_folder: Union[str, Path]):
    if isinstance(cache_folder, Path):
        cache_folder = str(cache_folder)

    model_path = os.join(filename, cache_folder)
    model = torch.load(model_path)
    return model

8、Callable 用法

当你需要传入一个函数作为参数的时候，这个参数的类型提示可以为 Callable。

from typing import Callable

def sum_numbers(x: int, y: int) -> int:
    return x + y

def foo(x: int, y: int, func: Callable) -> int:
    output = func(x, y)
    return output

foo(1, 2, sum_numbers)

你还可以给这样的函数参数指定参数列表，真的很强大：

语法：

Callable[[input_type_1, ...], return_type]

示例：

def foo(x: int, y: int, func: Callable[[int, int], int]) -> int:
    output = func(x, y)
    return output

9、Any 用法

当你传入的参数可以为任何类型的时候，就可以使用 Any

def bar(input: Any):
    ...

10、Optional 用法

如果你的函数使用可选参数，具有默认值，那么你可以使用类型模块中的 Optional 类型。

from typing import Optional

def foo(format_layout: Optional[bool] = True):
    ...

11、Sequence 用法

Sequence 类型的对象是可以被索引的任何东西：列表、元组、字符串、对象列表、元组列表的元组等。

from typing import Sequence

def print_sequence_elements(sequence: Sequence[str]):
    for i, s in enumerate(s):
        print(f"item {i}: {s}"

12、Tuple 用法

Tuple 类型的工作方式与 List 类型略有不同，Tuple 需要指定每一个位置的类型：

from typing import Tuple
t: Tuple[int, int, int] = (1, 2, 3)

如果你不关心元组中每个元素的类型，你可以继续使用内置类型 tuple。

t: tuple = (1, 2, 3, ["cat", "dog"], {"name": "John"})

最后的话

类型提示在代码之上带来了额外的抽象层：它们有助于记录代码，澄清关于输入/输出的假设，并防止在顶部执行静态代码分析 (mypy) 时出现的隐蔽和错误。接下来做的事情就是在你的项目中使用类型提示，从长期看，这是你最佳的选择。如果有帮助，欢迎在看、关注、讨论。