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 陳述式

在 Python 中的 for 陳述式可能不同於在 C 或 Pascal 中所看到的使用方式。與其只能疊代 (iterate) 一個等差級數（如 Pascal），或給與使用者定義疊代步進方式與結束條件（如 C），Python 的 for 陳述疊代任何序列（list 或者字串）的元素，以他們出現在序列中的順序。例如（無意雙關）：

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

如果你在迴圈中需要修改一個你正在疊代的序列（例如重複一些選擇的元素），那麼會建議你先建立一個序列的拷貝。疊代序列並不暗示建立新的拷貝。此時 slice 語法就讓這件事十分容易完成：

>>> for w in words[:]:  # Loop over a slice copy of the entire list.
...     if len(w) > 6:
...         words.insert(0, w)
...
>>> words
['defenestrate', 'cat', 'window', 'defenestrate']

4.3. range() 函式

如果你需要疊代一個數列的話，使用內建 range() 函式就很方便。它可以生成一等差級數：

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

給定的結束值永遠不會出現在生成的序列中；range(10) 生成的 10 個數值，即對應存取一個長度為 10 的序列內每一個元素的索引值。也可以讓 range 從其他數值計數，或者給定不同的級距（甚至為負；有時稱之為 step）：

range(5, 10)
   5 through 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() 函式將更為方便，詳見迴圈技巧。

如果直接印出一個 range 則會出現奇怪的輸出：

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

在很多情況下，由 range() 回傳的物件的行為如同一個 list，但實際上它並不是。它是一個物件在你疊代時會回傳想要的序列的連續元素，並不會真正建出這個序列的 list，以節省空間。

我們稱這樣的物件為 iterable（可疊代的），意即能作為函式、陳述式中能一直獲取連續元素直到用盡的部件。我們已經看過 for 陳述式可做為如此的 iterator（疊代器）。list() 函式為另一個例子，他可以自 iterable（可疊代物件）建立 list：

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

待會我們可以看到更多函式回傳 iterable 和接受 iterable 為引數。

4.4. break 和 continue 陳述、迴圈內 else 段落

break 陳述，如同 C 語言，終止包含其最內部的 for 或 while 迴圈。

迴圈可以帶有一個 else 段落。當迴圈歷遍疊代的 list （在 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 迴圈，並非 if 陳述。）

當 else 段落與迴圈使用時，相較於搭配 if 陳述使用，它的行為與搭配 try 陳述使用時更為相似：try 的 else 段落在沒有任何例外 (exception) 時執行，而迴圈的 else 段落在沒有任何 break 時執行。更多有關 try 陳述和例外的介紹，見處理例外。

continue 陳述，亦承襲於 C 語言，讓所屬的迴圈繼續執行下個疊代：

>>> for num in range(2, 10):
...     if num % 2 == 0:
...         print("Found an even number", num)
...         continue
...     print("Found a number", num)
Found an even number 2
Found a number 3
Found an even number 4
Found a number 5
Found an even number 6
Found a number 7
Found an even number 8
Found a 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. 定義函式 (function)

我們可以建立一個函式來產生費式數列到任何一個上界：

>>> 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 是個好慣例，應該養成這樣的習慣。

函式執行期間會建立一個新的符號表（symbol table）來儲存該函式內的區域變數。更精確地說，所有在函式內的變數賦值都會把該值儲存在一個區域符號表。然而，在讀取一個變數時，會先從區域符號表起搜尋，其次為所有包含其函式的區域符號表，其次為全域符號表，最後為所有內建的名稱。因此，在函式中，全域變數無法被直接賦值（除非該變數有被 global 陳述句提及），但它們可以被讀取。

在一個函式被呼叫的時候，實際傳入的參數（引數）會被加入至該函數的區域符號表。因此，引數傳入的方式為傳值呼叫 (call by value)（這裡傳遞的「值」永遠是一個物件的參照（reference），而不是該物件的值）。[1] 當一個函式呼叫別的函式時，在被呼叫的函式中會建立一個新的區域符號表。

一個函式定義會把該函式名稱加入至當前的符號表。該函式名稱的值帶有一個型別，並被直譯器辨識為使用者自定函式（user-defined function）。該值可以被賦予給別的變數名，而該變數也可以被當作函式使用。這即是常見的重新命名方式：

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

如果你是來自別的語言，你可能不同意 fib 是個函式，而是個程序 (procedure)，因為它並沒有回傳值。實際上，即使一個函式缺少一個 return 陳述，它亦有一個固定的回傳值。這個值為 None（它是一個內建名稱）。在直譯器中單獨使用 None 時，通常不會被顯示。你可以使用 print() 來看到它：

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

