Python&#s Gradual Typing: Flexibly Enhancing Code Safety and Performance

聖光之護

发布时间：2024-11-25 21:33:21

1155人浏览过

来源于dev.to

转载

python

python 中的渐进式输入对于像我们这样想要两全其美的开发人员来说是一个游戏规则改变者：动态灵活性和静态安全性。这不是选边站，而是选边站。这是为了找到适合我们项目的最佳点。

让我们从基础开始。 python 一直是动态类型的，这意味着我们不必声明变量类型。这为我们提供了令人难以置信的灵活性，但它也可能导致难以捕获的运行时错误。这就是渐进打字的用武之地。

通过逐步输入，我们可以在代码中添加类型提示。这些提示是可选的，因此我们可以逐步引入它们（因此得名），而不会破坏现有代码。这是一个简单的例子：

def greet(name: str) -> str:
    return f"hello, {name}!"

print(greet("alice"))  # output: hello, alice!
print(greet(42))  # this will run, but a type checker would warn us

在此示例中，我们告诉 python name 应该是一个字符串，并且该函数应该返回一个字符串。但 python 不会在运行时强制执行这一点 - 我们需要使用像 mypy 这样的类型检查器来捕获潜在的问题。

现在，让我们更深入地了解一下。渐进式打字最酷的事情之一是我们可以混合打字和非打字代码。当我们使用不使用类型提示的遗留代码库或第三方库时，这非常有用。

def process_data(data: list[int]) -> int:
    return sum(data)

# this function doesn't use type hints
def get_data():
    return [1, 2, 3, 4, 5]

result = process_data(get_data())  # this works fine

这里，process_data 使用类型提示，但 get_data 没有。他们仍然可以无缝地合作。

立即学习“Python免费学习笔记（深入）”；

但是渐进式打字不仅仅是到处添加 : int 。它打开了一个充满可能性的全新世界。例如，我们可以创建自定义类型以使我们的代码更具表现力：

from typing import newtype

userid = newtype('userid', int)

def get_user_info(user_id: userid) -> dict:
    # fetch user info from database
    pass

user_id = userid(12345)
info = get_user_info(user_id)  # this is fine
info = get_user_info(12345)  # a type checker would warn about this

这有助于我们发现逻辑错误。当然，用户 id 可能是整数，但并非每个整数都是有效的用户 id。

现在，我们来谈谈一些更高级的概念。协变和逆变是一些奇特的术语，它们描述了我们如何在类型提示中使用子类型和超类型。一开始有点令人费解，但它非常有用。

from typing import list, callable

class animal:
    def make_sound(self):
        pass

class dog(animal):
    def make_sound(self):
        return "woof!"

def animal_sounds(animals: list[animal]) -> list[str]:
    return [animal.make_sound() for animal in animals]

dogs: list[dog] = [dog(), dog()]
sounds = animal_sounds(dogs)  # this is fine because dog is a subtype of animal

在此示例中，我们使用协方差。我们可以将 dogs 列表传递给需要 animal 列表的函数，因为 dog 是 animal 的子类型。

逆变则相反。当我们处理函数参数时它很有用：

def feed_animal(animal: animal):
    print("feeding animal")

def feed_dog(dog: dog):
    print("feeding dog")

def do_feeding(feeder: callable[[animal], none], animal: animal):
    feeder(animal)

do_feeding(feed_animal, dog())  # this is fine
do_feeding(feed_dog, animal())  # a type checker would warn about this

在这里，我们可以将 feed_animal 传递给 do_feeding，因为它可以处理任何动物，包括狗。但我们不能传递 feed_dog，因为它可能无法处理所有类型的动物。

这些概念可能看起来有点抽象，但当我们设计复杂的系统时它们非常强大。

现在，我们来谈谈如何逐步将静态类型引入到大型 python 代码库中。这不是一个全有或全无的提议。我们可以从小事做起，逐步向上。

首先，我们可能想向公共 api 添加类型提示。这有助于我们代码的用户了解他们应该传递什么类型以及他们将返回什么。然后，我们可以继续讨论代码的关键部分——与类型相关的错误特别成问题的区域。

随着我们添加更多类型提示，我们将开始看到好处。类型检查器可以在我们运行代码之前捕获潜在的错误。我们的 ide 可以提供更好的自动完成和重构支持。我们的代码在一定程度上变得自我记录。

但是需要取得平衡。我们不想过度使用类型提示而失去 python 的可读性和简单性。有时，保留无类型内容是可以的，尤其是对于简单、不言而喻的代码。

Tome

先进的AI智能PPT制作工具

下载

让我们看一个逐步输入函数的示例：

# Original function
def process_order(order):
    total = sum(item['price'] * item['quantity'] for item in order['items'])
    if order['coupon']:
        total *= 0.9
    return {'order_id': order['id'], 'total': total}

# Gradually typed version
from typing import Dict, List, Optional

def process_order(order: Dict[str, Any]) -> Dict[str, Union[str, float]]:
    total = sum(item['price'] * item['quantity'] for item in order['items'])
    if order['coupon']:
        total *= 0.9
    return {'order_id': order['id'], 'total': total}

# Fully typed version
OrderItem = Dict[str, Union[str, int, float]]
Order = Dict[str, Union[str, List[OrderItem], bool]]

def process_order(order: Order) -> Dict[str, Union[str, float]]:
    total = sum(item['price'] * item['quantity'] for item in order['items'])
    if order['coupon']:
        total *= 0.9
    return {'order_id': order['id'], 'total': total}

我们一开始没有类型提示，然后添加了一些基本提示，最后为完全类型化版本创建了自定义类型。每一步都在不改变代码功能的情况下提高了代码的稳健性。

渐进打字最酷的事情之一是它可以提高性能。当我们提供类型信息时，python 有时可以优化我们的代码。例如，它可能能够使用更高效的数据结构或避免不必要的类型检查。

但也许渐进式打字的最大好处是它如何改变我们思考代码的方式。当我们开始考虑类型时，我们经常会发现逻辑不一致或我们以前没有想到的潜在边缘情况。这就像与未来的自己对话，讨论我们的代码应该做什么。

当然，渐进打字并非没有挑战。它可以使我们的代码更加冗长，并且有效使用类型提示有一个学习曲线。我们还需要小心，不要陷入认为类型提示保证正确性的陷阱——它们是帮助我们捕获某些类型错误的工具，但它们并不是灵丹妙药。

最后，让我们考虑一下在 python 中使用渐进式输入的一些最佳实践：