4. 其他流程控制工具

除了剛剛介紹過的 while 語(yǔ)句，Python 中也會(huì)使用其他語(yǔ)言中常見的流程控制語(yǔ)句，只是稍有變化。

4.1. if 語(yǔ)句

可能最為人所熟知的編程語(yǔ)句就是 if 語(yǔ)句了。例如

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

可以有零個(gè)或多個(gè) elif 部分，以及一個(gè)可選的 else 部分。 關(guān)鍵字 'elif' 是 'else if' 的縮寫，適合用于避免過多的縮進(jìn)。 一個(gè) if ... elif ... elif ... 序列可以看作是其他語(yǔ)言中的 switch 或 case 語(yǔ)句的替代。

4.2. for 語(yǔ)句

Python 中的 for 語(yǔ)句與你在 C 或 Pascal 中可能用到的有所不同。 Python 中的 for 語(yǔ)句并不總是對(duì)算術(shù)遞增的數(shù)值進(jìn)行迭代（如同 Pascal），或是給予用戶定義迭代步驟和暫停條件的能力（如同 C），而是對(duì)任意序列進(jìn)行迭代（例如列表或字符串），條目的迭代順序與它們?cè)谛蛄兄谐霈F(xiàn)的順序一致。 例如（此處英文為雙關(guān)語(yǔ)）:

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

如果在循環(huán)內(nèi)需要修改序列中的值（比如重復(fù)某些選中的元素），推薦你先拷貝一份副本。對(duì)序列進(jìn)行循環(huán)不代表制作了一個(gè)副本進(jìn)行操作。切片操作使這件事非常簡(jiǎn)單：

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

如果寫成 for w in words:，這個(gè)示例就會(huì)創(chuàng)建無限長(zhǎng)的列表，一次又一次重復(fù)地插入 defenestrate。

4.3. range() 函數(shù)

如果你確實(shí)需要遍歷一個(gè)數(shù)字序列，內(nèi)置函數(shù) range() 會(huì)派上用場(chǎng)。它生成算術(shù)級(jí)數(shù):

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

給定的終止數(shù)值并不在要生成的序列里；range(10) 會(huì)生成10個(gè)值，并且是以合法的索引生成一個(gè)長(zhǎng)度為10的序列。range也可以以另一個(gè)數(shù)字開頭，或者以指定的幅度增加（甚至是負(fù)數(shù)；有時(shí)這也被叫做 '步進(jìn)'）

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

然而，在大多數(shù)這類情況下，使用 enumerate() 函數(shù)比較方便，請(qǐng)參見 循環(huán)的技巧 。

如果你只打印 range，會(huì)出現(xiàn)奇怪的結(jié)果:

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

range() 所返回的對(duì)象在許多方面表現(xiàn)得像一個(gè)列表，但實(shí)際上卻并不是。此對(duì)象會(huì)在你迭代它時(shí)基于所希望的序列返回連續(xù)的項(xiàng)，但它沒有真正生成列表，這樣就能節(jié)省空間。

我們說這樣的對(duì)象是 可迭代的 ，也就是說，適合作為函數(shù)和結(jié)構(gòu)體的參數(shù)，這些函數(shù)和結(jié)構(gòu)體期望在迭代結(jié)束之前可以從中獲取連續(xù)的元素。我們已經(jīng)看到 for 語(yǔ)句就是這樣一個(gè)迭代器。函數(shù) list() 是另外一個(gè)；它從可迭代對(duì)象中創(chuàng)建列表。

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

后面，我們會(huì)看到更多返回可迭代對(duì)象的函數(shù)，和以可迭代對(duì)象作為參數(shù)的函數(shù)。

4.4. break 和 continue 語(yǔ)句，以及循環(huán)中的 else 子句

break 語(yǔ)句，和 C 中的類似，用于跳出最近的 for 或 while 循環(huán).

循環(huán)語(yǔ)句可能帶有一個(gè) else 子句；它會(huì)在循環(huán)遍歷完列表 (使用 for) 或是在條件變?yōu)榧?(使用 while) 的時(shí)候被執(zhí)行，但是不會(huì)在循環(huán)被 break 語(yǔ)句終止時(shí)被執(zhí)行。 這可以通過以下搜索素?cái)?shù)的循環(huán)為例來進(jìn)行說明:

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

（是的，這是正確的代碼。仔細(xì)看： else 子句屬于 for 循環(huán)， 不屬于 if 語(yǔ)句。）

