Python泛型(Generics)使用及说明

from typing import TypeVar, List

# 定义一个类型变量 T
# 习惯上变量名和字符串参数保持一致
T = TypeVar('T')

from typing import TypeVar, List

T = TypeVar('T')

def get_first(items: List[T]) -> T:
    """返回列表的第一个元素，类型与列表元素类型一致"""
    return items[0]

# 使用示例
n: int = get_first([1, 2, 3])      # T 被推断为 int
s: str = get_first(["a", "b"])     # T 被推断为 str

# IDE 会报错的例子:
# x: str = get_first([1, 2, 3])    # 错误: 期望返回 int，但标记为 str

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:
        return self.items.pop()

# 具体化使用
int_stack = Stack[int]()
int_stack.push(1)
# int_stack.push("a")  # 类型检查错误: 期望 int

str_stack = Stack[str]()
str_stack.push("hello")

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

class KeyValuePair(Generic[K, V]):
    def __init__(self, key: K, value: V):
        self.key = key
        self.value = value

pair = KeyValuePair[str, int]("age", 25)

class Animal:
    def speak(self): pass

class Dog(Animal): ...
class Cat(Animal): ...

# T 必须是 Animal 或其子类
A = TypeVar('A', bound=Animal)

def make_noise(animal: A) -> None:
    animal.speak()

make_noise(Dog()) # OK
# make_noise("hello") # Error: str 不是 Animal 的子类

// Java 不需要提前定义 T
public class Box<T> {
    private T content;
    
    public void set(T content) {
        this.content = content;
    }
    
    public T get() {
        return content;
    }
}

// 使用
Box<String> box = new Box<>();
box.set("hello");

from typing import TypeVar, Generic

# Python 必须先定义 T
T = TypeVar('T') 

class Box(Generic[T]):
    def __init__(self) -> None:
        self.content: T = None
        
    def set(self, content: T) -> None:
        self.content = content
        
    def get(self) -> T:
        return self.content

# 使用
box = Box[str]()
box.set("hello")

// T 必须是 Animal 或其子类
public class Zoo<T extends Animal> {
    private T animal;
    
    public void set(T animal) {
        // 可以安全调用 Animal 的方法
        animal.speak();
    }
}

# T 必须是 Animal 或其子类
T = TypeVar('T', bound='Animal')

class Zoo(Generic[T]):
    def __init__(self, animal: T):
        self.animal = animal
        
    def set(self, animal: T) -> None:
        # 可以安全调用 Animal 的方法
        self.animal.speak()

from typing import TypeVar, Generic, List, Optional
from dataclasses import dataclass

# 假设有两个实体模型
@dataclass
class User:
    id: int
    name: str

@dataclass
class Document:
    id: int
    content: str

# 定义泛型 T，约束为必须有 id 属性 (这里用 Protocol 更高级，但简化演示用)
T = TypeVar('T')

class BaseRepository(Generic[T]):
    def __init__(self):
        self.db: dict[int, T] = {}

    def save(self, entity: T) -> None:
        # 假设实体都有 id 属性
        self.db[entity.id] = entity

    def get(self, id: int) -> Optional[T]:
        return self.db.get(id)

    def find_all(self) -> List[T]:
        return list(self.db.values())

# 具体实现
class UserRepository(BaseRepository[User]):
    def find_by_name(self, name: str) -> Optional[User]:
        for user in self.db.values():
            if user.name == name:
                return user
        return None

# 使用
user_repo = UserRepository()
user_repo.save(User(1, "Alice"))
user = user_repo.get(1) # 类型自动推断为 User

from typing import Protocol, TypeVar

T = TypeVar('T')

class Reader(Protocol[T]):
    def read(self) -> T:
        ...

def process_data(reader: Reader[str]) -> None:
    print(reader.read())

class FileReader:
    def read(self) -> str:
        return "file content"

# FileReader 没有继承 Reader，但符合结构，可以通过检查
process_data(FileReader())