Python泛型类详解 - 元素码农

发布时间: 2025-03-29 21:33

↑

# Python泛型类详解

## 什么是泛型类？
泛型类是一种可以接受类型参数的类，它允许我们编写可以处理不同类型数据的通用类实现。通过使用泛型类，我们可以在保持类型安全的同时实现代码复用。

## 创建泛型类
在Python中，我们使用`typing.Generic`和`TypeVar`来创建泛型类。以下是一个基本示例：

```python
from typing import TypeVar, Generic

T = TypeVar('T')

class Stack(Generic[T]):
    def __init__(self) -> None:
        self.items: list[T] = []
    
    def push(self, item: T) -> None:
        self.items.append(item)
    
    def pop(self) -> T:
        if not self.items:
            raise IndexError("Stack is empty")
        return self.items.pop()
    
    def peek(self) -> T:
        if not self.items:
            raise IndexError("Stack is empty")
        return self.items[-1]
    
    def is_empty(self) -> bool:
        return len(self.items) == 0
```

## 使用泛型类
创建泛型类的实例时，我们可以指定具体的类型：

```python
# 创建一个整数栈
int_stack = Stack[int]()
int_stack.push(1)
int_stack.push(2)
print(int_stack.pop())  # 输出: 2

# 创建一个字符串栈
str_stack = Stack[str]()
str_stack.push("hello")
str_stack.push("world")
print(str_stack.pop())  # 输出: "world"
```

## 多类型参数泛型类
泛型类可以接受多个类型参数：

```python
from typing import TypeVar, Generic

K = TypeVar('K')
V = TypeVar('V')

class Pair(Generic[K, V]):
    def __init__(self, key: K, value: V) -> None:
        self.key = key
        self.value = value
    
    def get_key(self) -> K:
        return self.key
    
    def get_value(self) -> V:
        return self.value
    
    def set_value(self, value: V) -> None:
        self.value = value

# 使用示例
pair = Pair[str, int]("age", 25)
print(pair.get_key())    # 输出: "age"
print(pair.get_value())  # 输出: 25
```

## 泛型类型约束
我们可以对类型参数添加约束，限制可用的类型：

```python
from typing import TypeVar, Generic, Comparable

T = TypeVar('T', bound=Comparable)

class SortedList(Generic[T]):
    def __init__(self) -> None:
        self.items: list[T] = []
    
    def add(self, item: T) -> None:
        self.items.append(item)
        self.items.sort()
    
    def get_all(self) -> list[T]:
        return self.items

# 使用示例
numbers = SortedList[int]()
numbers.add(3)
numbers.add(1)
numbers.add(2)
print(numbers.get_all())  # 输出: [1, 2, 3]
```

## 泛型类的继承
泛型类可以继承其他泛型类：

```python
from typing import TypeVar, Generic

T = TypeVar('T')

class Container(Generic[T]):
    def __init__(self, item: T) -> None:
        self.item = item
    
    def get_item(self) -> T:
        return self.item

class NamedContainer(Container[T]):
    def __init__(self, name: str, item: T) -> None:
        super().__init__(item)
        self.name = name
    
    def get_name(self) -> str:
        return self.name

# 使用示例
named_container = NamedContainer[int]("numbers", 42)
print(named_container.get_name())   # 输出: "numbers"
print(named_container.get_item())   # 输出: 42
```

## 最佳实践
1. 使用有意义的类型变量名称，如`Key`、`Value`、`T`等。
2. 为泛型类添加类型注解，提高代码可读性。
3. 合理使用类型约束，确保类型安全。
4. 在文档中清晰说明类型参数的用途。
5. 避免过度使用泛型，只在真正需要类型参数化的场景使用。

## 总结
泛型类是Python类型系统中的重要特性，它能够帮助我们编写更加灵活、可复用的代码，同时保持类型安全。通过合理使用泛型类，我们可以提高代码质量和开发效率。