在 Python 中，要求其实例必须能够获取指定属性，可以通过两种主要范式实现：一是使用 `abc` 模块创建**抽象基类（Abstract Base Class， ABC）**，强制子类实现特定属性；二是使用 `typing` 模块的 `Protocol` 进行**结构化类型注解**，定义一种“协议”，要求符合该协议的对象必须拥有指定属性[ref_1][ref_3]。这两种方法分别适用于不同的场景：抽象基类用于**继承和强制实现**，而协议用于**灵活的鸭子类型检查**。 ### 方法一：使用 `abc` 模块创建抽象基类 抽象基类通过继承机制，强制子类实现特定的抽象方法或属性。对于“必须能够获取指定属性”这一要求，可以将其定义为**抽象属性**。 #### 1. 定义抽象属性（使用 `@abstractmethod` 装饰器） 在 Python 3.3+ 中，`property`、`classmethod`、`staticmethod` 等描述符可以与 `@abstractmethod` 结合使用来定义抽象属性[ref_2]。 ```python from abc import ABC, abstractmethod class HasName(ABC): """抽象基类，要求子类实例必须拥有可获取的 'name' 属性。""" @property @abstractmethod def name(self) -> str: """抽象属性 getter。子类必须实现此属性。""" pass # 可选：还可以定义抽象的 setter 和 deleter @name.setter @abstractmethod def name(self, value: str): pass class Person(HasName): def __init__(self, first_name: str, last_name: str): self._first_name = first_name self._last_name = last_name @property def name(self) -> str: """具体实现抽象属性 getter。""" return f"{self._first_name} {self._last_name}" @name.setter def name(self, value: str): """具体实现抽象属性 setter。""" parts = value.split(' ', 1) self._first_name = parts[0] self._last_name = parts[1] if len(parts) > 1 else "" # 测试 p = Person("张", "三") print(p.name) # 输出：张 三 p.name = "李 四" print(p.name) # 输出：李 四 ``` #### 2. 定义抽象方法返回属性值 如果不强制要求属性是 `property`，也可以定义一个抽象的 `get_name()` 方法。 ```python from abc import ABC, abstractmethod class HasName(ABC): @abstractmethod def get_name(self) -> str: """抽象方法，子类必须实现以返回名称。""" pass class Product(HasName): def __init__(self, product_name: str): self.product_name = product_name def get_name(self) -> str: return self.product_name # 测试 prod = Product("笔记本电脑") print(prod.get_name()) # 输出：笔记本电脑 ``` **关键点**： * 子类 `Person` 和 `Product` 必须实现抽象基类中定义的所有 `@abstractmethod` 装饰的成员，否则在实例化时会抛出 `TypeError`[ref_3]。 * 抽象基类 `HasName` 本身不能被实例化。 * 抽象基类中也可以包含已实现的普通方法、类方法或静态方法，子类可以直接继承使用[ref_2]。 ### 方法二：使用 `typing.Protocol` 进行类型注解 `Protocol` 是 Python 3.8+ 中引入的（通过 `typing_extensions` 模块可在更早版本使用），用于定义**结构化子类型（Structural Subtyping）**，即“鸭子类型”。它不要求显式继承，只要求对象拥有协议中定义的特定属性和方法即可。 #### 1. 定义协议 ```python from typing import Protocol, runtime_checkable @runtime_checkable class Named(Protocol): """一个协议，要求符合该协议的对象必须拥有一个可读的 'name' 属性（类型为 str）。""" name: str # 如果要求是可调用的方法，可以这样定义： # def get_name(self) -> str: ... class User: def __init__(self, user_id: int, username: str): self.id = user_id self.name = username # 拥有 `name` 属性 class Animal: def __init__(self, species: str): self.species = species # 没有 `name` 属性 def print_name(obj: Named) -> None: """该函数接受任何符合 Named 协议的对象。""" print(f"Name: {obj.name}") # 使用 user = User(1, "Alice") animal = Animal("Cat") print(isinstance(user, Named)) # 输出: True (因为 user 有 name 属性) print(isinstance(animal, Named)) # 输出: False (因为 animal 没有 name 属性) print_name(user) # 类型检查通过，运行正常 # print_name(animal) # 如果开启类型检查器（如 mypy），此处会报错 ``` #### 2. 结合泛型使用 ```python from typing import TypeVar, Iterable from typing_extensions import Protocol T = TypeVar('T') class HasLength(Protocol): """协议：拥有 __len__ 方法的对象。""" def __len__(self) -> int: ... def get_size(items: Iterable[HasLength]) -> list[int]: """接受任何可迭代的、拥有 __len__ 方法的对象集合。""" return [len(item) for item in items] # 使用 list_of_lists = [[1, 2], [3, 4, 5]] list_of_strings = ["ab", "cde"] print(get_size(list_of_lists)) # 输出: [2, 3] print(get_size(list_of_strings)) # 输出: [2, 3] ``` **关键点**： * `Protocol` 定义了一种结构契约，不依赖继承关系。 * 使用 `@runtime_checkable` 装饰后，可以用 `isinstance(obj, Protocol)` 进行运行时检查[ref_2]。 * 类型检查器（如 mypy, Pyright）会在静态分析时确保传入 `print_name` 函数的参数符合 `Named` 协议。 * 这种方式更加灵活，允许不相关的类通过实现相同的属性/方法而满足同一协议。 ### 两种方法对比与应用场景 | 特性 | 抽象基类 (ABC) | 协议 (Protocol) | | :--- | :--- | :--- | | **核心机制** | 继承与显式声明 | 结构化子类型（鸭子类型） | | **强制力** | 强。子类必须实现所有抽象成员，否则无法实例化。 | 弱。由类型检查器在静态分析时保证，或在运行时通过 `isinstance` 检查（需 `@runtime_checkable`）。 | | **灵活性** | 较低。要求类必须显式继承自抽象基类。 | 极高。任何拥有所需属性/方法的类都自动符合协议，无需修改类定义。 | | **主要用途** | 1. 定义清晰的类层次结构和模板方法模式。<br>2. 在框架或库中提供必须实现的接口。<br>3. 确保子类具备某些行为。 | 1. 为函数参数提供灵活的类型提示，支持鸭子类型。<br>2. 定义回调接口或插件系统。<br>3. 在不修改现有类的情况下进行类型注解。 | | **代码示例适用场景** | 当你在设计一个类家族（如各种 `Shape` 子类），并且要求它们**必须**有 `area()` 和 `perimeter()` 方法时，使用抽象基类是合适的[ref_3]。 | 当你编写一个函数 `process(item: Named)`，它不关心 `item` 的具体类是什么，只关心它是否有 `name` 属性时，使用协议是更好的选择。 | **总结与选择建议**： * 如果你在**设计一个类体系**，并且希望（或强制）所有派生类都拥有某些特定属性或方法，应使用**抽象基类**。它提供了更强的约束和清晰的继承关系。 * 如果你在**编写使用现有对象的函数或库**，并且只关心这些对象是否拥有某些属性或方法（而不关心它们的继承关系），应使用**协议**。它提供了最大的灵活性，是现代 Python 类型注解中推崇的方式。 在实际项目中，两者可以结合使用。例如，可以定义一个抽象基类提供部分通用实现，同时定义一个对应的协议，让那些无法继承自该抽象基类但拥有相同结构的类也能通过类型检查。