Python泛型类型详解 - TypeVar与Generic使用指南

from typing import TypeVar, Generic, TypeAlias

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

# 定义带约束的类型变量
T_constrained = TypeVar('T_constrained', int, float, str)

# 泛型函数
def first(items: list[T]) -> T:
    return items[0]

# 泛型类
class Stack(Generic[T]):
    def __init__(self) -> None:
        self._items: list[T] = []

# 类型别名
Vector: TypeAlias = list[float]

from typing import TypeVar, List

T = TypeVar('T')

def first(items: List[T]) -> T:
    """返回列表的第一个元素"""
    if not items:
        raise ValueError("列表为空")
    return items[0]

def last(items: List[T]) -> T:
    """返回列表的最后一个元素"""
    if not items:
        raise ValueError("列表为空")
    return items[-1]

# 使用泛型函数
numbers = [10, 20, 30, 40, 50]
print(f"第一个数字: {first(numbers)}")
print(f"最后一个数字: {last(numbers)}")

words = ["hello", "world", "python"]
print(f"第一个单词: {first(words)}")
print(f"最后一个单词: {last(words)}")

第一个数字: 10
最后一个数字: 50
第一个单词: hello
最后一个单词: python

from typing import TypeVar, Generic, List, Optional

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 self.is_empty():
            raise IndexError("栈为空")
        return self._items.pop()

    def peek(self) -> Optional[T]:
        """查看栈顶元素"""
        if self.is_empty():
            return None
        return self._items[-1]

    def is_empty(self) -> bool:
        """判断栈是否为空"""
        return len(self._items) == 0

    def size(self) -> int:
        """返回栈的大小"""
        return len(self._items)

# 使用整数栈
int_stack: Stack[int] = Stack()
int_stack.push(1)
int_stack.push(2)
int_stack.push(3)
print(f"整数栈大小: {int_stack.size()}")
print(f"栈顶元素: {int_stack.peek()}")
print(f"出栈: {int_stack.pop()}")
print(f"出栈后栈顶: {int_stack.peek()}")

# 使用字符串栈
str_stack: Stack[str] = Stack()
str_stack.push("hello")
str_stack.push("world")
print(f"\n字符串栈大小: {str_stack.size()}")
print(f"出栈: {str_stack.pop()}")

整数栈大小: 3
栈顶元素: 3
出栈: 3
出栈后栈顶: 2

字符串栈大小: 2
出栈: world

from typing import TypeVar, List

# 带约束的类型变量：只能是 int 或 float
Number = TypeVar('Number', int, float)

def sum_values(values: List[Number]) -> Number:
    """对数值列表求和"""
    total: Number = 0  # type: ignore
    for v in values:
        total += v
    return total

int_result = sum_values([1, 2, 3, 4, 5])
float_result = sum_values([1.5, 2.5, 3.0])
print(f"整数求和: {int_result}")
print(f"浮点数求和: {float_result}")

# 带上界的类型变量
from typing import Protocol

class Comparable(Protocol):
    def __lt__(self, other: object) -> bool: ...
    def __gt__(self, other: object) -> bool: ...

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

def find_max(items: List[C]) -> C:
    """找到列表中的最大值"""
    if not items:
        raise ValueError("列表为空")
    max_item = items[0]
    for item in items[1:]:
        if item > max_item:
            max_item = item
    return max_item

max_num = find_max([3, 7, 2, 9, 1])
max_str = find_max(["apple", "banana", "cherry"])
print(f"最大数字: {max_num}")
print(f"最大字符串: {max_str}")

整数求和: 15
浮点数求和: 7.0
最大数字: 9
最大字符串: cherry