Python泛型高级用法：协变、逆变与泛型继承

一颗松果

发布时间：2026-10-24| 5人浏览过

原创

在使用 Python 编写类型注解时，大多数开发者最早接触的是基础的 TypeVar('T')。然而一旦将泛型带入面向对象的多态体系，静态类型检查器（如 Mypy、Pyright）经常会给出出人意料的错误提示：明明子类对象可以赋值给父类变量，为什么包含子类的泛型容器却不能赋值给包含父类的泛型容器？本文将系统梳理这一现象背后的核心概念——型变（Variance），拆解默认不变性（Invariant）、协变（Covariant）与逆变（Contravariant）的逻辑根源与适用场景，并详细说明自定义泛型类在多层继承中的参数传递规范。

一、子类型多态与默认不变性的矛盾

在面向对象设计中，若类 Dog 继承自 Animal，则根据里氏替换原则（LSP），任何需要 Animal 的地方都可以安全传入 Dog 的实例。在类型理论中，这表示 Dog 是 Animal 的子类型，记作 Dog <: Animal。

直觉上，开发者容易推论：既然单个 Dog 是 Animal，那么由多个 Dog 构成的列表 list[Dog] 也应该是 list[Animal] 的子类型。然而，在静态类型检查器看来，这种赋值是不安全的，会直接引发类型检查报错。

class Animal:
    pass

class Dog(Animal):
    def bark(self) -> None:
        print("汪汪")

class Cat(Animal):
    pass

def add_stray_cat(shelter: list[Animal]) -> None:
    shelter.append(Cat())

my_dogs: list[Dog] = [Dog()]
# 下面这行代码如果被类型检查器允许，就会引发灾难：
# add_stray_cat(my_dogs) 
# 此时 my_dogs 内部混入了 Cat 实例，当随后执行 my_dogs[1].bark() 时便会运行时崩溃！

这种潜在的类型破坏揭示了一个核心事实：只要容器允许写入操作，泛型就不能随意沿用内部元素的子类型关系。为了保障绝对的类型安全，Python 中未显式声明型变方向的类型变量 TypeVar('T') 默认是不变（Invariant）的。这意味着即使 Dog <: Animal，list[Dog] 与 list[Animal] 之间也毫无子类型关系，二者相互隔离。

Python泛型高级用法：协变、逆变与泛型继承 — 图 1：可变容器的默认不变性（Invariant）及其防范运行时崩溃的机制

二、协变（Covariant）：只读容器与生产者的自然延伸

既然不变性是为了杜绝非法写入，那么对于绝不接受新元素写入、仅负责向外提供数据的结构（即“只读”或“生产者”），这种严格限制就不再必要。例如，元组 tuple[Dog, ...] 或只读序列 Sequence[Dog] 是绝对安全的，因为调用者无法向其中追加 Cat。

当类型构造器保持了内部类型的子类型继承方向时，这种性质被称为协变（Covariant）：

协变定义公式

若类型 B 是类型 A 的子类型（B <: A），且泛型类 F 满足 F[B] <: F[A]，则称 F 在类型参数上关于该参数是协变的。

1. 声明协变类型参数

在 Python 3.12 之前，通过 TypeVar 的 covariant=True 参数进行标记：

from typing import TypeVar, Generic

T_co = TypeVar('T_co', covariant=True)

class ReadOnlyBox(Generic[T_co]):
    def __init__(self, value: T_co) -> None:
        self._value = value

    def get(self) -> T_co:
        """作为生产者向外输出数据：返回类型允许使用协变变量"""
        return self._value

在 Python 3.12 引入的 PEP 695 新语法中，可以直接在类声明括号中使用加号前缀 +T 表示协变：

# Python 3.12+ 原生泛型语法
class ReadOnlyBox[+T]:
    def __init__(self, value: T) -> None:
        self._value = value

    def get(self) -> T:
        return self._value

2. 协变方法签名的严格约束

一旦类标记为协变，类型检查器就会严格监控该类的方法参数。协变类型变量只能出现在方法的返回值位置（输出位置），绝不能出现在公开方法的参数位置（输入位置）。

# 错误示例：试图在协变类中接收 T_co 作为方法参数
class InvalidBox(Generic[T_co]):
    def set_value(self, new_value: T_co) -> None:
        # Mypy 报错: Cannot use a covariant type variable as a parameter
        self._value = new_value

三、逆变（Contravariant）：消费者与入参的逆向逻辑

在理解了协变面向“只读/输出”后，另一个对偶的概念是逆变（Contravariant），它主要面向“只写/消费者”。

思考一个直观的生活常识：如果一位动物医生能够诊断任何 Animal（包括狗、猫、鸟类），那么当你需要一位专门诊断 Dog 的医生时，请这位能看所有动物的医生来，是否绝对安全？答案显然是肯定的。