如果要寫一個函式回傳費式數列的 list 而不是直接印出它，這也很容易：

>>> 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) 陳述呼叫了一個 list 物件的 result method（方法）。method 為「屬於」一個物件的函式，命名規則為 obj.methodname，其中 obj 為某個物件（亦可為一表達式），而 methodname 為該 method 的名稱，並由該物件的型別所定義。不同的型別代表不同的 method。不同型別的 method 可以擁有一樣的名稱而不會讓 Python 混淆。（你可以使用 class 定義自己的物件型別和 method，見 类）這裡 append() method 定義在 list 物件中；它會加入一個新的元素在該 list 的末端。這個例子等同於 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. 关键字参数

也可以使用形如 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'

When a final formal parameter of the form **name is present, it receives a dictionary (see 映射类型 — dict) containing all keyword arguments except for those corresponding to a formal parameter. This may be combined with a formal parameter of the form *name (described in the next subsection) which receives a tuple containing the positional arguments beyond the formal parameter list. (*name must occur before **name.) For example, if we define a function like this:

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)
    keys = sorted(keywords.keys())
    for kw in keys:
        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.
----------------------------------------
client : John Cleese
shopkeeper : Michael Palin
sketch : Cheese Shop Sketch

Note that the list of keyword argument names is created by sorting the result of the keywords dictionary’s keys() method before printing its contents; if this is not done, the order in which the arguments are printed is undefined.

4.7.3. 任意的参数列表

最后，最不常用的选项是可以使用任意数量的参数调用函数。这些参数会被包含在一个元组里（参见 Tuples 和序列 (Sequences) ）。在可变数量的参数之前，可能会出现零个或多个普通参数。:

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.7.4. 解包参数列表

The reverse situation occurs when the arguments are already in a list or tuple but need to be unpacked for a function call requiring separate positional arguments. For instance, the built-in range() function expects separate start and stop arguments. If they are not available separately, write the function call with the *-operator to unpack the arguments out of a list or tuple:

>>> 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]

In the same fashion, dictionaries can deliver keyword arguments with the **-operator:

>>> 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.5. 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.7.6. 說明文件字串

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

第一行应该是对象目的的简要概述。为简洁起见，它不应显式声明对象的名称或类型，因为这些可通过其他方式获得（除非名称恰好是描述函数操作的动词）。这一行应以大写字母开头，以句点结尾。

如果文档字符串中有更多行，则第二行应为空白，从而在视觉上将摘要与其余描述分开。后面几行应该是一个或多个段落，描述对象的调用约定，它的副作用等。

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.7. 函数标注

Function annotations are completely optional metadata information about the types used by user-defined functions (see PEP 484 for more information).

Annotations are stored in the __annotations__ attribute of the function as a dictionary and have no effect on any other part of the function. Parameter annotations are defined by a colon after the parameter name, followed by an expression evaluating to the value of the annotation. Return annotations are defined by a literal ->, followed by an expression, between the parameter list and the colon denoting the end of the def statement. The following example has a positional argument, a keyword argument, and the return value annotated:

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

现在你将要写更长，更复杂的 Python 代码，是时候讨论一下 代码风格 了。 大多数语言都能以不同的风格被编写（或更准确地说，被格式化）；有些比其他的更具有可读性。 能让其他人轻松阅读你的代码总是一个好主意，采用一种好的编码风格对此有很大帮助。

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

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

  4个空格是一个在小缩进（允许更大的嵌套深度）和大缩进（更容易阅读）的一种很好的折中方案。制表符会引入混乱，最好不要使用它。

• 换行，使一行不超过79个字符。

  这有助于使用小型显示器的用户，并且可以在较大的显示器上并排放置多个代码文件。

• 使用空行分隔函数和类，以及函数内的较大的代码块。

• 如果可能，把注释放到单独的一行。

• 使用文档字符串。

• 在运算符前后和逗号后使用空格，但不能直接在括号内使用： a = f(1, 2) + g(3, 4)。

• Name your classes and functions consistently; the convention is to use CamelCase for classes and lower_case_with_underscores for functions and methods. Always use self as the name for the first method argument (see 初探类 for more on classes and methods).

• 如果你的代码旨在用于国际环境，请不要使用花哨的编码。Python 默认的 UTF-8 或者纯 ASCII 在任何情况下都能有最好的表现。

• 同样，哪怕只有很小的可能，遇到说不同语言的人阅读或维护代码，也不要在标识符中使用非ASCII字符。

註解

[1]	实际上，通过对象引用调用 会是一个更好的表述，因为如果传递的是可变对象，则调用者将看到被调用者对其做出的任何更改（插入到列表中的元素）。