4. 更多控制流工具¶

除了刚刚介绍的 while 语句，Python 还使用了一些其他语句，我们将在本章中遇到。

4.1. `if` 语句¶

也许最著名的语句类型是 if 语句。例如

>>> x = int(input("Please enter an integer: "))
Please enter an integer: 42
>>> if x < 0:
...     x = 0
...     print('Negative changed to zero')
... elif x == 0:
...     print('Zero')
... elif x == 1:
...     print('Single')
... else:
...     print('More')
...
More

可以有零个或多个 elif 部分，else 部分是可选的。关键字 ‘elif’ 是 ‘else if’ 的缩写，用于避免过度缩进。一个 if … elif … elif … 序列是其他语言中 switch 或 case 语句的替代品。

如果你要将同一个值与多个常量进行比较，或者检查特定的类型或属性，你可能会发现 match 语句很有用。有关更多详细信息，请参阅 match 语句。

4.2. `for` 语句¶

Python 中的 for 语句与你在 C 或 Pascal 中习惯的略有不同。它不像 Pascal 中那样总是迭代算术级数（例如在 Pascal 中），也不像 C 中那样允许用户定义迭代步长和停止条件，Python 的 for 语句迭代任何序列（列表或字符串）中的项目，按照它们在序列中出现的顺序。例如（并非有意）

>>> # Measure some strings:
... words = ['cat', 'window', 'defenestrate']
>>> for w in words:
...     print(w, len(w))
...
cat 3
window 6
defenestrate 12

在迭代同一个集合时修改集合的代码可能很难写对。相反，通常更直接的方法是循环遍历集合的副本或创建一个新的集合。

# Create a sample collection
users = {'Hans': 'active', 'Éléonore': 'inactive', '景太郎': 'active'}

# Strategy:  Iterate over a copy
for user, status in users.copy().items():
    if status == 'inactive':
        del users[user]

# Strategy:  Create a new collection
active_users = {}
for user, status in users.items():
    if status == 'active':
        active_users[user] = status

4.3. The `range()` 函数¶

如果你确实需要迭代一系列数字，内置函数 range() 会派上用场。它生成算术级数。

>>> for i in range(5):
...     print(i)
...
0
1
2
3
4

给定的结束点永远不会成为生成的序列的一部分；range(10) 生成 10 个值，这些值是长度为 10 的序列中项目的合法索引。可以使范围从另一个数字开始，或者指定不同的增量（甚至负数；有时这被称为“步长”）。

>>> list(range(5, 10))
[5, 6, 7, 8, 9]

>>> list(range(0, 10, 3))
[0, 3, 6, 9]

>>> list(range(-10, -100, -30))
[-10, -40, -70]

要迭代序列的索引，可以将 range() 和 len() 结合起来，如下所示。

>>> a = ['Mary', 'had', 'a', 'little', 'lamb']
>>> for i in range(len(a)):
...     print(i, a[i])
...
0 Mary
1 had
2 a
3 little
4 lamb

然而，在大多数情况下，使用 enumerate() 函数更方便，请参见循环技巧。

如果你只是打印一个范围，就会发生一件奇怪的事情。

>>> range(10)
range(0, 10)

在许多方面，由 range() 返回的对象的行为就像一个列表，但实际上它不是。它是一个对象，当你迭代它时，它会返回所需序列的连续项目，但它实际上并没有创建列表，从而节省了空间。

我们说这样的对象是可迭代的，也就是说，适合作为期望从其中获取连续项目的函数和结构的目标，直到供应耗尽。我们已经看到 for 语句就是这样一个结构，而一个接受可迭代对象的函数的例子是 sum()。

>>> sum(range(4))  # 0 + 1 + 2 + 3
6

稍后我们将看到更多返回可迭代对象并接受可迭代对象作为参数的函数。在第数据结构章中，我们将更详细地讨论 list()。

4.4. `break` 和 `continue` 语句，以及循环上的 `else` 子句¶

The break 语句会退出最内层的封闭 for 或 while 循环。

A for 或 while 循环可以包含一个 else 子句。

在 for 循环中，else 子句在循环到达其最后一次迭代后执行。

