搜索菜单
当前位置: 首页 > Python > Python泛型高级用法：协变、逆变与泛型继承

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

一颗松果
一颗松果
发布时间：2026-10-24 | 4人浏览过
原创
在使用 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
Python泛型高级用法：协变、逆变与泛型继承
图 2：协变推导步骤与方法签名位置规则

三、逆变（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泛型高级用法：协变、逆变与泛型继承
图 3：消费者/处理器中的逆变机制：参数类型更宽泛的处理器能满足更具体的处理要求

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

定义了基础的泛型类之后，随着业务系统的扩展，常常需要派生出子类。在 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)
Python泛型高级用法：协变、逆变与泛型继承
图 4：泛型型变选型决策树与核心应用总结

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

相关文章

相关标签: Python

本站声明

本文内容仅供参考，不代表本站观点。转载或引用请注明出处。如发现内容问题，请通过联系我们页面反馈。

作者最新文章

全部内容

Python 相关产品和应用

全部下载
Python Selenium
Selenium

Selenium

4.51.0 · Windows

用于浏览器自动化和 Web 测试的 Python 工具。
Python 机器学习 Scikit-learn
scikit-learn

scikit-learn

1.9.1 · Windows

常用 Python 机器学习算法与模型评估工具库。
Python 代码质量
Black

Black

26.10.1 · Windows

强调一致性的 Python 自动代码格式化工具。
Python 代码质量
Ruff

Ruff

0.17.1 · macOS

由 Rust 编写的高速 Python 代码检查和格式化工具。
Python pytest
pytest

pytest

9.1.1 · Windows

简洁而强大的 Python 自动化测试框架。
Python FastAPI API
FastAPI

FastAPI

0.146.0 · Windows

高性能 Python API 框架，支持类型提示和自动接口文档。
Python Flask Web开发
Flask

Flask

3.1.3 · Windows

轻量灵活的 Python Web 应用框架。
Python Django Web开发
Django

Django

6.1.2 · Windows

成熟的 Python Web 框架，适合构建内容站点和业务系统。
Python IDE Spyder
Spyder

Spyder

6.1.7 · Windows

面向科学计算与数据分析的 Python 集成开发环境。
Python SciPy
SciPy

SciPy

1.18.1 · Windows

面向科学、工程和技术计算的 Python 算法库。
Python Pandas 数据分析
pandas

pandas

3.0.6 · Windows

Python 数据分析库，提供 DataFrame 与丰富的数据处理能力。
Python NumPy
NumPy

NumPy

2.5.4 · Windows

Python 科学计算基础库，提供高性能多维数组与数值运算。

文章分类

专题列表

ipython.cn 学习网
人工智能 Java AI行业服务