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

亲爱的编程学习爱好者，如果你点开了这篇文章，说明你对《鸭子类型遇到类型提示：在 Python 中使用协议》很感兴趣。本篇文章就来给大家详细解析一下，主要介绍一下，希望所有认真读完的童鞋们，都有实质性的提高。

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 等高级静态类型检查工具。

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

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

本篇关于《鸭子类型遇到类型提示：在 Python 中使用协议》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于文章的相关知识，请关注golang学习网公众号！