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 其他语言的语句。

4.2. `for` 声明¶

这个 for python中的语句与c或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. 这个 `range()` 功能¶

如果您确实需要迭代一个数字序列，那么内置函数 range() 很方便。它生成算术级数：

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

给定的端点绝不是生成序列的一部分； range(10) 生成10个值，即长度为10的序列项的法律索引。可以让范围从另一个数字开始，或者指定不同的增量（甚至为负；有时这称为“步骤”）：

range(5, 10)
   5, 6, 7, 8, 9

range(0, 10, 3)
   0, 3, 6, 9

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() 函数，参见循环技术 .

如果只打印一个范围，会发生一件奇怪的事情：

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

在许多方面，返回的对象 range() 它的行为就像是一个列表，但事实上它不是。它是一个对象，当您在它上面迭代时，它返回所需序列的连续项，但它实际上并不构成列表，因此节省了空间。

我们说这样的物体是 iterable 也就是说，适合作为函数和构造的目标，这些函数和构造期望从中获得连续的项，直到供应耗尽。我们已经看到 for 语句就是这样一个构造，而接受iterable的函数的一个例子是 sum() ：：

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

稍后我们将看到更多返回iterables并将iterables作为参数的函数。最后，也许你对如何从一个范围中获得一个列表很好奇。解决方法如下：

>>> list(range(4))
[0, 1, 2, 3]

第章数据结构，我们将更详细地讨论 list() .

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

这个 break 语句和C中的语句一样，从最里面的 for 或 while 循环。

循环语句可以具有 else 子句；当循环因ITerable耗尽而终止时执行 for ）或者当条件变为错误时 while ，但当循环被 break 语句。下面的循环就是一个例子，它搜索质数：

>>> 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 循环， not 这个 if 声明）

与循环一起使用时， else 子句与 else A的子句 try 比它和 if 声明：A try 语句的 else 子句在没有异常发生时运行，并且循环的 else 子句在否时运行 break 发生。更多关于 try 语句和异常，请参见处理异常 .

这个 continue 语句也从C中借用，继续循环的下一个迭代：

>>> 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. 定义函数¶

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

>>> 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 .（有关docstrings的更多信息，请参见文档字符串 .）有一些工具可以使用docstring自动生成在线或打印文档，或者让用户交互浏览代码；在您编写的代码中包含docstring是一种良好的做法，因此请养成习惯。

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

函数调用的实际参数（参数）在被调用函数被调用时引入该函数的本地符号表中；因此，使用 按值调用 （在那里 value 始终是一个对象 reference ，而不是对象的值）。 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) 调用A 方法列表对象的 result . 方法是“属于”对象并命名为 obj.methodname 在哪里 obj 是某个对象（这可能是一个表达式），并且 methodname 是由对象类型定义的方法的名称。不同的类型定义不同的方法。不同类型的方法可以具有相同的名称，而不会导致歧义。（可以使用 classes 见 Classes ）方法 append() 示例中显示的是为列表对象定义的；它在列表末尾添加了一个新元素。在这个例子中，它等价于 result = result + [a] ，但效率更高。

4.7. 关于定义函数的更多信息¶

还可以定义参数数目可变的函数。有三种形式可以组合。

4.7.1. 默认参数值¶

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

def ask_ok(prompt, retries=4, reminder='Please try again!'):
    while True:
        ok = input(prompt)
        if ok in ('y', 'ye', 'yes'):
            return True
        if ok 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.7.2. 关键字参数¶

函数也可以使用 keyword arguments 形式的 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 keyword argument 'a'

当窗体的最终形式参数 **name 存在，它接收字典（参见映射类型--- 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.7.3. 特殊参数¶

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

函数定义可能如下所示：

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

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

4.7.3.1. 位置或关键字参数¶

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

4.7.3.2. 仅位置参数¶