在类型系统中，这意味着：一个能够接收 Animal 的处理器，完全可以安全地充当一个接收 Dog 的处理器。处理器的层级关系与它所处理对象的继承关系恰好颠倒了：

逆变定义公式

若类型 B 是类型 A 的子类型（B <: A），且泛型类 F 满足 F[A] <: F[B]，则称 F 在该类型参数上是逆变的。

1. 声明与使用逆变

在 Python 3.12 之前，通过 contravariant=True 声明；在 Python 3.12+ 中使用减号前缀 -T：

from typing import TypeVar, Generic

T_contra = TypeVar('T_contra', contravariant=True)

class Consumer(Generic[T_contra]):
    def consume(self, item: T_contra) -> None:
        """只接受输入：逆变变量合法出现在方法参数位置"""
        pass

# Python 3.12+ 原生语法：
# class Consumer[-T]:
#     def consume(self, item: T) -> None:
#         pass

def process_dog_care(consumer: Consumer[Dog]) -> None:
    consumer.consume(Dog())

animal_consumer: Consumer[Animal] = Consumer[Animal]()
# 逆变赋植：Consumer[Animal] 是 Consumer[Dog] 的子类型，完美通过类型检查！
process_dog_care(animal_consumer)

反之，如果逆变类型变量出现在了返回值的输出位置，类型检查器同样会立即拦截并报错。因为如果一个类承诺返回 Dog，而逆变允许该类被替换为返回更宽泛的 Animal 的实现，调用方获取结果后调用 bark() 就会再次导致崩溃。

四、泛型继承与多层派生规范

定义了基础的泛型类之后，随着业务系统的扩展，常常需要派生出子类。在 Python 中，继承自 Generic[...] 的类拥有严格的类型参数传递规则。根据子类对类型参数的处理方式，可以分为三种典型的继承模式：

1. 保留泛型参数（透传）

子类依然是一个泛型类，仅添加子类特有的方法或逻辑，类型变量继续保留并在实例化时决定：

from typing import TypeVar, Generic

T = TypeVar('T')

class Repository(Generic[T]):
    def __init__(self) -> None:
        self._items: list[T] = []

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

# 子类必须在基类和 Generic 中同时声明 T
class FilterableRepository(Repository[T], Generic[T]):
    def get_all(self) -> list[T]:
        return list(self._items)

2. 具体化类型参数（绑定）

子类在继承时直接将泛型参数绑定为具体的业务类型，此时子类变成了一个普通类（非泛型类）：

class UserRepository(Repository[dict[str, str]]):
    """明确指定操作的数据结构，无需再继承 Generic"""
    def find_by_username(self, name: str) -> dict[str, str] | None:
        for user in self._items:
            if user.get("username") == name:
                return user
        return None

3. 扩展与多类型参数派生

子类不仅继承父类的类型参数，还可以引入自身专属的新类型参数：

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

class KeyValueRepository(Repository[V], Generic[K, V]):
    def __init__(self) -> None:
        super().__init__()
        self._index: dict[K, V] = {}

    def set_key(self, key: K, val: V) -> None:
        self.add(val)
        self._index[key] = val

继承时的型变一致性原则

如果在继承链中父类使用了协变或逆变变量，子类在重写方法或重声明泛型参数时，绝对不能改变父类所保证的型变契约。例如父类是协变只读的，子类绝不能在重写的方法中将其放开为可变输入，否则将彻底违背里氏替换原则。

五、型变选型决策与排错总结

在实际工程中，什么时候该用默认不变，什么时候该用协变或逆变？可以参考面向对象设计中的 PECS 原则（Producer Extends, Consumer Super）：

型变分类	Python 声明 (旧/新)	角色与行为	方法中的位置	典型标准库类型
不变 (Invariant)	`TypeVar('T')` / `[T]`	既读又写、双向交互	既可作为入参，也可作为返回值	`list[T]`, `dict[K, V]`, `set[T]`
协变 (Covariant)	`covariant=True` / `[+T]`	生产者 (Producer)、只读结构	只能作为返回值 (输出位置)	`tuple[T, ...]`, `Sequence[T]`, `Iterable[T]`
逆变 (Contravariant)	`contravariant=True` / `[-T]`	消费者 (Consumer)、写入处理	只能作为方法参数 (输入位置)	`Callable[[T], None]`, `Generator[..., T, ...]` (send)

理解了型变与泛型继承的内在机理后，便能清晰洞察类型检查器各项报错的根源。在架构设计中，合理将可变状态与只读接口分离（例如优先将函数参数注解为协变的 Sequence[T] 而非不变的 list[T]），不仅能够提升接口对多态的包容性，更能利用静态检查在编译期杜绝绝大多数由于类型混乱造成的运行时隐患。