Python typing模块

介绍

在编写Python代码时，我们经常需要考虑变量的类型和函数的参数类型注解。为了提供更好的类型检查和IDE支持，Python提供了typing模块。typing模块是Python 3.5及以上版本的一部分，它提供了用于类型注解的类和函数，使我们能够更清晰地表达代码的意图和约束。

在本文中，我们将详细介绍typing模块的常用功能和用法，包括基本数据类型、容器类型、函数签名和泛型等。

基本数据类型

typing模块提供了一些基本数据类型，用于标注常用的数据类型，包括整数、浮点数、布尔值、字符串以及None等。

整数

使用typing模块中的int类型可以表示整数。

from typing import List, int

def sum_of_list(numbers: List[int]) -> int:
    return sum(numbers)

numbers = [1, 2, 3, 4, 5]
print(sum_of_list(numbers))

运行结果：

在上述代码中，我们使用List[int]来表示一个整数列表，然后使用int来表明函数返回一个整数。

浮点数

使用typing模块中的float类型可以表示浮点数。

from typing import List, float

def average(numbers: List[float]) -> float:
    return sum(numbers) / len(numbers)

numbers = [1.5, 2.5, 3.5, 4.5, 5.5]
print(average(numbers))

运行结果：

3.5

在上述代码中，我们使用List[float]表示一个浮点数列表，然后使用float来表明函数返回一个浮点数。

布尔值

使用typing模块中的bool类型可以表示布尔值。

from typing import Tuple, bool

def all_true(values: Tuple[bool]) -> bool:
    return all(values)

values = (True, True, False, True)
print(all_true(values))

运行结果：

False

在上述代码中，我们使用Tuple[bool]表示一个布尔值元组，然后使用bool来表明函数返回一个布尔值。

字符串

使用typing模块中的str类型可以表示字符串。

from typing import List, str

def to_upper_case(strings: List[str]) -> List[str]:
    return [s.upper() for s in strings]

strings = ["apple", "banana", "cherry"]
print(to_upper_case(strings))

运行结果：

['APPLE', 'BANANA', 'CHERRY']

在上述代码中，我们使用List[str]表示一个字符串列表，然后使用str来表明函数返回一个字符串列表。

None

使用typing模块中的None类型可以表示空值。

from typing import Union, None

def do_something(value: Union[int, str, None]) -> None:
    if value is None:
        print("Value is None")
    else:
        print(f"Value is {value}")

do_something(10)
do_something("hello")
do_something(None)

运行结果：

Value is 10
Value is hello
Value is None

在上述代码中，我们使用Union[int, str, None]表示参数可以是整数、字符串或空值。而None用于表示函数的返回值为空。

容器类型

在使用typing模块时，我们可以使用一些容器类型来标注列表、元组、字典等复杂数据结构。

列表

使用typing模块中的List类型可以表示列表。

from typing import List

def multiply(numbers: List[int], factor: int) -> List[int]:
    return [n * factor for n in numbers]

numbers = [1, 2, 3, 4, 5]
factor = 2
print(multiply(numbers, factor))

运行结果：

[2, 4, 6, 8, 10]

在上述代码中，我们使用List[int]表示一个整数列表，并使用List[int]来表示函数返回一个整数列表。

元组

使用typing模块中的Tuple类型可以表示元组。

from typing import Tuple

def swap(a: int, b: int) -> Tuple[int, int]:
    return b, a

a = 1
b = 2
print(swap(a, b))

运行结果：

(2, 1)

在上述代码中，我们使用Tuple[int, int]表示一个整数元组，并使用Tuple[int, int]来表示函数返回一个整数元组。

字典

使用typing模块中的Dict类型可以表示字典。

from typing import Dict

def merge_dicts(d1: Dict[str, int], d2: Dict[str, int]) -> Dict[str, int]:
    return {**d1, **d2}

d1 = {"a": 1, "b": 2}
d2 = {"c": 3, "d": 4}
print(merge_dicts(d1, d2))

运行结果：

{'a': 1, 'b': 2, 'c': 3, 'd': 4}

在上述代码中，我们使用Dict[str, int]表示一个键为字符串，值为整数的字典，并使用Dict[str, int]来表示函数返回一个相同类型的字典。

函数签名

使用typing模块时，我们可以标注函数的参数类型和返回值类型，从而提高代码的可读性和可维护性。

单个参数

可以使用typing模块中的类型注解来标注函数的参数类型。

from typing import List

def square_root(n: int) -> float:
    return n ** 0.5

num = 16
print(square_root(num))

运行结果：

4.0

在上述代码中，我们使用n: int来标注函数square_root的参数类型为整数，使用float来标注函数返回值类型为浮点数。

多个参数

当函数有多个参数时，可以使用typing模块中的Tuple类型来一次性标注多个参数的类型。

from typing import Tuple

def power(base: int, exponent: int) -> Tuple[int, int, int]:
    return base, exponent, base ** exponent

b = 2
e = 3
print(power(b, e))

运行结果：

(2, 3, 8)

在上述代码中，我们使用base: int, exponent: int来标注函数power的参数类型为整数，并使用Tuple[int, int, int]来标注函数返回值类型为一个由整数构成的元组。

可选参数

有时候，函数的参数可以是可选的，可以使用typing模块中的Optional类型来标注可选参数的类型。

from typing import Optional

def greet(name: Optional[str] = None) -> str:
    if name is None:
        return "Hello, anonymous!"
    else:
        return f"Hello, {name}!"

print(greet())
print(greet("Alice"))

运行结果：

Hello, anonymous!
Hello, Alice!

在上述代码中，我们使用name: Optional[str]来标注函数greet的参数name的类型为可选的字符串，并使用str来标注函数的返回值类型为字符串。

泛型

typing模块还提供了泛型，用于表示参数类型可以是任意类型的情况。

Union

使用typing模块中的Union类型可以表示多个类型中的任意一种。

from typing import Union

def square_root(n: Union[int, float]) -> float:
    return n ** 0.5

num1 = 16
num2 = 2.25
print(square_root(num1))
print(square_root(num2))

运行结果：

4.0
1.5

在上述代码中，我们使用Union[int, float]来标注函数square_root的参数类型为整数或浮点数，使用float来标注函数的返回值类型为浮点数。

Any

使用typing模块中的Any类型可以表示任意类型。

from typing import Any

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

x = 10
y = 20
print(add(x, y))

s1 = "Hello"
s2 = "World"
print(add(s1, s2))

运行结果：