當(dāng)和循環(huán)一起使用時(shí)，else 子句與 try 語(yǔ)句中的 else 子句的共同點(diǎn)多于 if 語(yǔ)句中的子句: try 語(yǔ)句中的 else 子句會(huì)在未發(fā)生異常時(shí)執(zhí)行，而循環(huán)中的 else 子句則會(huì)在未發(fā)生 break 時(shí)執(zhí)行。 有關(guān) try 語(yǔ)句和異常的更多信息，請(qǐng)參閱 處理異常。

continue 語(yǔ)句也是借鑒自 C 語(yǔ)言，表示繼續(xù)循環(huán)中的下一次迭代:

>>> 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 語(yǔ)句

pass 語(yǔ)句什么也不做。當(dāng)語(yǔ)法上需要一個(gè)語(yǔ)句，但程序需要什么動(dòng)作也不做時(shí)，可以使用它。例如:

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

這通常用于創(chuàng)建最小的類:

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

pass 的另一個(gè)可以使用的場(chǎng)合是在你編寫新的代碼時(shí)作為一個(gè)函數(shù)或條件子句體的占位符，允許你保持在更抽象的層次上進(jìn)行思考。 pass 會(huì)被靜默地忽略:

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

4.6. 定義函數(shù)

我們可以創(chuàng)建一個(gè)輸出任意范圍內(nèi) Fibonacci 數(shù)列的函數(shù):

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

關(guān)鍵字 def 引入一個(gè)函數(shù) 定義。它必須后跟函數(shù)名稱和帶括號(hào)的形式參數(shù)列表。構(gòu)成函數(shù)體的語(yǔ)句從下一行開始，并且必須縮進(jìn)。

函數(shù)體的第一個(gè)語(yǔ)句可以（可選的）是字符串文字；這個(gè)字符串文字是函數(shù)的文檔字符串或 docstring 。（有關(guān)文檔字符串的更多信息，請(qǐng)參閱 文檔字符串 部分）有些工具使用文檔字符串自動(dòng)生成在線或印刷文檔，或者讓用戶以交互式的形式瀏覽代碼；在你編寫的代碼中包含文檔字符串是一種很好的做法，所以要養(yǎng)成習(xí)慣。

函數(shù)的 執(zhí)行 會(huì)引入一個(gè)用于函數(shù)局部變量的新符號(hào)表。 更確切地說，函數(shù)中所有的變量賦值都將存儲(chǔ)在局部符號(hào)表中；而變量引用會(huì)首先在局部符號(hào)表中查找，然后是外層函數(shù)的局部符號(hào)表，再然后是全局符號(hào)表，最后是內(nèi)置名稱的符號(hào)表。 因此，全局變量和外層函數(shù)的變量不能在函數(shù)內(nèi)部直接賦值（除非是在 global 語(yǔ)句中定義的全局變量，或者是在 nonlocal 語(yǔ)句中定義的外層函數(shù)的變量），盡管它們可以被引用。

在函數(shù)被調(diào)用時(shí)，實(shí)際參數(shù)（實(shí)參）會(huì)被引入被調(diào)用函數(shù)的本地符號(hào)表中；因此，實(shí)參是通過 按值調(diào)用 傳遞的（其中 值 始終是對(duì)象 引用 而不是對(duì)象的值）。1 當(dāng)一個(gè)函數(shù)調(diào)用另外一個(gè)函數(shù)時(shí)，將會(huì)為該調(diào)用創(chuàng)建一個(gè)新的本地符號(hào)表。

函數(shù)定義會(huì)把函數(shù)名引入當(dāng)前的符號(hào)表中。函數(shù)名稱的值具有解釋器將其識(shí)別為用戶定義函數(shù)的類型。這個(gè)值可以分配給另一個(gè)名稱，該名稱也可以作為一個(gè)函數(shù)使用。這用作一般的重命名機(jī)制:

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

如果你學(xué)過其他語(yǔ)言，你可能會(huì)認(rèn)為 fib 不是函數(shù)而是一個(gè)過程，因?yàn)樗⒉环祷刂?。事?shí)上，即使沒有 return 語(yǔ)句的函數(shù)也會(huì)返回一個(gè)值，盡管它是一個(gè)相當(dāng)無聊的值。這個(gè)值稱為 None （它是內(nèi)置名稱）。一般來說解釋器不會(huì)打印出單獨(dú)的返回值 None ，如果你真想看到它，你可以使用 print()

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