更详细地了解一下，可以将某些参数标记为 positional-only .如果 positional-only ，参数的顺序很重要，不能通过关键字传递参数。仅位置参数放置在 / (forward-slash). The / is used to logically separate the positional-only parameters from the rest of the parameters. If there is no `` /``在函数定义中，没有仅位置参数。

参数跟随 / 可能是 positional-or-keyword 或 keyword-only .

4.7.3.3. 仅关键字参数¶

将参数标记为 keyword-only ，指示参数必须通过关键字参数传递，将 * 在第一个参数之前的参数列表中 keyword-only 参数。

4.7.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 an unexpected keyword argument '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 an unexpected keyword argument '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.7.3.5. 扼要重述¶

用例将确定要在函数定义中使用的参数：

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

作为指导：

仅当希望参数名称对用户不可用时才使用位置。如果参数名没有实际意义，如果要在调用函数时强制执行参数的顺序，或者需要使用某些位置参数和任意关键字，则此选项非常有用。
仅当名称有意义且函数定义更易于理解时，或者希望防止用户依赖传递参数的位置时，才使用关键字。
对于API，仅使用positional防止在以后修改参数名时中断API更改。

4.7.4. 任意参数列表¶

最后，最不常用的选项是指定可以使用任意数量的参数调用函数。这些参数将被封装成一个元组（请参见元组和序列）在变参数数目之前，可能会出现零个或更多正常参数。：：

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

通常，这些 variadic 参数将是形式参数列表中的最后一个，因为它们会收集传递给函数的所有剩余输入参数。任何出现在 *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.7.5. 解包参数列表¶

如果参数已经在列表或元组中，但需要为需要单独位置参数的函数调用解包，则会发生相反的情况。例如，内置 range() 函数应单独开始和 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.7.6. 表达式¶

可以使用创建小型匿名函数 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.7.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.7.8. 函数注解¶

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

Annotations 存储在 __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.8. Intermezzo:编码样式¶

既然您将要编写更长、更复杂的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字符。

脚注

1: 事实上， 按对象引用调用 更好的描述，因为如果传递了可变对象，调用者将看到被调用者对其所做的任何更改（插入到列表中的项）。

4. 更多控制流工具¶

4.1. `if` 声明¶

4.2. `for` 声明¶

4.3. 这个 `range()` 功能¶

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

4.5. `pass` 声明¶

4.6. 定义函数¶

4.7. 关于定义函数的更多信息¶

4.7.1. 默认参数值¶

4.7.2. 关键字参数¶

4.7.3. 特殊参数¶

4.7.3.1. 位置或关键字参数¶

4.7.3.2. 仅位置参数¶

4.7.3.3. 仅关键字参数¶

4.7.3.4. 函数示例¶

4.7.3.5. 扼要重述¶

4.7.4. 任意参数列表¶

4.7.5. 解包参数列表¶

4.7.6. 表达式¶

4.7.7. 文档字符串¶

4.7.8. 函数注解¶

4.8. Intermezzo:编码样式¶

Table of Contents

上一个主题

下一个主题

4. 更多控制流工具¶

4.1. if 声明¶

4.2. for 声明¶

4.3. 这个 range() 功能¶

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

4.5. pass 声明¶

4.6. 定义函数¶

4.7. 关于定义函数的更多信息¶

4.7.1. 默认参数值¶

4.7.2. 关键字参数¶

4.7.3. 特殊参数¶

4.7.3.1. 位置或关键字参数¶

4.7.3.2. 仅位置参数¶

4.7.3.3. 仅关键字参数¶

4.7.3.4. 函数示例¶

4.7.3.5. 扼要重述¶

4.7.4. 任意参数列表¶

4.7.5. 解包参数列表¶

4.7.6. 表达式¶

4.7.7. 文档字符串¶

4.7.8. 函数注解¶

4.8. Intermezzo:编码样式¶

4.1. `if` 声明¶

4.2. `for` 声明¶

4.3. 这个 `range()` 功能¶

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

4.5. `pass` 声明¶