Python typing.Generic详解 - 泛型类与类型安全容器完全指南

from typing import Generic, TypeVar

# 定义类型变量
T = TypeVar('T')
K = TypeVar('K')
V = TypeVar('V')

# 单类型参数的泛型类
class Container(Generic[T]):
    def __init__(self, value: T) -> None:
        self.value = value

# 多类型参数的泛型类
class Pair(Generic[K, V]):
    def __init__(self, key: K, value: V) -> None:
        self.key = key
        self.value = value

# 继承泛型类
class IntContainer(Container[int]):
    pass

from typing import Generic, TypeVar, List, Optional

T = TypeVar('T')

class Box(Generic[T]):
    """泛型盒子，存放一个值"""

    def __init__(self, value: T) -> None:
        self._value: T = value

    def get(self) -> T:
        """获取值"""
        return self._value

    def set(self, value: T) -> None:
        """设置值"""
        self._value = value

    def __repr__(self) -> str:
        return f"Box({self._value!r})"

# 使用整数盒子
int_box: Box[int] = Box(42)
print(f"整数盒子: {int_box}")
print(f"获取值: {int_box.get()}")
int_box.set(100)
print(f"设置后: {int_box.get()}")

# 使用字符串盒子
str_box: Box[str] = Box("hello")
print(f"\n字符串盒子: {str_box}")
print(f"获取值: {str_box.get()}")

整数盒子: Box(42)
获取值: 42
设置后: 100

字符串盒子: Box('hello')
获取值: hello

from typing import Generic, TypeVar, List, Optional

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

class Dictionary(Generic[K, V]):
    """泛型字典，键值对类型独立"""

    def __init__(self) -> None:
        self._data: List[tuple] = []

    def put(self, key: K, value: V) -> None:
        """添加或更新键值对"""
        for i, (k, _) in enumerate(self._data):
            if k == key:
                self._data[i] = (key, value)
                return
        self._data.append((key, value))

    def get(self, key: K) -> Optional[V]:
        """根据键获取值"""
        for k, v in self._data:
            if k == key:
                return v
        return None

    def remove(self, key: K) -> bool:
        """删除键值对"""
        for i, (k, _) in enumerate(self._data):
            if k == key:
                self._data.pop(i)
                return True
        return False

    def keys(self) -> List[K]:
        """获取所有键"""
        return [k for k, _ in self._data]

    def items(self) -> List[tuple]:
        """获取所有键值对"""
        return self._data.copy()

# 字符串键，整数值
scores: Dictionary[str, int] = Dictionary()
scores.put("Alice", 95)
scores.put("Bob", 87)
scores.put("Charlie", 92)

print("成绩字典:")
for key, value in scores.items():
    print(f"  {key}: {value}")

print(f"\nAlice 的成绩: {scores.get('Alice')}")
print(f"David 的成绩: {scores.get('David')}")

# 整数键，字符串值
names: Dictionary[int, str] = Dictionary()
names.put(1, "Alice")
names.put(2, "Bob")
print(f"\n编号1的姓名: {names.get(1)}")

成绩字典:
  Alice: 95
  Bob: 87
  Charlie: 92

Alice 的成绩: 95
David 的成绩: None

编号1的姓名: Alice

from typing import Generic, TypeVar, List, Iterator

T = TypeVar('T')

class Collection(Generic[T]):
    """泛型集合基类"""

    def __init__(self) -> None:
        self._items: List[T] = []

    def add(self, item: T) -> None:
        self._items.append(item)

    def size(self) -> int:
        return len(self._items)

    def is_empty(self) -> bool:
        return len(self._items) == 0

    def __iter__(self) -> Iterator[T]:
        return iter(self._items)

class SortedCollection(Collection[T]):
    """排序集合，继承泛型类"""

    def __init__(self) -> None:
        super().__init__()

    def add(self, item: T) -> None:
        """添加元素并保持排序"""
        self._items.append(item)
        self._items.sort()

    def min(self) -> T:
        """获取最小值"""
        if self.is_empty():
            raise ValueError("集合为空")
        return self._items[0]

    def max(self) -> T:
        """获取最大值"""
        if self.is_empty():
            raise ValueError("集合为空")
        return self._items[-1]

class UniqueCollection(Collection[T]):
    """去重集合，继承泛型类"""

    def __init__(self) -> None:
        super().__init__()
        self._seen: set = set()

    def add(self, item: T) -> None:
        """添加元素，自动去重"""
        if item not in self._seen:
            self._items.append(item)
            self._seen.add(item)

# 使用排序集合
sorted_nums: SortedCollection[int] = SortedCollection()
for num in [5, 2, 8, 1, 9, 3]:
    sorted_nums.add(num)
print(f"排序集合: {list(sorted_nums)}")
print(f"最小值: {sorted_nums.min()}, 最大值: {sorted_nums.max()}")

# 使用去重集合
unique_words: UniqueCollection[str] = UniqueCollection()
for word in ["apple", "banana", "apple", "cherry", "banana"]:
    unique_words.add(word)
print(f"\n去重集合: {list(unique_words)}")
print(f"元素数量: {unique_words.size()}")

排序集合: [1, 2, 3, 5, 8, 9]
最小值: 1, 最大值: 9

去重集合: ['apple', 'banana', 'cherry']
元素数量: 3