在 while 循环中，当循环条件变为假时，循环才会执行。

在任何一种循环中，如果循环是由 break 终止的，则 else 子句 **不会** 执行。

以下 for 循环就是一个例子，它用于搜索素数

>>> for n in range(2, 10):
...     for x in range(2, n):
...         if n % x == 0:
...             print(n, 'equals', x, '*', n//x)
...             break
...     else:
...         # loop fell through without finding a factor
...         print(n, 'is a prime number')
...
2 is a prime number
3 is a prime number
4 equals 2 * 2
5 is a prime number
6 equals 2 * 3
7 is a prime number
8 equals 2 * 4
9 equals 3 * 3

(是的，这是正确的代码。仔细看：else 子句属于 for 循环，**不** 属于 if 语句。)

当与循环一起使用时，else 子句与 try 语句的 else 子句更相似，而不是与 if 语句的 else 子句相似：try 语句的 else 子句在没有异常发生时运行，而循环的 else 子句在没有 break 发生时运行。有关 try 语句和异常的更多信息，请参见处理异常。

从 C 语言借鉴而来的 continue 语句将继续执行循环的下一个迭代。

>>> for num in range(2, 10):
...     if num % 2 == 0:
...         print("Found an even number", num)
...         continue
...     print("Found an odd number", num)
...
Found an even number 2
Found an odd number 3
Found an even number 4
Found an odd number 5
Found an even number 6
Found an odd number 7
Found an even number 8
Found an odd number 9

4.5. `pass` 语句¶

pass 语句什么也不做。当语法上需要语句但程序不需要任何操作时，可以使用它。例如

>>> while True:
...     pass  # Busy-wait for keyboard interrupt (Ctrl+C)
...

这通常用于创建最小的类

>>> class MyEmptyClass:
...     pass
...

另一个可以使用 pass 的地方是在编写新代码时作为函数或条件体占位符，允许您在更抽象的层面上思考。 pass 会被静默忽略。

>>> def initlog(*args):
...     pass   # Remember to implement this!
...

4.6. `match` 语句¶

match 语句接受一个表达式，并将它的值与作为一个或多个 case 块给出的连续模式进行比较。这表面上类似于 C、Java 或 JavaScript（以及许多其他语言）中的 switch 语句，但它更类似于 Rust 或 Haskell 等语言中的模式匹配。只有第一个匹配的模式会被执行，它还可以从值中提取组件（序列元素或对象属性）到变量中。

最简单的形式将一个主题值与一个或多个字面量进行比较

def http_error(status):
    match status:
        case 400:
            return "Bad request"
        case 404:
            return "Not found"
        case 418:
            return "I'm a teapot"
        case _:
            return "Something's wrong with the internet"

注意最后一个块：“变量名” _ 充当通配符，永远不会匹配失败。如果没有任何 case 匹配，则不会执行任何分支。

可以使用 |（“或”）将多个字面量组合到一个模式中

case 401 | 403 | 404:
    return "Not allowed"

模式看起来像解包赋值，可以用来绑定变量

# point is an (x, y) tuple
match point:
    case (0, 0):
        print("Origin")
    case (0, y):
        print(f"Y={y}")
    case (x, 0):
        print(f"X={x}")
    case (x, y):
        print(f"X={x}, Y={y}")
    case _:
        raise ValueError("Not a point")

仔细研究一下！第一个模式有两个字面量，可以看作是对上面显示的字面量模式的扩展。但接下来的两个模式组合了一个字面量和一个变量，而变量绑定了来自主题的值（point）。第四个模式捕获了两个值，这在概念上类似于解包赋值 (x, y) = point。

如果你使用类来组织数据，你可以使用类名后跟一个类似于构造函数的参数列表，但具有将属性捕获到变量中的能力。

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

def where_is(point):
    match point:
        case Point(x=0, y=0):
            print("Origin")
        case Point(x=0, y=y):
            print(f"Y={y}")
        case Point(x=x, y=0):
            print(f"X={x}")
        case Point():
            print("Somewhere else")
        case _:
            print("Not a point")

你可以对一些内置类使用位置参数，这些类为它们的属性提供了一个排序（例如 dataclasses）。你也可以通过在你的类中设置 __match_args__ 特殊属性来为属性定义一个特定位置。如果它被设置为 (“x”, “y”)，那么以下模式都是等效的（并且都将 y 属性绑定到 var 变量）

Point(1, var)
Point(1, y=var)
Point(x=1, y=var)
Point(y=var, x=1)

推荐的阅读模式的方法是将它们视为你将在赋值左侧放置的内容的扩展形式，以了解哪些变量将被设置为哪些值。只有独立的名称（如上面的 var）会被匹配语句赋值。点分隔名称（如 foo.bar）、属性名称（上面的 x= 和 y=）或类名（通过它们旁边的“(…)”识别，如上面的 Point）永远不会被赋值。

模式可以任意嵌套。例如，如果我们有一个包含 Points 的简短列表，并且添加了 __match_args__，我们可以像这样匹配它。

class Point:
    __match_args__ = ('x', 'y')
    def __init__(self, x, y):
        self.x = x
        self.y = y

match points:
    case []:
        print("No points")
    case [Point(0, 0)]:
        print("The origin")
    case [Point(x, y)]:
        print(f"Single point {x}, {y}")
    case [Point(0, y1), Point(0, y2)]:
        print(f"Two on the Y axis at {y1}, {y2}")
    case _:
        print("Something else")

我们可以向模式添加一个 if 子句，称为“守卫”。如果守卫为假，match 会继续尝试下一个 case 块。请注意，值捕获发生在守卫被评估之前。

match point:
    case Point(x, y) if x == y:
        print(f"Y=X at {x}")
    case Point(x, y):
        print(f"Not on the diagonal")

此语句的几个其他关键特性。

与解包赋值类似，元组和列表模式具有完全相同的含义，实际上匹配任意序列。一个重要的例外是它们不匹配迭代器或字符串。
序列模式支持扩展解包：[x, y, *rest] 和 (x, y, *rest) 的工作方式类似于解包赋值。* 后的名称也可以是 _，因此 (x, y, *_) 匹配至少两个项目的序列，而不绑定剩余的项目。
映射模式：{"bandwidth": b, "latency": l} 从字典中捕获 "bandwidth" 和 "latency" 值。与序列模式不同，额外的键会被忽略。解包，如 **rest，也受支持。（但 **_ 将是多余的，因此不允许。）
可以使用 as 关键字捕获子模式。
```
case (Point(x1, y1), Point(x2, y2) as p2): ...
```
将捕获输入的第二个元素作为 p2（只要输入是两个点的序列）。
大多数字面量通过相等性进行比较，但是单例 True、False 和 None 通过标识进行比较。

模式可以使用命名常量。这些必须是点分隔的名称，以防止它们被解释为捕获变量。

from enum import Enum
class Color(Enum):
    RED = 'red'
    GREEN = 'green'
    BLUE = 'blue'

color = Color(input("Enter your choice of 'red', 'blue' or 'green': "))

match color:
    case Color.RED:
        print("I see red!")
    case Color.GREEN:
        print("Grass is green")
    case Color.BLUE:
        print("I'm feeling the blues :(")

有关更详细的解释和更多示例，您可以查看 PEP 636，它以教程格式编写。

4.7. 定义函数¶

我们可以创建一个函数，将斐波那契数列写入任意边界。

>>> def fib(n):    # write Fibonacci series up to n
...     """Print a Fibonacci series up to n."""
...     a, b = 0, 1
...     while a < n:
...         print(a, end=' ')
...         a, b = b, a+b
...     print()
...
>>> # Now call the function we just defined:
... fib(2000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

关键字 def 引入函数定义。它必须后跟函数名称和括号括起来的正式参数列表。构成函数主体的语句从下一行开始，并且必须缩进。

函数主体的第一条语句可以选择是一个字符串文字；这个字符串文字是函数的文档字符串，或docstring。（有关 docstring 的更多信息，请参阅文档字符串部分。）有一些工具使用 docstring 自动生成在线或打印文档，或让用户交互式地浏览代码；在您编写的代码中包含 docstring 是一个好习惯，所以养成这个习惯。

执行函数会引入一个新的符号表，用于函数的局部变量。更准确地说，函数中的所有变量赋值都会将值存储在局部符号表中；而变量引用首先在局部符号表中查找，然后在封闭函数的局部符号表中查找，然后在全局符号表中查找，最后在内置名称表中查找。因此，全局变量和封闭函数的变量不能在函数内直接赋值（除非全局变量在 global 语句中命名，或者封闭函数的变量在 nonlocal 语句中命名），尽管它们可以被引用。

函数调用时的实际参数（参数）在调用函数时被引入到被调用函数的局部符号表中；因此，参数使用按值调用传递（其中值始终是对象引用，而不是对象的值）。[1] 当一个函数调用另一个函数，或递归地调用自身时，会为该调用创建一个新的局部符号表。

函数定义将函数名称与当前符号表中的函数对象关联起来。解释器将该名称指向的对象识别为用户定义的函数。其他名称也可以指向同一个函数对象，并且也可以用来访问该函数。

>>> fib
<function fib at 10042ed0>
>>> f = fib
>>> f(100)
0 1 1 2 3 5 8 13 21 34 55 89

来自其他语言，你可能会反对 fib 不是函数，而是过程，因为它没有返回值。事实上，即使没有 return 语句的函数也会返回值，尽管它是一个相当无聊的值。这个值被称为 None（它是一个内置名称）。如果 None 是唯一写入的值，解释器通常会抑制它的写入。如果你真的想看到它，你可以使用 print() 来查看它。

>>> fib(0)
>>> print(fib(0))
None

编写一个返回斐波那契数列数字列表的函数很简单，而不是打印它。

>>> def fib2(n):  # return Fibonacci series up to n
...     """Return a list containing the Fibonacci series up to n."""
...     result = []
...     a, b = 0, 1
...     while a < n:
...         result.append(a)    # see below
...         a, b = b, a+b
...     return result
...
>>> f100 = fib2(100)    # call it
>>> f100                # write the result
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

这个例子，像往常一样，演示了一些新的 Python 特性。

The return 语句从函数中返回一个值。没有表达式参数的 return 返回 None。从函数末尾掉下来也会返回 None。
语句 result.append(a) 调用列表对象 result 的一个方法。方法是“属于”某个对象并命名为 obj.methodname 的函数，其中 obj 是某个对象（这可能是一个表达式），而 methodname 是由对象类型定义的方法名称。不同的类型定义不同的方法。不同类型的对象可能具有相同名称的方法，而不会导致歧义。（可以使用类定义自己的对象类型和方法，请参见类）示例中显示的方法 append() 是为列表对象定义的；它在列表末尾添加一个新元素。在本例中，它等效于 result = result + [a]，但效率更高。

4.8. 关于函数定义的更多内容¶

还可以定义具有可变数量参数的函数。有三种形式，可以组合使用。

4.8.1. 默认参数值¶

最实用的形式是为一个或多个参数指定默认值。这将创建一个可以调用参数数量少于定义数量的函数。例如

def ask_ok(prompt, retries=4, reminder='Please try again!'):
    while True:
        reply = input(prompt)
        if reply in {'y', 'ye', 'yes'}:
            return True
        if reply in {'n', 'no', 'nop', 'nope'}:
            return False
        retries = retries - 1
        if retries < 0:
            raise ValueError('invalid user response')
        print(reminder)

此函数可以通过多种方式调用

只给出强制参数：ask_ok('Do you really want to quit?')
给出其中一个可选参数：ask_ok('OK to overwrite the file?', 2)
甚至给出所有参数：ask_ok('OK to overwrite the file?', 2, 'Come on, only yes or no!')

此示例还介绍了 in 关键字。这将测试序列是否包含某个值。

默认值在函数定义时的定义范围内进行评估，因此

i = 5

def f(arg=i):
    print(arg)

i = 6
f()

将打印 5。

重要警告：默认值仅评估一次。当默认值为可变对象（如列表、字典或大多数类的实例）时，这会产生差异。例如，以下函数在后续调用中累积传递给它的参数

def f(a, L=[]):
    L.append(a)
    return L

print(f(1))
print(f(2))
print(f(3))

这将打印

[1]
[1, 2]
[1, 2, 3]

如果您不希望默认值在后续调用之间共享，可以改为这样编写函数

def f(a, L=None):
    if L is None:
        L = []
    L.append(a)
    return L

4.8.2. 关键字参数¶

函数也可以使用关键字参数的形式 kwarg=value 调用。例如，以下函数

def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):
    print("-- This parrot wouldn't", action, end=' ')
    print("if you put", voltage, "volts through it.")
    print("-- Lovely plumage, the", type)
    print("-- It's", state, "!")

接受一个必需参数 (voltage) 和三个可选参数 (state、action 和 type)。此函数可以通过以下任何方式调用

parrot(1000)                                          # 1 positional argument
parrot(voltage=1000)                                  # 1 keyword argument
parrot(voltage=1000000, action='VOOOOOM')             # 2 keyword arguments
parrot(action='VOOOOOM', voltage=1000000)             # 2 keyword arguments
parrot('a million', 'bereft of life', 'jump')         # 3 positional arguments
parrot('a thousand', state='pushing up the daisies')  # 1 positional, 1 keyword

但以下所有调用都是无效的

parrot()                     # required argument missing
parrot(voltage=5.0, 'dead')  # non-keyword argument after a keyword argument
parrot(110, voltage=220)     # duplicate value for the same argument
parrot(actor='John Cleese')  # unknown keyword argument

在函数调用中，关键字参数必须放在位置参数之后。所有传递的关键字参数必须与函数接受的参数之一匹配（例如，actor 不是 parrot 函数的有效参数），并且它们的顺序并不重要。这也包括非可选参数（例如，parrot(voltage=1000) 也是有效的）。任何参数都不能多次接收值。以下是一个由于此限制而失败的示例

>>> def function(a):
...     pass
...
>>> function(0, a=0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: function() got multiple values for argument 'a'

当存在形式为 **name 的最终形式参数时，它将接收一个字典（参见 Mapping Types — dict），其中包含所有关键字参数，除了与形式参数相对应的参数。这可以与形式为 *name 的形式参数结合使用（在下一小节中描述），它接收一个包含形式参数列表之外的位置参数的 tuple。（*name 必须出现在 **name 之前。）例如，如果我们定义一个这样的函数

def cheeseshop(kind, *arguments, **keywords):
    print("-- Do you have any", kind, "?")
    print("-- I'm sorry, we're all out of", kind)
    for arg in arguments:
        print(arg)
    print("-" * 40)
    for kw in keywords:
        print(kw, ":", keywords[kw])

它可以像这样调用

cheeseshop("Limburger", "It's very runny, sir.",
           "It's really very, VERY runny, sir.",
           shopkeeper="Michael Palin",
           client="John Cleese",
           sketch="Cheese Shop Sketch")

当然它会打印

-- Do you have any Limburger ?
-- I'm sorry, we're all out of Limburger
It's very runny, sir.
It's really very, VERY runny, sir.
----------------------------------------
shopkeeper : Michael Palin
client : John Cleese
sketch : Cheese Shop Sketch

请注意，关键字参数的打印顺序保证与它们在函数调用中提供的顺序一致。

4.8.3. 特殊参数¶

默认情况下，参数可以通过位置或显式关键字传递给 Python 函数。为了可读性和性能，限制参数传递方式是有意义的，这样开发人员只需查看函数定义即可确定项目是通过位置传递，通过位置或关键字传递，还是通过关键字传递。

函数定义可能看起来像

def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):
      -----------    ----------     ----------
        |             |                  |
        |        Positional or keyword   |
        |                                - Keyword only
         -- Positional only

其中 / 和 * 是可选的。如果使用，这些符号通过参数如何传递给函数来指示参数的类型：仅位置、位置或关键字，以及仅关键字。关键字参数也称为命名参数。

4.8.3.1. 位置或关键字参数¶

如果函数定义中没有 / 和 *，则可以通过位置或关键字将参数传递给函数。

4.8.3.2. 仅位置参数¶

更详细地看一下，可以将某些参数标记为仅位置。如果为仅位置，则参数的顺序很重要，并且参数不能通过关键字传递。仅位置参数放在 /（正斜杠）之前。 / 用于在逻辑上将仅位置参数与其他参数隔开。如果函数定义中没有 /，则没有仅位置参数。

/ 之后的参数可以是位置或关键字或仅关键字。

4.8.3.3. 仅关键字参数¶

要将参数标记为仅关键字，表示必须通过关键字参数传递参数，请在参数列表中第一个仅关键字参数之前放置一个 *。

4.8.3.4. 函数示例¶

考虑以下函数定义示例，密切注意标记 / 和 *

>>> def standard_arg(arg):
...     print(arg)
...
>>> def pos_only_arg(arg, /):
...     print(arg)
...
>>> def kwd_only_arg(*, arg):
...     print(arg)
...
>>> def combined_example(pos_only, /, standard, *, kwd_only):
...     print(pos_only, standard, kwd_only)

第一个函数定义 standard_arg，最熟悉的形式，对调用约定没有限制，参数可以通过位置或关键字传递

>>> standard_arg(2)
2

>>> standard_arg(arg=2)
2

第二个函数 pos_only_arg 仅限于使用位置参数，因为函数定义中有一个 /

>>> pos_only_arg(1)
1

>>> pos_only_arg(arg=1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: pos_only_arg() got some positional-only arguments passed as keyword arguments: 'arg'

第三个函数 kwd_only_args 仅允许关键字参数，如函数定义中的 * 所示。

>>> kwd_only_arg(3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: kwd_only_arg() takes 0 positional arguments but 1 was given

>>> kwd_only_arg(arg=3)
3

最后一个函数定义在同一个函数定义中使用了所有三种调用约定。

>>> combined_example(1, 2, 3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: combined_example() takes 2 positional arguments but 3 were given

>>> combined_example(1, 2, kwd_only=3)
1 2 3

>>> combined_example(1, standard=2, kwd_only=3)
1 2 3

>>> combined_example(pos_only=1, standard=2, kwd_only=3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: combined_example() got some positional-only arguments passed as keyword arguments: 'pos_only'

最后，考虑这个函数定义，它在位置参数 name 和 **kwds 之间存在潜在的冲突，其中 name 作为键。

def foo(name, **kwds):
    return 'name' in kwds

没有可能的调用可以使其返回 True，因为关键字 'name' 将始终绑定到第一个参数。例如

>>> foo(1, **{'name': 2})
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: foo() got multiple values for argument 'name'
>>>

但是使用 /（仅位置参数），这是可能的，因为它允许 name 作为位置参数，而 'name' 作为关键字参数中的键。

>>> def foo(name, /, **kwds):
...     return 'name' in kwds
...
>>> foo(1, **{'name': 2})
True

换句话说，仅位置参数的名称可以在 **kwds 中使用，不会产生歧义。

4.8.3.5. 回顾¶

用例将决定在函数定义中使用哪些参数。

def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):

作为指导

如果希望参数名称对用户不可用，请使用仅位置参数。这在参数名称没有实际意义时很有用，如果您想在调用函数时强制执行参数的顺序，或者您需要接受一些位置参数和任意关键字。
如果名称有意义，并且通过明确使用名称使函数定义更易于理解，或者您想阻止用户依赖传递的参数位置，请使用仅关键字参数。
对于 API，请使用仅位置参数，以防止在将来修改参数名称时出现 API 更改。

4.8.4. 任意参数列表¶

最后，最不常用的选项是指定函数可以接受任意数量的参数。这些参数将被包装在一个元组中（参见元组和序列）。在可变数量的参数之前，可能出现零个或多个普通参数。

def write_multiple_items(file, separator, *args):
    file.write(separator.join(args))

通常，这些可变参数将位于形式参数列表的最后，因为它们会收集传递给函数的所有剩余输入参数。任何出现在 *args 参数之后的正式参数都是“仅关键字”参数，这意味着它们只能用作关键字，而不是位置参数。

>>> def concat(*args, sep="/"):
...     return sep.join(args)
...
>>> concat("earth", "mars", "venus")
'earth/mars/venus'
>>> concat("earth", "mars", "venus", sep=".")
'earth.mars.venus'

4.8.5. 解包参数列表¶

当参数已经存在于列表或元组中，但需要解包以用于需要单独位置参数的函数调用时，就会出现相反的情况。例如，内置的 range() 函数需要单独的start 和stop 参数。如果它们没有单独提供，请使用 * 运算符编写函数调用，以将参数从列表或元组中解包。

>>> list(range(3, 6))            # normal call with separate arguments
[3, 4, 5]
>>> args = [3, 6]
>>> list(range(*args))            # call with arguments unpacked from a list
[3, 4, 5]

以同样的方式，字典可以使用 ** 运算符传递关键字参数。

>>> def parrot(voltage, state='a stiff', action='voom'):
...     print("-- This parrot wouldn't", action, end=' ')
...     print("if you put", voltage, "volts through it.", end=' ')
...     print("E's", state, "!")
...
>>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
>>> parrot(**d)
-- This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !

4.8.6. Lambda 表达式¶

可以使用 lambda 关键字创建小型匿名函数。此函数返回其两个参数的总和：lambda a, b: a+b。Lambda 函数可以在需要函数对象的地方使用。它们在语法上被限制为单个表达式。在语义上，它们只是普通函数定义的语法糖。与嵌套函数定义一样，lambda 函数可以引用包含范围内的变量。

>>> def make_incrementor(n):
...     return lambda x: x + n
...
>>> f = make_incrementor(42)
>>> f(0)
42
>>> f(1)
43

上面的例子使用 lambda 表达式返回一个函数。另一个用途是将一个小函数作为参数传递。

>>> pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]
>>> pairs.sort(key=lambda pair: pair[1])
>>> pairs
[(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]

4.8.7. 文档字符串¶

以下是一些关于文档字符串内容和格式的约定。

第一行应该始终是对对象目的的简短、简洁的总结。为了简洁，它不应该明确说明对象的名称或类型，因为这些可以通过其他方式获得（除非名称恰好是描述函数操作的动词）。此行应以大写字母开头，以句号结尾。

如果文档字符串中还有更多行，则第二行应该为空，在视觉上将摘要与描述的其余部分隔开。接下来的几行应该是描述对象调用约定、其副作用等的段落。

Python 解析器不会从 Python 中的多行字符串字面量中去除缩进，因此处理文档的工具如果需要，必须去除缩进。这是使用以下约定完成的。字符串第一行后的第一个非空行决定了整个文档字符串的缩进量。（我们不能使用第一行，因为它通常与字符串的起始引号相邻，因此它的缩进在字符串字面量中并不明显。）然后从字符串所有行的开头去除与该缩进“等效”的空白。缩进较少的行不应该出现，但如果出现，它们的所有前导空白应该被去除。空白的等效性应该在制表符扩展（通常为 8 个空格）后进行测试。

这是一个多行文档字符串的示例

>>> def my_function():
...     """Do nothing, but document it.
...
...     No, really, it doesn't do anything.
...     """
...     pass
...
>>> print(my_function.__doc__)
Do nothing, but document it.

    No, really, it doesn't do anything.

4.8.8. 函数注解¶

函数注解是关于用户定义函数使用的类型的完全可选的元数据信息（有关更多信息，请参阅 PEP 3107 和 PEP 484）。

注解存储在函数的 __annotations__ 属性中，作为字典，对函数的任何其他部分都没有影响。参数注解由参数名称后的冒号定义，后跟一个表达式，该表达式计算出注解的值。返回值注解由一个字面量 -> 定义，后跟一个表达式，位于参数列表和表示 def 语句结束的冒号之间。以下示例具有一个必需参数、一个可选参数以及带注解的返回值

>>> def f(ham: str, eggs: str = 'eggs') -> str:
...     print("Annotations:", f.__annotations__)
...     print("Arguments:", ham, eggs)
...     return ham + ' and ' + eggs
...
>>> f('spam')
Annotations: {'ham': <class 'str'>, 'return': <class 'str'>, 'eggs': <class 'str'>}
Arguments: spam eggs
'spam and eggs'

4.9. 插曲：编码风格¶

现在您将要编写更长、更复杂的 Python 代码，现在是谈论编码风格的好时机。大多数语言可以用不同的风格编写（或者更简洁地说，格式化）；有些比其他的更易读。让其他人更容易阅读您的代码始终是一个好主意，采用良好的编码风格对此有很大帮助。

对于 Python，PEP 8 已成为大多数项目遵循的风格指南；它提倡一种非常易读且赏心悦目的编码风格。每个 Python 开发人员都应该在某个时候阅读它；以下是为您提取的最重要的要点

使用 4 个空格缩进，不使用制表符。

4 个空格是小型缩进（允许更大的嵌套深度）和大型缩进（更容易阅读）之间的一个很好的折衷方案。制表符会造成混乱，最好不要使用。
换行，使它们不超过 79 个字符。

这有助于使用小型显示器的用户，并使在大型显示器上并排显示多个代码文件成为可能。
使用空行分隔函数和类，以及函数内部更大的代码块。
尽可能将注释放在单独的一行。
使用文档字符串。
在运算符周围和逗号之后使用空格，但在括号构造内部不使用空格：a = f(1, 2) + g(3, 4)。
一致地命名您的类和函数；约定是使用 UpperCamelCase 表示类，使用 lowercase_with_underscores 表示函数和方法。始终使用 self 作为第一个方法参数的名称（有关类和方法的更多信息，请参阅初识类）。
如果您的代码旨在在国际环境中使用，请不要使用花哨的编码。无论如何，Python 的默认编码 UTF-8 甚至纯 ASCII 都最适合。
同样，如果存在哪怕是最小的可能性，说不同语言的人会阅读或维护代码，请不要在标识符中使用非 ASCII 字符。

脚注

4. 更多控制流工具¶

4.1. `if` 语句¶

4.2. `for` 语句¶

4.3. The `range()` 函数¶

4.4. `break` 和 `continue` 语句，以及循环上的 `else` 子句¶

4.5. `pass` 语句¶

4.6. `match` 语句¶

4.7. 定义函数¶

4.8. 关于函数定义的更多内容¶

4.8.1. 默认参数值¶

4.8.2. 关键字参数¶

4.8.3. 特殊参数¶

4.8.3.1. 位置或关键字参数¶

4.8.3.2. 仅位置参数¶

4.8.3.3. 仅关键字参数¶

4.8.3.4. 函数示例¶

4.8.3.5. 回顾¶

4.8.4. 任意参数列表¶

4.8.5. 解包参数列表¶

4.8.6. Lambda 表达式¶

4.8.7. 文档字符串¶

4.8.8. 函数注解¶

4.9. 插曲：编码风格¶

目录

上一主题

下一主题

本页

4. 更多控制流工具¶

4.1. if 语句¶

4.2. for 语句¶

4.3. The range() 函数¶

4.4. break 和 continue 语句，以及循环上的 else 子句¶

4.5. pass 语句¶

4.6. match 语句¶

4.7. 定义函数¶

4.8. 关于函数定义的更多内容¶

4.8.1. 默认参数值¶

4.8.2. 关键字参数¶

4.8.3. 特殊参数¶

4.8.3.1. 位置或关键字参数¶

4.8.3.2. 仅位置参数¶

4.8.3.3. 仅关键字参数¶

4.8.3.4. 函数示例¶

4.8.3.5. 回顾¶

4.8.4. 任意参数列表¶

4.8.5. 解包参数列表¶

4.8.6. Lambda 表达式¶

4.8.7. 文档字符串¶

4.8.8. 函数注解¶

4.9. 插曲：编码风格¶

4.1. `if` 语句¶

4.2. `for` 语句¶

4.3. The `range()` 函数¶

4.4. `break` 和 `continue` 语句，以及循环上的 `else` 子句¶

4.5. `pass` 语句¶

4.6. `match` 语句¶