鸭子类型与类型提示的结合：在 Python 中使用协议

发布于2024-09-04

Duck Typing Meets Type Hints: Using Protocols in Python

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

在本教程中，您将学习：

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

了解鸭子类型

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

在 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 参数没有类型提示，这在鸭子类型代码中很常见，但可能会导致较大代码库中出现问题。

鸭子打字的优点和缺点

鸭子打字有几个优点：

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

但是，它也有一些缺点：

缺乏清晰度：可能不清楚对象需要实现哪些方法。
运行时错误：仅在运行时捕获与类型相关的错误。
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)

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

它需要继承，这可能导致不灵活的层次结构。
它不适用于您无法修改的现有类。
这违背了 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)

让我们分解一下：

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

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

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

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

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 函数可以与任何具有这些方法的对象一起使用。