Python中的接口、抽象基类和协议示例详解

class BigMac:
    def eat(self):
        return "巨无霸：双层牛肉，酱汁浓郁！"

class ChickenBurger:
    def eat(self):
        return "香辣鸡腿堡：外酥里嫩！"

class Human:
    def eat_lunch(self, food: BigMac):
        # 【面向实现编程】
        # 这里写死了：我只检查是不是巨无霸。
        # 如果想吃香辣鸡腿堡，必须修改 Human 类的代码！没有任何拓展性
        if isinstance(food, BigMac):
            print(f"人类正在吃: {food.eat()}")
        else:
            print("人类拒绝进食：这不是巨无霸！")

# --- 代码运行 ---
person = Human()
mcd = BigMac()
kfc = ChickenBurger()

# 一旦换了不同的汉堡（具体实现）就吃不了了。。。
person.eat_lunch(mcd)
person.eat_lunch(kfc)

from abc import ABC, abstractmethod

# 1. 定义接口，这是汉堡基类，可以实现出不同的汉堡
class Burger(ABC):
    @abstractmethod
    def eat(self):
        pass

# 2. 具体实现（必须继承 Burger）
class BigMac(Burger):
    def eat(self):
        return "巨无霸：双层牛肉！"

class ChickenBurger(Burger):
    def eat(self):
        return "香辣鸡腿堡：脆皮炸鸡！"

# 3. 客户端
class Human:
    # 【面向接口编程】后续想挑战什么汉堡都可以，继承Burger实现eat就可以
    # 只要是 Burger 的子类，我都能接受
    def eat_lunch(self, food: Burger):
        print(f"人类正在吃: {food.eat()}")

# --- 代码执行 ---
person = Human()
person.eat_lunch(BigMac())        
person.eat_lunch(ChickenBurger())

from abc import ABC, abstractmethod

# 1. 定义接口，这是汉堡基类，可以实现出不同的汉堡
class Burger(ABC):
    @abstractmethod
    def eat(self):
        pass

class Dumpling(object):
    def eat(self):
        return "玉米饺子"

# 3. 客户端
class Human:
    # 【面向接口编程】后续想挑战什么汉堡都可以，继承Burger实现eat就可以
    # 只要是 Burger 的子类，我都能接受
    def eat_lunch(self, food: Burger):
        print(f"人类正在吃: {food.eat()}")

# --- 代码执行 ---
person = Human()
# 传入的对象是饺子的实例对象，但是也可以运行成功，因为饺子有eat方法
person.eat_lunch(Dumpling())

from abc import ABC, abstractmethod

# 1. 定义接口，这是汉堡基类，可以实现出不同的汉堡
class Burger(ABC):
    @abstractmethod
    def eat(self):
        pass

class Dumpling(object):
    def eat(self):
        return "玉米饺子"

# 3. 客户端
class Human:
    # 【面向接口编程】后续想挑战什么汉堡都可以，继承Burger实现eat就可以
    # 只要是 Burger 的子类，我都能接受
    def eat_lunch(self, food: Burger):
        if not isinstance(food, Burger):
            raise TypeError(f"必须传入 Burger 的子类，当前传入的是: {type(food).__name__}")
        print(f"人类正在吃: {food.eat()}")

# --- 代码执行 ---
person = Human()
person.eat_lunch(Dumpling())

from abc import ABC, abstractmethod

# 1. 定义接口，这是汉堡基类，可以实现出不同的汉堡
class Burger(ABC):
    @abstractmethod
    def eat(self):
        pass

# 注册为汉堡的虚拟子类
@Burger.register
class Dumpling(object):
    def eat(self):
        return "玉米饺子"

# 3. 客户端
class Human:
    # 【面向接口编程】后续想挑战什么汉堡都可以，继承Burger实现eat就可以
    # 只要是 Burger 的子类，我都能接受
    def eat_lunch(self, food: Burger):
        if not isinstance(food, Burger):
            raise TypeError(f"必须传入 Burger 的子类，当前传入的是: {type(food).__name__}")
        print(f"人类正在吃: {food.eat()}")

# --- 代码执行 ---
person = Human()
person.eat_lunch(Dumpling())

from collections.abc import Iterable

class MyIter:
    # MyIter类只是定义了__iter__方法
    def __iter__(self):
        pass

counter = MyIter()

# 神奇的事情发生了，MyIter和Iterable并没有任何显式继承的关系
print(isinstance(counter, Iterable))

# 验证一下MyIter并没有继承Iterable
print(MyIter.__mro__)

