使用Python typing模块中的TypeVar和Generic实现泛型

在Python中，泛型是一种编程概念，它允许在编写函数、类或数据结构时使用参数化类型，以提高代码的灵活性和复用性。通过泛型，我们可以编写更通用的代码，使其能够适用于多种不同类型的数据。

Python 中的泛型是使用 typing 模块中的 TypeVar 和 Generic 进行实现的。TypeVar 用于定义泛型类型变量，而 Generic 用于定义泛型类或函数。

typing 模块中的泛型支持包括一系列的泛型类型和类型变量，例如 List、Dict、Tuple 等。开发者可以使用这些泛型类型来声明具有泛型参数的数据结构或函数签名。此外，Python 3.9 引入了更多强大的泛型支持，包括 Literal、TypedDict 等新的泛型类型。

需要注意的是，Python 中的泛型类型提示仅用于静态类型检查和文档说明，并不影响运行时的行为。Python 解释器不会强制执行类型提示，因此在运行时仍然可以传入任何类型的参数。

下面是一些关于Python泛型的详细解释：

1. 泛型类型变量（Generic Type Variables）：

在使用泛型时，我们通常会定义一个泛型类型变量，用于表示某种不确定的类型。泛型类型变量通常使用大写字母命名，比如 T、U、V 等。

T = TypeVar('T')

2. 泛型函数（Generic Functions）：

泛型函数是可以接受一个或多个泛型类型参数的函数。这些参数可以用来指定函数参数的类型、返回值的类型或函数内部使用的其他类型。

from typing import TypeVar, List

T = TypeVar('T')

def first_element(items: List[T]) -> T:
    return items[0]

int_list = [1, 2, 3, 4, 5]
print(first_element(int_list))  # 输出: 1

str_list = ["Hello", "World", "Python"]
print(first_element(str_list))  # 输出: Hello

在这个例子中，我们创建了一个整数列表 int_list 和一个字符串列表 str_list。我们使用 first_element 函数获取了这两个列表的第一个元素，分别是整数 1 和字符串 "Hello"。 

from typing import TypeVar, List

# 定义一个泛型类型T
T = TypeVar('T')

def reverse_list(items: List[T]) -> List[T]:
    """反转列表"""
    return items[::-1]

# 使用泛型函数
int_list = [1, 2, 3, 4, 5]
str_list = ["apple", "banana", "orange"]

reversed_ints = reverse_list(int_list)
reversed_strs = reverse_list(str_list)

print(reversed_ints)  # 输出: [5, 4, 3, 2, 1]
print(reversed_strs)  # 输出: ['orange', 'banana', 'apple']

3. 泛型类（Generic Classes）：

泛型类是可以接受一个或多个泛型类型参数的类。这些参数可以用来指定类的属性类型、方法参数类型、方法返回值类型或类内部使用的其他类型。

from typing import TypeVar, Generic

T = TypeVar('T')

class Box(Generic[T]):
    def __init__(self, item: T):
        self.item = item

    def get_item(self) -> T:
        return self.item

int_box = Box[int](10)
print(int_box.get_item())  # 输出: 10

str_box = Box[str]("Hello")
print(str_box.get_item())  # 输出: Hello

在这个例子中，我们创建了一个整数 Box 实例 int_box，存储了整数 10，并使用 get_item 方法获取了该整数。我们还创建了一个字符串 Box 实例 str_box，存储了字符串 "Hello"，并使用 get_item 方法获取了该字符串。 

4. 泛型约束（Generic Constraints）：

有时，我们希望泛型类型只能是特定的类型或其子类。在这种情况下，我们可以使用泛型约束来限制泛型类型的范围。

from typing import TypeVar, List, Union

T = TypeVar('T', int, float)

def sum_values(items: List[T]) -> Union[int, float]:
    return sum(items)

int_list = [1, 2, 3, 4, 5]
print(sum_values(int_list))  # 输出: 15

float_list = [1.5, 2.5, 3.5, 4.5, 5.5]
print(sum_values(float_list))  # 输出: 16.0

在这个例子中，我们创建了一个整数列表 int_list 和一个浮点数列表 float_list。我们使用 sum_values 函数计算了这两个列表的总和，分别是整数 15 和浮点数 16.0。 
代码片段中，-> Union[int, float] 是函数 sum_values 的返回类型注解。它表示函数的返回值可以是整数（int）或浮点数（float）类型之一。这是通过 typing 模块中的 Union 类型帮助器实现的。
需要注意的是，Python 中的泛型类型提示仅用于静态类型检查和文档说明，并不影响运行时的行为。Python 解释器不会强制执行类型提示，因此在运行时仍然可以传入任何类型的参数。

​​​​​​​
类型注解是指在代码中为变量、函数参数和返回值等添加类型信息的过程。它们使用 Python 的 typing 模块提供的类型帮助器，如 List、Union、TypeVar 等，来描述变量或函数参数的类型。类型注解的主要目的是提高代码的可读性、可维护性，并为静态类型检查工具提供有关代码结构的信息。

5. 使用泛型时的注意事项：

总之，泛型是一种强大的编程工具，可以帮助开发者编写更通用、更灵活的代码，但在使用时需要注意理解其原理和限制。

———

from typing import TypeVar, Generic

# 定义一个泛型类型T
T = TypeVar('T')

class Storage(Generic[T]):
    def __init__(self, initial_value: T):
        self._value = initial_value

    def get_value(self) -> T:
        """获取存储的值"""
        return self._value

    def set_value(self, new_value: T) -> None:
        """设置新的值"""
        self._value = new_value

# 使用泛型类
int_storage = Storage(10)
print(int_storage.get_value())  # 输出: 10
int_storage.set_value(20)
print(int_storage.get_value())  # 输出: 20

str_storage = Storage("Hello")
print(str_storage.get_value())  # 输出: Hello
str_storage.set_value("World")
print(str_storage.get_value())  # 输出: World

这段代码演示了如何使用泛型类（Generic Class）来创建可以存储不同类型数据的存储器。

作者：铁松溜达py