Python语言有接口概念吗(实例详细解释)

# 不需要声明“我实现了Readable接口”
# 只要对象有 read() 方法，它就可以被当作“可读对象”
class FileReader:
    """文件读取器"""
    def read(self):
        return "从文件读取的数据"
class NetworkReader:
    """网络数据读取器""" 
    def read(self):
        return "从网络读取的数据"
class DatabaseReader:
    """数据库读取器"""
    def read(self):
        return "从数据库读取的数据"
# 使用这些对象时，不需要知道它们的具体类型
# 只需要知道它们都有 read() 方法
def process_reader(reader):
    """处理任何有read()方法的对象"""
    data = reader.read()  # 不关心reader的具体类型
    print(f"处理数据: {data}")
# 所有对象都可以传入，因为它们都有read()方法
process_reader(FileReader())
process_reader(NetworkReader())
process_reader(DatabaseReader())

# 定义两个“接口”的预期行为
class JSONSerializable:
    """期望对象有 to_json() 方法"""
    pass  # 这只是文档说明，没有实际约束
class XMLSerializable:
    """期望对象有 to_xml() 方法"""
    pass
# 实现类
class User:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def to_json(self):
        import json
        return json.dumps({"name": self.name, "age": self.age})
    def to_xml(self):
        return f"<user><name>{self.name}</name><age>{self.age}</age></user>"
# 使用函数
def export_json(obj):
    """导出为JSON - 要求obj有to_json()方法"""
    if hasattr(obj, 'to_json'):  # 运行时检查
        return obj.to_json()
    raise TypeError("对象必须实现 to_json() 方法")
def export_xml(obj):
    """导出为XML - 要求obj有to_xml()方法"""
    return obj.to_xml()  # 直接调用，如果失败会抛出异常
# 测试
user = User("张三", 25)
print(export_json(user))  # 正常执行
print(export_xml(user))   # 正常执行

from abc import ABC, abstractmethod
from typing import List
# 显式定义接口
class DataRepository(ABC):
    """数据仓库接口"""
    @abstractmethod
    def save(self, data: dict) -> bool:
        """保存数据"""
        pass
    @abstractmethod
    def find_by_id(self, id: str) -> dict:
        """按ID查找"""
        pass
    @abstractmethod
    def find_all(self) -> List[dict]:
        """查找所有"""
        pass
# 实现类
class UserRepository(DataRepository):
    def __init__(self):
        self._users = []
    def save(self, data: dict) -> bool:
        self._users.append(data)
        return True
    def find_by_id(self, id: str) -> dict:
        for user in self._users:
            if user.get('id') == id:
                return user
        return {}
    def find_all(self) -> List[dict]:
        return self._users.copy()
# 测试
try:
    repo = UserRepository()  # 正常实例化
    repo.save({"id": "1", "name": "Alice"})
    print(repo.find_by_id("1"))
except TypeError as e:
    print(f"错误: {e}")
# 不能实例化抽象类
try:
    abstract_repo = DataRepository()  # 会报错！
except TypeError as e:
    print(f"正确：不能实例化抽象类 - {e}")

from typing import Protocol, runtime_checkable
from dataclasses import dataclass
# 定义协议（接口）
@runtime_checkable
class Renderable(Protocol):
    """可渲染对象的协议"""
    def render(self) -> str:
        """渲染为字符串"""
        ...
    width: int  # 期望有width属性
    height: int  # 期望有height属性
# 实现类 - 不需要继承或声明
class Button:
    def __init__(self, text, width, height):
        self.text = text
        self.width = width
        self.height = height
    def render(self) -> str:
        return f"[{self.text}]"
class Image:
    def __init__(self, src, width, height):
        self.src = src
        self.width = width
        self.height = height
    def render(self) -> str:
        return f"<img src='{self.src}' width={self.width} height={self.height}>"
# 使用函数
def render_ui(component: Renderable) -> str:
    """渲染UI组件"""
    # 类型检查器会验证component是否符合Renderable协议
    return f"""
    组件: {component.render()}
    尺寸: {component.width}x{component.height}
    """
# 测试
button = Button("点击我", 100, 40)
image = Image("logo.png", 200, 100)
print(render_ui(button))
print(render_ui(image))
# 运行时检查
print(f"button符合Renderable协议吗? {isinstance(button, Renderable)}")  # True
print(f"image符合Renderable协议吗? {isinstance(image, Renderable)}")    # True
# 不符合协议的例子
class BadComponent:
    def render(self):
        return "bad"
bad = BadComponent()
print(f"bad符合Renderable协议吗? {isinstance(bad, Renderable)}")  # False，缺少width/height属性

// 定义接口
type Shape interface {
    Area() float64
    Perimeter() float64
}
// 实现接口
type Rectangle struct {
    Width, Height float64
}
// 必须显式实现所有方法
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}
func (r Rectangle) Perimeter() float64 {
    return 2 * (r.Width + r.Height)
}
// 使用接口
func printArea(s Shape) {
    fmt.Println("面积:", s.Area())
}

# 不需要定义Shape接口
class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height
    # 只要有area()和perimeter()方法
    # 就可以被当作"形状"
    def area(self):
        return self.width * self.height
    def perimeter(self):
        return 2 * (self.width + self.height)
# 使用函数
def print_area(shape):
    """期望shape有area()方法"""
    print(f"面积: {shape.area()}")
# 任何有area()方法的对象都可以传入
print_area(Rectangle(10, 5))

from typing import Protocol, runtime_checkable
from dataclasses import dataclass
# 1. 使用Protocol定义接口
@runtime_checkable
class PaymentProcessor(Protocol):
    def charge(self, amount: float, currency: str) -> str:
        """处理支付，返回交易ID"""
        ...
    def refund(self, transaction_id: str) -> bool:
        """退款"""
        ...
# 2. 实现类
class StripeProcessor:
    def charge(self, amount: float, currency: str) -> str:
        # Stripe支付逻辑
        return f"stripe_tx_{hash((amount, currency))}"
    def refund(self, transaction_id: str) -> bool:
        # Stripe退款逻辑
        return True
class PayPalProcessor:
    def charge(self, amount: float, currency: str) -> str:
        # PayPal支付逻辑
        return f"paypal_tx_{hash((amount, currency))}"
    def refund(self, transaction_id: str) -> bool:
        # PayPal退款逻辑
        return True
# 3. 业务逻辑
class OrderService:
    def __init__(self, processor: PaymentProcessor):
        self.processor = processor
    def checkout(self, order_id: str, amount: float):
        # 类型检查器会验证processor是否符合PaymentProcessor
        tx_id = self.processor.charge(amount, "USD")
        print(f"订单 {order_id} 支付成功，交易ID: {tx_id}")
# 4. 使用
service = OrderService(StripeProcessor())
service.checkout("order123", 99.99)
# 可以轻松切换实现
service = OrderService(PayPalProcessor())

# Go的：接口定义 → 强制实现
# type Storage interface { Save(data []byte) error }
# Python的等价做法：
# 1. Protocol（最接近Go）
class Storage(Protocol):
    def save(self, data: bytes) -> None: ...
# 2. ABC（强制实现）
class Storage(ABC):
    @abstractmethod
    def save(self, data: bytes) -> None: ...
# 3. 鸭子类型（最Pythonic）
# 不定义接口，直接写函数：
def save_data(storage_obj, data: bytes):
    # 期望storage_obj有save()方法
    storage_obj.save(data)