寫一個(gè)返回斐波那契數(shù)列的列表（而不是把它打印出來）的函數(shù)，非常簡(jiǎn)單:

>>> 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 語(yǔ)句會(huì)從函數(shù)內(nèi)部返回一個(gè)值。 不帶表達(dá)式參數(shù)的 return 會(huì)返回 None。 函數(shù)執(zhí)行完畢退出也會(huì)返回 None。

• result.append(a) 語(yǔ)句調(diào)用了列表對(duì)象 result 的 方法 。方法是“屬于”一個(gè)對(duì)象的函數(shù)，它被命名為 obj.methodname ，其中 obj 是某個(gè)對(duì)象（也可能是一個(gè)表達(dá)式）， methodname 是由對(duì)象類型中定義的方法的名稱。不同的類型可以定義不同的方法。不同類型的方法可以有相同的名稱而不會(huì)引起歧義。（可以使用 類 定義自己的對(duì)象類型和方法，請(qǐng)參閱 類 ）示例中的方法 append() 是為列表對(duì)象定義的；它會(huì)在列表的最后添加一個(gè)新的元素。在這個(gè)示例中它相當(dāng)于 result = result + [a] ，但更高效。

4.7. 函數(shù)定義的更多形式

給函數(shù)定義有可變數(shù)目的參數(shù)也是可行的。這里有三種形式，可以組合使用。

4.7.1. 參數(shù)默認(rèn)值

最有用的形式是對(duì)一個(gè)或多個(gè)參數(shù)指定一個(gè)默認(rèn)值。這樣創(chuàng)建的函數(shù)，可以用比定義時(shí)允許的更少的參數(shù)調(diào)用，比如:

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)

這個(gè)函數(shù)可以通過幾種方式調(diào)用:

• 只給出必需的參數(shù)：ask_ok('Do you really want to quit?')

• 給出一個(gè)可選的參數(shù)：ask_ok('OK to overwrite the file?', 2)

• 或者給出所有的參數(shù)：ask_ok('OK to overwrite the file?', 2, 'Come on, only yes or no!')

這個(gè)示例還介紹了 in 關(guān)鍵字。它可以測(cè)試一個(gè)序列是否包含某個(gè)值。

默認(rèn)值是在 定義過程 中在函數(shù)定義處計(jì)算的，所以

i = 5

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

i = 6
f()

會(huì)打印 5。

重要警告： 默認(rèn)值只會(huì)執(zhí)行一次。這條規(guī)則在默認(rèn)值為可變對(duì)象（列表、字典以及大多數(shù)類實(shí)例）時(shí)很重要。比如，下面的函數(shù)會(huì)存儲(chǔ)在后續(xù)調(diào)用中傳遞給它的參數(shù):

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

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

這將打印出

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

如果你不想要在后續(xù)調(diào)用之間共享默認(rèn)值，你可以這樣寫這個(gè)函數(shù):

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

4.7.2. 關(guān)鍵字參數(shù)

也可以使用形如 kwarg=value 的 關(guān)鍵字參數(shù) 來調(diào)用函數(shù)。例如下面的函數(shù):

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, "!")

接受一個(gè)必需的參數(shù)（voltage）和三個(gè)可選的參數(shù)（state, action，和 type）。這個(gè)函數(shù)可以通過下面的任何一種方式調(diào)用:

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

但下面的函數(shù)調(diào)用都是無效的:

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

在函數(shù)調(diào)用中，關(guān)鍵字參數(shù)必須跟隨在位置參數(shù)的后面。傳遞的所有關(guān)鍵字參數(shù)必須與函數(shù)接受的其中一個(gè)參數(shù)匹配（比如 actor 不是函數(shù) parrot 的有效參數(shù)），它們的順序并不重要。這也包括非可選參數(shù)，（比如 parrot(voltage=1000) 也是有效的）。不能對(duì)同一個(gè)參數(shù)多次賦值。下面是一個(gè)因?yàn)榇讼拗贫〉睦?

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

