Python中实现接口的三种方式深度解析

# 约定：所有夹爪类必须实现 gripper_open/gripper_close 方法（无显式约束）
class RealGripper:
    def gripper_open(self):
        print("真实夹爪打开")
    def gripper_close(self):
        print("真实夹爪关闭")
class SimGripper:
    def gripper_open(self):
        print("仿真夹爪打开")
    def gripper_close(self):
        print("仿真夹爪关闭")
# 使用接口的函数：默认传入的对象实现了指定方法
def control_gripper(gripper):
    gripper_open()  # 若未实现，运行时才会报错
    gripper_close()
# 调用（符合约定则正常运行）
control_gripper(RealGripper())
control_gripper(SimGripper())

from abc import ABC, abstractmethod  # ABC 是继承了 ABCMeta 的便捷类
# 定义抽象基类（接口）：强制子类实现指定方法
class GripperABC(ABC):
    # 抽象方法：子类必须实现，否则无法实例化
    @abstractmethod
    def gripper_open(self):
        """打开夹爪（抽象方法，无实现）"""
        pass
    @abstractmethod
    def gripper_close(self):
        """关闭夹爪（抽象方法，无实现）"""
        pass
    # 可选：非抽象方法（子类可继承/重写）
    def gripper_status(self):
        """获取夹爪状态（默认实现）"""
        return "未知状态"
# 正确实现：子类必须覆盖所有抽象方法
class RealGripper(GripperABC):
    def gripper_open(self):
        print("真实夹爪打开")
    def gripper_close(self):
        print("真实夹爪关闭")
# 错误实现：未实现所有抽象方法 → 无法实例化
class BadGripper(GripperABC):
    def gripper_open(self):
        print("仅实现打开")
    # 未实现 gripper_close → 实例化时报错
# 测试1：正确子类可实例化
real_gripper = RealGripper()
real_gripper.gripper_open()  # 正常执行
print(real_gripper.gripper_status())  # 继承默认方法
# 测试2：错误子类实例化报错
# bad_gripper = BadGripper()  # 抛出 TypeError: Can't instantiate abstract class BadGripper with abstract method gripper_close
# 测试3：运行时类型检查（支持）
print(isinstance(real_gripper, GripperABC))  # True

@GripperABC.register
class VirtualGripper:  # 未继承 GripperABC，但注册为虚拟子类
    def gripper_open(self): pass
    # 即使未实现 gripper_close，也能通过 issubclass 检查
print(issubclass(VirtualGripper, GripperABC))  # True

from typing import Protocol
# 定义协议（接口）：规定夹爪必须有 gripper_open/gripper_close 方法
class GripperProtocol(Protocol):
    def gripper_open(self):
        """打开夹爪（仅定义签名，无实现）"""
        ...  # 用 ... 代替 pass，更符合协议的语义
    def gripper_close(self):
        """关闭夹爪"""
        ...
# 实现类：无需继承 Protocol，只要实现指定方法就符合接口
class RealGripper:
    def gripper_open(self):
        print("真实夹爪打开")
    def gripper_close(self):
        print("真实夹爪关闭")
class SimGripper:
    def gripper_open(self):
        print("仿真夹爪打开")
    def gripper_close(self):
        print("仿真夹爪关闭")
# 使用接口的函数：参数标注为 Protocol 类型
def control_gripper(gripper: GripperProtocol):
    gripper.gripper_open()
    gripper.gripper_close()
# 测试1：静态检查（编辑器提示）
# 若传入的对象未实现指定方法，PyCharm/mypy 会标红（运行时不报错）
control_gripper(RealGripper())  # 正常运行
control_gripper(SimGripper())   # 正常运行
# 测试2：默认不支持运行时检查
# print(isinstance(RealGripper(), GripperProtocol))  # 抛出 TypeError

from typing import Protocol
from typing_extensions import runtime_checkable  # Python3.10+ 可从 typing 导入
# 装饰器开启运行时检查
@runtime_checkable
class GripperProtocol(Protocol):
    def gripper_open(self): ...
    def gripper_close(self): ...
