Python typing.Protocol详解 - 结构化子类型与静态鸭子类型指南

from typing import Protocol

# 定义协议
class Drawable(Protocol):
    def draw(self) -> None: ...

class Comparable(Protocol):
    def __lt__(self, other: object) -> bool: ...
    def __gt__(self, other: object) -> bool: ...

# 带属性的协议
class Named(Protocol):
    name: str

# 运行时可检查的协议
from typing import runtime_checkable

@runtime_checkable
class Sized(Protocol):
    def __len__(self) -> int: ...

from typing import Protocol

class Printable(Protocol):
    """可打印协议"""
    def to_string(self) -> str: ...

class Person:
    """人类（未继承Protocol，但实现了协议方法）"""
    def __init__(self, name: str, age: int) -> None:
        self.name = name
        self.age = age

    def to_string(self) -> str:
        return f"{self.name}, {self.age}岁"

class Product:
    """商品类"""
    def __init__(self, title: str, price: float) -> None:
        self.title = title
        self.price = price

    def to_string(self) -> str:
        return f"{self.title} - ¥{self.price:.2f}"

def print_item(item: Printable) -> None:
    """打印任何实现了Printable协议的对象"""
    print(item.to_string())

# Person 和 Product 都没有继承 Printable，但都实现了 to_string 方法
# 因此它们都满足 Printable 协议
person = Person("Alice", 30)
product = Product("Python编程书", 59.90)

print_item(person)
print_item(product)

Alice, 30岁
Python编程书 - ¥59.90

from typing import Protocol, runtime_checkable

@runtime_checkable
class Closeable(Protocol):
    """可关闭协议"""
    def close(self) -> None: ...

class FileResource:
    """文件资源"""
    def __init__(self, filename: str) -> None:
        self.filename = filename
        self._closed = False

    def close(self) -> None:
        self._closed = True
        print(f"关闭文件: {self.filename}")

    def __repr__(self) -> str:
        status = "已关闭" if self._closed else "打开中"
        return f"FileResource({self.filename}, {status})"

class NetworkConnection:
    """网络连接"""
    def __init__(self, host: str) -> None:
        self.host = host
        self._closed = False

    def close(self) -> None:
        self._closed = True
        print(f"断开连接: {self.host}")

# 使用 isinstance 检查协议
file = FileResource("data.txt")
conn = NetworkConnection("example.com")

print(f"file 是 Closeable: {isinstance(file, Closeable)}")
print(f"conn 是 Closeable: {isinstance(conn, Closeable)}")

# 统一关闭资源
resources = [file, conn]
for resource in resources:
    if isinstance(resource, Closeable):
        resource.close()

file 是 Closeable: True
conn 是 Closeable: True
关闭文件: data.txt
断开连接: example.com

from typing import Protocol, TypeVar, List, Iterator

T = TypeVar('T')

class Iterable(Protocol[T]):
    """可迭代协议（泛型版本）"""
    def __iter__(self) -> Iterator[T]: ...

class Sized(Protocol):
    """有大小协议"""
    def __len__(self) -> int: ...

class Container(Protocol[T]):
    """容器协议"""
    def __contains__(self, item: T) -> bool: ...

class NumberRange:
    """数字范围类，满足多个协议"""

    def __init__(self, start: int, end: int, step: int = 1) -> None:
        self.start = start
        self.end = end
        self.step = step

    def __iter__(self) -> Iterator[int]:
        current = self.start
        while current < self.end:
            yield current
            current += self.step

    def __len__(self) -> int:
        return max(0, (self.end - self.start + self.step - 1) // self.step)

    def __contains__(self, item: int) -> bool:
        return self.start <= item < self.end and (item - self.start) % self.step == 0

def describe_iterable(obj: Iterable[int]) -> None:
    """描述可迭代对象"""
    items = list(obj)
    print(f"  元素: {items}")

def describe_sized(obj: Sized) -> None:
    """描述有大小对象"""
    print(f"  大小: {len(obj)}")

# NumberRange 满足 Iterable、Sized、Container 三个协议
rng = NumberRange(1, 10, 2)

print("NumberRange(1, 10, 2):")
describe_iterable(rng)
describe_sized(rng)
print(f"  包含5: {5 in rng}")
print(f"  包含4: {4 in rng}")

NumberRange(1, 10, 2):
  元素: [1, 3, 5, 7, 9]
  大小: 5
  包含5: True
  包含4: False