老齐教室

Python3.8新语法：海象运算符

2020-03-03

作者：Brett Slatkin

翻译：老齐

与本文内容有关的图书：《跟老齐学Python：轻松入门》、《Python大学实用教程》（以下图书，各大电商平台有售）

Python3.8引入了一种叫做海象运算符（walrus）的新语法（译者注： 对于walrus的翻译，目前尚未出现对于Python的专门术语翻译，所以，此处姑且用字面意思“海象”），它其实是一种赋值语句，用于解决Python语言中长期存在的、可能导致代码重复的问题。正常的赋值语句是a=b，读作“a等于b”，而海象赋值语句是a:=b，读作“a walrus /ˈwɔːlrəs/ b”（因为:=看起来像一对眼球和獠牙，类似于海象。注意：此语句还没有适合的中文读法，总不能读作“a海象b”吧）。

海象运算符的优势在于能在不允许赋值的地方（如if语句的条件表达式中）使用赋值变量。海象运算符左侧有个标识符，赋值表达式的值等于分配给这个标识符的值。

例如，假设我有一篮子新鲜水果，我正试图经营一家果汁店。在这里，我定义了篮子里的东西：

1
2
3
4
5
fresh_fruit = {
    'apple': 10,
    'banana': 8,
    'lemon': 5,
}

当顾客到柜台点柠檬水时，我需要确保篮子里至少有一个柠檬用来榨果汁。我的操作方法是检索柠檬的数量，然后使用if语句查询非零的值：

1
2
3
4
5
6
7
8
9
10
11
def make_lemonade(count):
    ...

def out_of_stock():
    ...

count = fresh_fruit.get('lemon', 0)
if count:
    make_lemonade(count)
else:
    out_of_stock()

这个看似简单的代码问题吸引了过多的关注。count变量仅在if语句的第一个代码块中使用，在if语句上方定义count会使它看起来比实际情况更为重要，好像后面的所有代码（包括else块）都需要访问count变量，然而事实并非如此。

我们获取一个值，检查它是否为非零，然后使用它。这种模式在Python中非常常见。许多程序员试图绕过多次出现count的情况，甚至不惜使用各种损害可读性的招数。现在好了，在Python3.8中增加了海象运算符，可以简化上面的代码。

1
2
3
4
if count := fresh_fruit.get('lemon', 0):
    make_lemonade(count)
else:
    out_of_stock()

虽然现在只是少了一行，但可读性提高很多。因为现在可以清楚地看到count只与if语句的第一行相关。赋值表达式首先为count变量赋值，然后在if语句的上下文中使用该值，以确定如何继续控制流程。这两步行为——分配和评估——是海象运算符的基本性质。

柠檬是非常有效的，所以我的柠檬水配方中只需要一个，这意味着非零检查就足够了。不过，如果顾客点了苹果酒，我需要确保至少有四个苹果。在这里，我从fruit_basket字典中获取计数，然后在if语句中使用比较表达式：

1
2
3
4
5
6
7
8
def make_cider(count):
    ...

count = fresh_fruit.get('apple', 0)
if count >= 4:
    make_cider(count)
else:
    out_of_stock()

这个问题和柠檬水的例子一样，count的赋值会分散对这个变量的注意力。在这里，我还使用了海象运算符来提高代码的清晰度：

1
2
3
4
if (count := fresh_fruit.get('apple', 0)) >= 4:
    make_cider(count)
else:
    out_of_stock()

这样做可以收到预期的效果，并使代码缩短了一行。需要注意的是，我需要用圆括号将赋值表达式括起来，以便与if语句中的4进行比较。在柠檬水的例子中不需要使用圆括号，因为赋值表达式本身就是一个非零检查；它不是一个较大表达式的子表达式。与其他表达式一样，应尽量避免使用圆括号把赋值表达式括起来。

有时候会出现一种类似的重复模式，那就是当我需要根据某些条件在封闭范围内分配一个变量，然后在函数中的稍后位置引用该变量。例如，假设客户订购了一些香蕉冰沙。为了制作它们，我需要至少两个香蕉的香蕉片，否则将引发OutOfBananas异常。在这里，我以一种典型的方式来实现这个逻辑：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
def slice_bananas(count):
    ...

class OutOfBananas(Exception):
    pass

def make_smoothies(count):
    ...

pieces = 0
count = fresh_fruit.get('banana', 0)
if count >= 2:
    pieces = slice_bananas(count)

try:
    smoothies = make_smoothies(pieces)
except OutOfBananas:
    out_of_stock()

另一种常见的方法是将pieces=0赋值放入else块：

1
2
3
4
5
6
7
8
9
10
count = fresh_fruit.get('banana', 0)
if count >= 2:
    pieces = slice_bananas(count)
else:
    pieces = 0

try:
    smoothies = make_smoothies(pieces)
except OutOfBananas:
    out_of_stock()

第二种方法可能会让人觉得奇怪，因为这意味着pieces变量出现在了条件语句中两个不同的位置，可以在这两个位置进行初始定义。由于Python的作用域规则，这种分割定义在技术上是可行的，但它的可读性不好，也不优雅。这就是许多人喜欢上面那种结构的原因，在它里面的pieces = 0的赋值在前面出现。

海象运算符也可以用一行代码来缩短这个例子。这个小变化消除了对count变量的任何强调。现在，很明显，除了if语句之外，pieces也很重要:

1
2
3
4
5
6
7
8
pieces = 0
if (count := fresh_fruit.get('banana', 0)) >= 2:
    pieces = slice_bananas(count)

try:
    smoothies = make_smoothies(pieces)
except OutOfBananas:
    out_of_stock()

使用海象运算符还可以提高在条件语句中分别在两个分支中的pieces复制的可读性。当count定义不再位于if语句之前时，跟踪pieces变量变得更容易:

1
2
3
4
5
6
7
8
9
if (count := fresh_fruit.get('banana', 0)) >= 2:
    pieces = slice_bananas(count)
else:
    pieces = 0

try:
    smoothies = make_smoothies(pieces)
except OutOfBananas:
    out_of_stock()

初学Python的程序员经常遇到的一个难题是缺少灵活的switch/case语句，与此类功能近似的一般做法是使用多个if、elif和else语句的深度嵌套。

例如，假设我想实现一个优先级系统，这样每个客户都可以自动获得最好的果汁，而不必预定。在这里，我设置这样的流程，让它先供应香蕉冰沙，然后供应苹果酒，最后供应柠檬水：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
count = fresh_fruit.get('banana', 0)
if count >= 2:
    pieces = slice_bananas(count)
    to_enjoy = make_smoothies(pieces)
else:
    count = fresh_fruit.get('apple', 0)
    if count >= 4:
        to_enjoy = make_cider(count)
    else:
        count = fresh_fruit.get('lemon', 0)
        if count:
            to_enjoy = make_lemonade(count)
        else:
            to_enjoy = 'Nothing'

像这样难看的结构在Python代码中司空见惯，幸运的是，海象运算符提供了一个优雅的解决方案，它几乎可以像switch/case语句的专用语法一样通用：

1
2
3
4
5
6
7
8
9
if (count := fresh_fruit.get('banana', 0)) >= 2:
    pieces = slice_bananas(count)
    to_enjoy = make_smoothies(pieces)
elif (count := fresh_fruit.get('apple', 0)) >= 4:
    to_enjoy = make_cider(count)
elif count := fresh_fruit.get('lemon', 0):
    to_enjoy = make_lemonade(count)
else:
    to_enjoy = 'Nothing'

使用海象运算符版本只比原来的版本短五行，但是由于嵌套和缩进的减少，可读性有了很大提高。如果在你的代码中看到像上面那样丑陋的代买，我建议你尽量使用海象运算符重写。

初学Python的程序员常常遇到的另一个挫折是缺少do/while循环构造。例如，假设我想在新水果到货时将果汁装入瓶中，直到没有剩余的水果为止。在这里，我用while循环实现这个逻辑：

1
2
3
4
5
6
7
8
9
10
11
12
13
def pick_fruit():
    ...

def make_juice(fruit, count):
    ...

bottles = []
fresh_fruit = pick_fruit()
while fresh_fruit:
    for fruit, count in fresh_fruit.items():
        batch = make_juice(fruit, count)
        bottles.extend(batch)
    fresh_fruit = pick_fruit()

这里存在重复，先后执行了两次fresh_fruit = pick_fruit()，一个在循环前设置初始条件，另一个在循环结束时补充到货的水果列表。

在这种情况下，改进代码复用的策略是使用loop-and-a-half（如果出现这种情况，需要立即退出并跳过循环体中的任何剩余语句）。这消除了多余的行，但它也破坏了while循环，使其成为一个愚蠢的无限循环。现在，循环的所有流控制都依赖于break条件语句：

1
2
3
4
5
6
7
8
bottles = []
while True:                     # Loop
    fresh_fruit = pick_fruit()
    if not fresh_fruit:         # And a half
        break
    for fruit, count in fresh_fruit.items():
        batch = make_juice(fruit, count)
        bottles.extend(batch)

海象运算符消除了对loop-and-a-half的需要。方法是：允许重新设置fresh_fruit变量，然后每次都通过while循环有条件地求值。此解决方案简短易读，应该是代码中的首选方法：

1
2
3
4
5
bottles = []
while fresh_fruit := pick_fruit():
    for fruit, count in fresh_fruit.items():
        batch = make_juice(fruit, count)
        bottles.extend(batch)

在许多其他情况下，可以使用还有海象运算符的赋值表达式来消除冗余。通常，当你发现自己在许多行中多次重复同一个表达式或赋值时，应该考虑使用海象运算符来提高可读性。

牢记

  • 赋值表达式使用walrus运算符(:=)在单个表达式中同时对变量名进行赋值和计算，从而减少重复。
  • 当赋值表达式是一个较大表达式的子表达式时，它必须用圆括号括起来。
  • 尽管在Python中不能用switch/case语句和do/while循环，但是通过使用海象运算符的赋值表达式可以更清楚地模拟它们的功能。

原文链接：https://effectivepython.com/2020/02/02/prevent-repetition-with-assignment-expressions

关注微信公众号：老齐教室。读深度文章，得精湛技艺，享绚丽人生。

← Django中用SQL实现分组查询 针对各种编程问题，提供最权威回答 →
赏
使用支付宝打赏
使用微信打赏

若你觉得我的文章对你有帮助，欢迎点击上方按钮对我打赏

关注微信公众号，读文章、听课程，提升技能