# 1. 一个正经的后端对象：数据库连接
class DatabaseConnection:
    def __enter__(self):
        print("🔗 [Database] 开启数据库连接...")
        return self
        
    def __exit__(self, exc_type, exc_val, exc_tb):
        print("🔌 [Database] 释放数据库连接...")
        return False

# 2. 一个毫不相干的奇葩对象：魔法传送门
class MagicalPortal:
    def __enter__(self):
        print("🌀 [Portal] 念动咒语，打开时空传送门...")
        return self
        
    def __exit__(self, exc_type, exc_val, exc_tb):
        print("💥 [Portal] 传送结束，关闭传送门防止怪物入侵...")
        return False

# 3. 见证协议的威力
print("--- 场景 A：后端工程师在工作 ---")
# with 语句根本不在乎你是数据库还是什么，它只看协议
with DatabaseConnection():
    print("   执行 SQL 查询: SELECT * FROM users")

print("\n--- 场景 B：法师在施法 ---")
# 魔法传送门没有继承任何基类，但它满足了协议，照样能用 with！
with MagicalPortal():
    print("   正在穿越到艾泽拉斯大陆...")

from typing import Protocol

# 1. 定义静态协议 (契约)
# 注意：我们继承的是 typing.Protocol，而不是常规的基类
class MessageSender(Protocol):
    def send(self, message: str) -> bool:
        """只要一个类拥有接受 str 并返回 bool 的 send 方法，
           它在静态检查器眼里，就是 MessageSender。"""

# 2. 具体实现 (完全不需要继承 MessageSender！)
class EmailSender:
    def send(self, message: str) -> bool:
        print(f"📧 发送邮件: {message}")
        return True

class SMSSender:
    def send(self, message: str) -> bool:
        print(f"📱 发送短信: {message}")
        return True

# 3. 一个“假装”能发送，但其实方法名不对的类
class Printer:
    def print_doc(self, message: str) -> bool:
        print(f"🖨️ 打印文档: {message}")
        return True

# 4. 客户端调用方
# 在类型注解中指定依赖 Protocol
def alert_admin(sender: MessageSender, alert_msg: str):
    sender.send(alert_msg)

# --- 测试环节 ---

email_sender = EmailSender()
sms_sender = SMSSender()
printer = Printer()

# ✅ 这两行在 IDE（如 VS Code / PyCharm）或 mypy 中完全合法
alert_admin(email_sender, "服务器 CPU 超过 90%！")
alert_admin(sms_sender, "数据库连接断开！")

# ❌ 这一行会在代码运行前，直接被 IDE 标红报错！
alert_admin(printer, "机房起火了！")

from typing import Protocol

class Burger(Protocol):
    def eat(self) -> str:
        ...

class BigMac:
    def eat(self) -> str:
        return "巨无霸：双层牛肉！"

# 运行这段代码会直接报错：
print(isinstance(BigMac(), Burger))

from typing import Protocol, runtime_checkable

# 加上装饰器，赋予协议在运行时被 isinstance 检查的能力
@runtime_checkable
class Burger(Protocol):
    def eat(self) -> str:
        ...

class BigMac:
    def eat(self) -> str:
        return "巨无霸：双层牛肉！"

class Hotdog:
    def lick(self) -> str:
        return "吃热狗"

mac = BigMac()
dog = Hotdog()

# ✅ 运行时完美通过！输出 True，因为 BigMac 拥有 eat 方法
print(f"mac 是 Burger 吗？ {isinstance(mac, Burger)}") 

# ✅ 完美拦截！输出 False，因为 Hotdog 没有 eat 方法
print(f"dog 是 Burger 吗？ {isinstance(dog, Burger)}")

from typing import Protocol

# 1. 定义协议（静态接口/结构化子类型）
class Burger(Protocol):
    def eat(self) -> str:
        ...

# 2. 具体实现（隐式实现了 Burger 协议，完全解耦，无需显式继承）
class BigMac:
    def eat(self) -> str:
        return "巨无霸：双层牛肉！"

class ChickenBurger:
    def eat(self) -> str:
        return "香辣鸡腿堡：脆皮炸鸡！"

# 3. 客户端
class Human:
    # 【面向协议编程/静态鸭子类型】
    # 只要传入的对象拥有和 Burger 协议定义一致的 eat 方法，就能通过静态类型检查
    def eat_lunch(self, food: Burger) -> None:
        print(f"人类正在吃: {food.eat()}")

# --- 代码执行 ---
person = Human()
person.eat_lunch(BigMac())        
person.eat_lunch(ChickenBurger())