當(dāng)存在一個(gè)形式為 **name 的最后一個(gè)形參時(shí)，它會(huì)接收一個(gè)字典 (參見 映射類型 --- dict)，其中包含除了與已有形參相對(duì)應(yīng)的關(guān)鍵字參數(shù)以外的所有關(guān)鍵字參數(shù)。 這可以與一個(gè)形式為 *name，接收一個(gè)包含除了已有形參列表以外的位置參數(shù)的 元組 的形參 (將在下一小節(jié)介紹) 組合使用 (*name 必須出現(xiàn)在 **name 之前。) 例如，如果我們這樣定義一個(gè)函數(shù):

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

它可以像這樣調(diào)用:

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

當(dāng)然它會(huì)打印:

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

注意打印時(shí)關(guān)鍵字參數(shù)的順序保證與調(diào)用函數(shù)時(shí)提供它們的順序是相匹配的。

4.7.3. 任意的參數(shù)列表

最后，最不常用的選項(xiàng)是可以使用任意數(shù)量的參數(shù)調(diào)用函數(shù)。這些參數(shù)會(huì)被包含在一個(gè)元組里（參見 元組和序列 ）。在可變數(shù)量的參數(shù)之前，可能會(huì)出現(xiàn)零個(gè)或多個(gè)普通參數(shù)。:

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

一般來說，這些 可變參數(shù) 將在形式參數(shù)列表的末尾，因?yàn)樗鼈兪占瘋鬟f給函數(shù)的所有剩余輸入?yún)?shù)。出現(xiàn)在 *args 參數(shù)之后的任何形式參數(shù)都是 ‘僅關(guān)鍵字參數(shù)’，也就是說它們只能作為關(guān)鍵字參數(shù)而不能是位置參數(shù)。:

>>> 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. 解包參數(shù)列表

當(dāng)參數(shù)已經(jīng)在列表或元組中但需要為需要單獨(dú)位置參數(shù)的函數(shù)調(diào)用解包時(shí)，會(huì)發(fā)生相反的情況。例如，內(nèi)置的 range() 函數(shù)需要單獨(dú)的 start 和 stop 參數(shù)。如果它們不能單獨(dú)使用，請(qǐng)使用 * 運(yùn)算符編寫函數(shù)調(diào)用以從列表或元組中解包參數(shù):

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

以同樣的方式，字典可以使用 ** 運(yùn)算符來提供關(guān)鍵字參數(shù):

>>> 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 表達(dá)式

可以用 lambda 關(guān)鍵字來創(chuàng)建一個(gè)小的匿名函數(shù)。這個(gè)函數(shù)返回兩個(gè)參數(shù)的和： lambda a, b: a+b 。Lambda函數(shù)可以在需要函數(shù)對(duì)象的任何地方使用。它們?cè)谡Z(yǔ)法上限于單個(gè)表達(dá)式。從語(yǔ)義上來說，它們只是正常函數(shù)定義的語(yǔ)法糖。與嵌套函數(shù)定義一樣，lambda函數(shù)可以引用所包含域的變量:

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

上面的例子使用一個(gè)lambda表達(dá)式來返回一個(gè)函數(shù)。另一個(gè)用法是傳遞一個(gè)小函數(shù)作為參數(shù):

>>> 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. 文檔字符串

以下是有關(guān)文檔字符串的內(nèi)容和格式的一些約定。

第一行應(yīng)該是對(duì)象目的的簡(jiǎn)要概述。為簡(jiǎn)潔起見，它不應(yīng)顯式聲明對(duì)象的名稱或類型，因?yàn)檫@些可通過其他方式獲得（除非名稱恰好是描述函數(shù)操作的動(dòng)詞）。這一行應(yīng)以大寫字母開頭，以句點(diǎn)結(jié)尾。

如果文檔字符串中有更多行，則第二行應(yīng)為空白，從而在視覺上將摘要與其余描述分開。后面幾行應(yīng)該是一個(gè)或多個(gè)段落，描述對(duì)象的調(diào)用約定，它的副作用等。

Python 解析器不會(huì)從 Python 中刪除多行字符串文字的縮進(jìn)，因此處理文檔的工具必須在需要時(shí)刪除縮進(jìn)。 這是使用以下約定完成的。 文檔字符串第一行 之后 的第一個(gè)非空行確定整個(gè)文檔字符串的縮進(jìn)量。（我們不能使用第一行，因?yàn)樗ǔＥc字符串的開頭引號(hào)相鄰，因此它的縮進(jìn)在字符串文字中不明顯。）然后從字符串的所有行的開頭剝離與該縮進(jìn) "等效" 的空格。 縮進(jìn)更少的行不應(yīng)該出現(xiàn)，但是如果它們出現(xiàn)，則應(yīng)該剝離它們的所有前導(dǎo)空格。 應(yīng)在轉(zhuǎn)化制表符為空格后測(cè)試空格的等效性（通常轉(zhuǎn)化為8個(gè)空格）。