# 测试：运行时检查生效
real_gripper = RealGripper()
print(isinstance(real_gripper, GripperProtocol))  # True
# 未实现完整方法的类 → 检查失败
class BadGripper:
    def gripper_open(self): pass  # 仅实现一个方法
print(isinstance(BadGripper(), GripperProtocol))  # False

@runtime_checkable
class GripperProtocol(Protocol):
    # 约束必须有只读属性 status
    @property
    def status(self) -> str: ...
    def gripper_open(self): ...
class RealGripper:
    @property
    def status(self):
        return "open"
    def gripper_open(self): pass
print(isinstance(RealGripper(), GripperProtocol))  # True

# 接口约定：夹爪要有 open/close 方法（仅靠注释说明）
"""
【约定】所有夹爪类必须实现 open()/close() 方法
"""
class RealGripper:
    def open(self): pass  # 符合约定
    # 漏写 close() → 编码阶段无提示
# 使用接口的函数
def control_gripper(gripper):
    gripper.open()
    gripper.close()  # 运行时才会报错（AttributeError）
# 编码阶段无提示，运行时才暴露问题
control_gripper(RealGripper())  # 运行时报错：没有 close 方法

from typing import Protocol
# 显式定义接口：明确要求实现 open/close
class GripperProtocol(Protocol):
    def open(self): ...
    def close(self): ...
# 使用接口的函数：参数标注为 Protocol
def control_gripper(gripper: GripperProtocol):
    gripper.open()
    gripper.close()
class RealGripper:
    def open(self): pass  # 漏写 close()
# 编码阶段（编辑器）直接标红提示：
# "RealGripper" has no attribute "close" 符合 GripperProtocol 接口
control_gripper(RealGripper())  # 编辑器标红，提前规避错误

from typing import Protocol
class GripperProtocol(Protocol):
    # 约束：必须有一个字符串类型的属性 `status`
    status: str
    # 同时约束方法
    def open(self): ...
# 符合接口的类：有 status 属性 + open 方法
class RealGripper:
    def __init__(self):
        self.status = "closed"  # 字符串类型，符合约束
    def open(self):
        self.status = "open"
# 不符合接口的类：无 status 属性（编辑器标红）
class BadGripper:
    def open(self): pass  # 漏了 status 属性
# 函数参数标注为 Protocol，编辑器会检查属性
def get_gripper_status(gripper: GripperProtocol) -> str:
    return gripper.status

from typing import Protocol
from typing_extensions import runtime_checkable
@runtime_checkable
class GripperProtocol(Protocol):
    # 约束：必须有一个只读属性 `status`（返回字符串）
    @property
    def status(self) -> str: ...
# 符合接口的类：实现只读属性
class RealGripper:
    def __init__(self):
        self._status = "closed"  # 私有属性
    @property  # 实现只读属性
    def status(self) -> str:
        return self._status
# 运行时检查：属性符合约束 → 返回 True
g = RealGripper()
print(isinstance(g, GripperProtocol))  # True
# 不符合接口的类：无只读 status 属性
class BadGripper:
    status = "closed"  # 普通属性，不是 @property → 检查失败
print(isinstance(BadGripper(), GripperProtocol))  # False

from abc import ABC, abstractmethod
class GripperABC(ABC):  # 继承 ABC（核心）
    @abstractmethod
    def open(self): ...
# 子类未实现 open() → 实例化时报错
class BadGripper(GripperABC):
    pass
# bad_gripper = BadGripper()  # 抛出 TypeError：无法实例化抽象类（缺 open 方法）

from abc import abstractmethod
class GripperABC:  # 未继承 ABC
    @abstractmethod
    def open(self): ...
# 子类未实现 open() → 居然能实例化！@abstractmethod 完全失效
class BadGripper(GripperABC):
    pass
bad_gripper = BadGripper()  # 无任何报错！
bad_gripper.open()  # 运行时报错（但实例化阶段没提示）

from abc import abstractmethod, ABCMeta
# 不继承 ABC，直接指定元类
class GripperABC(metaclass=ABCMeta):
    @abstractmethod
    def open(self): ...
# 效果和继承 ABC 完全一致：子类未实现 open() 无法实例化