当前位置：首页 > 文章列表 > 文章 > python教程 > 鸭子类型遇到类型提示：在 Python 中使用协议

鸭子类型遇到类型提示：在 Python 中使用协议

来源：dev.to 2024-07-31 10:15:51 0浏览收藏

亲爱的编程学习爱好者，如果你点开了这篇文章，说明你对《鸭子类型遇到类型提示：在 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 函数可以与任何具有这些方法的对象一起使用。