下面是一個(gè)多行文檔字符串的例子:

>>> 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. 函數(shù)標(biāo)注

函數(shù)標(biāo)注 是關(guān)于用戶自定義函數(shù)中使用的類型的完全可選元數(shù)據(jù)信息（有關(guān)詳情請(qǐng)參閱 PEP 3107 和 PEP 484 ）。

函數(shù)標(biāo)注 以字典的形式存放在函數(shù)的 __annotations__ 屬性中，并且不會(huì)影響函數(shù)的任何其他部分。 形參標(biāo)注的定義方式是在形參名稱后加上冒號(hào)，后面跟一個(gè)表達(dá)式，該表達(dá)式會(huì)被求值為標(biāo)注的值。 返回值標(biāo)注的定義方式是加上一個(gè)組合符號(hào) ->，后面跟一個(gè)表達(dá)式，該標(biāo)注位于形參列表和表示 def 語(yǔ)句結(jié)束的冒號(hào)之間。 下面的示例有一個(gè)位置參數(shù)，一個(gè)關(guān)鍵字參數(shù)以及返回值帶有相應(yīng)標(biāo)注:

>>> 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. 小插曲：編碼風(fēng)格

現(xiàn)在你將要寫更長(zhǎng)，更復(fù)雜的 Python 代碼，是時(shí)候討論一下 代碼風(fēng)格 了。 大多數(shù)語(yǔ)言都能以不同的風(fēng)格被編寫（或更準(zhǔn)確地說，被格式化）；有些比其他的更具有可讀性。 能讓其他人輕松閱讀你的代碼總是一個(gè)好主意，采用一種好的編碼風(fēng)格對(duì)此有很大幫助。

對(duì)于Python，PEP 8 已經(jīng)成為大多數(shù)項(xiàng)目所遵循的風(fēng)格指南；它促進(jìn)了一種非常易讀且令人賞心悅目的編碼風(fēng)格。每個(gè)Python開發(fā)人員都應(yīng)該在某個(gè)時(shí)候閱讀它；以下是為你提取的最重要的幾個(gè)要點(diǎn)：

• 使用4個(gè)空格縮進(jìn)，不要使用制表符。

  4個(gè)空格是一個(gè)在小縮進(jìn)（允許更大的嵌套深度）和大縮進(jìn)（更容易閱讀）的一種很好的折中方案。制表符會(huì)引入混亂，最好不要使用它。

• 換行，使一行不超過79個(gè)字符。

  這有助于使用小型顯示器的用戶，并且可以在較大的顯示器上并排放置多個(gè)代碼文件。

• 使用空行分隔函數(shù)和類，以及函數(shù)內(nèi)的較大的代碼塊。

• 如果可能，把注釋放到單獨(dú)的一行。

• 使用文檔字符串。

• 在運(yùn)算符前后和逗號(hào)后使用空格，但不能直接在括號(hào)內(nèi)使用： a = f(1, 2) + g(3, 4)。

• 以一致的規(guī)則為你的類和函數(shù)命名；按照慣例應(yīng)使用 UpperCamelCase 來命名類，而以 lowercase_with_underscores 來命名函數(shù)和方法。 始終應(yīng)使用 self 來命名第一個(gè)方法參數(shù) (有關(guān)類和方法的更多信息請(qǐng)參閱 初探類)。

• 如果你的代碼旨在用于國(guó)際環(huán)境，請(qǐng)不要使用花哨的編碼。Python 默認(rèn)的 UTF-8 或者純 ASCII 在任何情況下都能有最好的表現(xiàn)。

• 同樣，哪怕只有很小的可能，遇到說不同語(yǔ)言的人閱讀或維護(hù)代碼，也不要在標(biāo)識(shí)符中使用非ASCII字符。

備注

1

實(shí)際上，通過對(duì)象引用調(diào)用 會(huì)是一個(gè)更好的表述，因?yàn)槿绻麄鬟f的是可變對(duì)象，則調(diào)用者將看到被調(diào)用者對(duì)其做出的任何更改（插入到列表中的元素）。