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 中可能习惯的有所不同。Python 的 for 语句不是始终迭代数字的算术级数（如 Pascal 中），也不是让用户能够定义迭代步长和停止条件（如 C 中），而是按它们在序列中出现的顺序迭代任何序列（列表或字符串）的项。例如（并非双关语）

>>> # 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. `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` 语句¶

break 语句会跳出最内层的 for 或 while 循环

>>> for n in range(2, 10):
...     for x in range(2, n):
...         if n % x == 0:
...             print(f"{n} equals {x} * {n//x}")
...             break
...
4 equals 2 * 2
6 equals 2 * 3
8 equals 2 * 4
9 equals 3 * 3

continue 语句继续循环的下一次迭代

>>> for num in range(2, 10):
...     if num % 2 == 0:
...         print(f"Found an even number {num}")
...         continue
...     print(f"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. 循环中的 `else` 子句¶

在 for 或 while 循环中，break 语句可以与 else 子句配对。如果循环在没有执行 break 的情况下完成，则 else 子句执行。

在 for 循环中，else 子句在循环完成其最后一次迭代后执行，即如果没有发生 break。

在 while 循环中，它在循环条件变为假后执行。

在任一类型的循环中，如果循环被 break 终止，则 else 子句将不执行。当然，其他提前结束循环的方式，例如 return 或引发异常，也会跳过 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 子句的一种方式是想象它与循环内的 if 配对。当循环执行时，它将运行一个类似于 if/if/if/else 的序列。if 在循环内部，多次遇到。如果条件曾为真，则会发生 break。如果条件从未为真，则循环外的 else 子句将执行。

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

4.6. `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!
...

对于最后一种情况，许多人使用省略号字面量 ... 而不是 pass。这种用法对 Python 没有特殊含义，也不是语言定义的一部分（你可以在这里使用任何常量表达式），但 ... 也被约定俗成地用作占位符主体。请参阅省略号对象。

4.7. `match` 语句¶

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

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

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 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）会被 match 语句赋值。带点号的名称（如 foo.bar）、属性名称（上文的 x= 和 y=）或类名称（通过其旁边的“(...)”识别，如上文的 Point）永远不会被赋值。

模式可以任意嵌套。例如，如果我们有一个带 __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.8. 定义函数¶

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

>>> def fib(n):    # write Fibonacci series less than n
...     """Print a Fibonacci series less than 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 特性

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

4.9. 更多函数定义¶

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

4.9.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('你真的想退出吗？')
提供一个可选参数：ask_ok('确定要覆盖文件吗？', 2)
甚至提供所有参数：ask_ok('确定要覆盖文件吗？', 2, '来吧，只有是或否！')

本例还介绍了 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.9.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 形式的最终形式参数时，它会收到一个字典（参见映射类型 — dict），其中包含除对应于形式参数的关键字参数之外的所有关键字参数。这可以与 *name 形式的形式参数（在下一小节中描述）结合使用，后者会收到一个包含超出形式参数列表的位置参数的元组。（*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.9.3. 特殊参数¶

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

函数定义可能如下所示

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

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

4.9.3.1. 位置或关键字参数¶

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

4.9.3.2. 仅位置参数¶

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

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

4.9.3.3. 仅关键字参数¶

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

4.9.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_arg 只允许关键字参数，如函数定义中的 * 所示

>>> 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 和以 name 为键的 **kwds 之间发生冲突

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.9.3.5. 回顾¶

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

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

作为指导

如果希望参数名称不向用户公开，请使用仅位置参数。当参数名称没有实际意义时，或者您想强制函数调用时的参数顺序，或者需要一些位置参数和任意关键字时，这很有用。
当名称有意义且函数定义通过显式名称更易于理解，或者您想防止用户依赖所传递参数的位置时，请使用仅关键字参数。
对于API，使用仅位置参数以防止如果参数名称将来修改而导致API中断。

4.9.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.9.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.9.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 表达式返回一个函数。另一种用法是将一个小型函数作为参数传递。例如，list.sort() 接受一个排序键函数 key，它可以是一个 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.9.7. 文档字符串¶

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

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

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

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

这是一个多行 docstring 的示例

>>> 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.9.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.10. 插曲：编码风格¶

既然您即将编写更长、更复杂的 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. `range()` 函数¶

4.4. `break` 和 `continue` 语句¶

4.5. 循环中的 `else` 子句¶

4.6. `pass` 语句¶

4.7. `match` 语句¶

4.8. 定义函数¶

4.9. 更多函数定义¶

4.9.1. 默认参数值¶

4.9.2. 关键字参数¶

4.9.3. 特殊参数¶

4.9.3.1. 位置或关键字参数¶

4.9.3.2. 仅位置参数¶

4.9.3.3. 仅关键字参数¶

4.9.3.4. 函数示例¶

4.9.3.5. 回顾¶

4.9.4. 任意参数列表¶

4.9.5. 解包参数列表¶

4.9.6. Lambda 表达式¶

4.9.7. 文档字符串¶

4.9.8. 函数注解¶

4.10. 插曲：编码风格¶

目录

上一主题

下一主题

本页

4. 更多控制流工具¶

4.1. if 语句¶

4.2. for 语句¶

4.3. range() 函数¶

4.4. break 和 continue 语句¶

4.5. 循环中的 else 子句¶

4.6. pass 语句¶

4.7. match 语句¶

4.8. 定义函数¶

4.9. 更多函数定义¶

4.9.1. 默认参数值¶

4.9.2. 关键字参数¶

4.9.3. 特殊参数¶

4.9.3.1. 位置或关键字参数¶

4.9.3.2. 仅位置参数¶

4.9.3.3. 仅关键字参数¶

4.9.3.4. 函数示例¶

4.9.3.5. 回顾¶

4.9.4. 任意参数列表¶

4.9.5. 解包参数列表¶

4.9.6. Lambda 表达式¶

4.9.7. 文档字符串¶

4.9.8. 函数注解¶

4.10. 插曲：编码风格¶

4.1. `if` 语句¶

4.2. `for` 语句¶

4.3. `range()` 函数¶

4.4. `break` 和 `continue` 语句¶

4.5. 循环中的 `else` 子句¶

4.6. `pass` 语句¶

4.7. `match` 语句¶