Python 的动态特性和对鸭子类型的支持长期以来因其灵活性而受到称赞。然而，随着代码库变得越来越大、越来越复杂，静态类型检查的好处变得越来越明显。但是我们如何协调鸭子类型的灵活性和静态类型检查的安全性呢？进入Python的Protocol类。

在本教程中，您将学习：

1. 什么是鸭子类型以及 Python 中如何支持它
2. 鸭子打字的优缺点
3. 抽象基类 (ABC) 如何尝试解决打字问题
4. 如何使用协议来获得两全其美的效果：通过静态类型检查实现鸭子类型灵活性

了解鸭子类型

鸭子类型是一种编程概念，其中对象的类型或类不如它定义的方法重要。它基于这样的想法：“如果它看起来像鸭子，像鸭子一样游泳，像鸭子一样嘎嘎叫，那么它可能就是一只鸭子。”

在 Python 中，完全支持鸭子类型。例如：

class Duck:
    def quack(self):
        print("Quack!")

class Person:
    def quack(self):
        print("I'm imitating a duck!")

def make_it_quack(thing):  # Note: No type hint here
    thing.quack()

duck = Duck()
person = Person()

make_it_quack(duck)    # Output: Quack!
make_it_quack(person)  # Output: I'm imitating a duck!

在此示例中，make_it_quack 不关心事物的类型。它只关心这个东西有一个江湖方法。请注意，thing 参数没有类型提示，这在鸭子类型代码中很常见，但可能会导致较大代码库中出现问题。

鸭子打字的优点和缺点

鸭子打字有几个优点：

1. 灵活性：它允许更灵活的代码，不依赖于特定类型。
2. 更轻松的代码重用：您可以在新上下文中使用现有类而无需修改。
3. 强调行为：它关注对象可以做什么，而不是它是什么。

但是，它也有一些缺点：

1. 缺乏清晰度：可能不清楚对象需要实现哪些方法。
2. 运行时错误：仅在运行时捕获与类型相关的错误。
3. IDE 支持较少：IDE 很难提供准确的自动完成和错误检查。

ABC 解决方案

解决这些问题的一种方法是使用抽象基类（ABC）。这是一个例子：

from abc import ABC, abstractmethod

class Quacker(ABC):
    @abstractmethod
    def quack(self):
        pass

class Duck(Quacker):
    def quack(self):
        print("Quack!")

class Person(Quacker):
    def quack(self):
        print("I'm imitating a duck!")

def make_it_quack(thing: Quacker):
    thing.quack()

duck = Duck()
person = Person()

make_it_quack(duck)
make_it_quack(person)

虽然这种方法提供了更好的类型检查和更清晰的接口，但它也有缺点：

1. 它需要继承，这可能导致不灵活的层次结构。
2. 它不适用于您无法修改的现有类。
3. 这违背了 Python 的“鸭子类型”哲学。

协议：两全其美

Python 3.8引入了Protocol类，它允许我们定义接口而不需要继承。下面是我们如何使用它：

from typing import Protocol

class Quacker(Protocol):
    def quack(self):...

class Duck:
    def quack(self):
        print("Quack!")

class Person:
    def quack(self):
        print("I'm imitating a duck!")

def make_it_quack(thing: Quacker):
    thing.quack()

duck = Duck()
person = Person()

make_it_quack(duck)
make_it_quack(person)

让我们分解一下：

1. 我们定义了一个Quacker协议来指定我们期望的接口。
2. 我们的 Duck 和 Person 类不需要继承任何东西。
3. 我们可以使用 make_it_quack 的类型提示来指定它需要 Quacker。

这种方法给我们带来了几个好处：

1. 静态类型检查：IDE 和类型检查器可以在运行时之前捕获错误。
2. 不需要继承：现有的类只要有正确的方法就可以工作。
3. 清晰的接口：协议明确定义了期望的方法。

这是一个更复杂的示例，展示了协议如何根据需要（形状）变得复杂，同时保持域类（圆形、矩形）平坦：

from typing import Protocol, List

class Drawable(Protocol):
    def draw(self): ...

class Resizable(Protocol):
    def resize(self, factor: float): ...

class Shape(Drawable, Resizable, Protocol):
    pass

def process_shapes(shapes: List[Shape]):
    for shape in shapes:
        shape.draw()
        shape.resize(2.0)

# Example usage
class Circle:
    def draw(self):
        print("Drawing a circle")

    def resize(self, factor: float):
        print(f"Resizing circle by factor {factor}")

class Rectangle:
    def draw(self):
        print("Drawing a rectangle")

    def resize(self, factor: float):
        print(f"Resizing rectangle by factor {factor}")

# This works with any class that has draw and resize methods,
# regardless of its actual type or inheritance
shapes: List[Shape] = [Circle(), Rectangle()]
process_shapes(shapes)

在此示例中，Circle 和 Rectangle 不继承自 Shape 或任何其他类。他们只是实现所需的方法（绘制和调整大小）。得益于 Shape 协议，process_shapes 函数可以与任何具有这些方法的对象一起使用。

概括

Python 中的协议提供了一种将静态类型引入鸭子类型代码的强大方法。它们允许我们在类型系统中指定接口，而不需要继承，保持鸭子类型的灵活性，同时添加静态类型检查的好处，

通过使用协议，您可以：

1. 为您的代码定义清晰的接口
2. 获得更好的 IDE，（静态类型检查），支持并更早捕获错误
3. 保持鸭子类型的灵活性
4. 利用类型检查来检查您无法修改的类。

如果您想了解有关 Python 中的协议和类型提示的更多信息，请查看有关类型模块的官方 Python 文档，或探索 mypy 等高级静态类型检查工具。

祝你编码愉快，愿你的鸭子总是因类型安全而嘎嘎叫！

您可以在这里找到我的更多内容，包括我的时事通讯