除了前面介紹的while語句，Python 還從其它語言借鑒了一些流程控制功能，并有所改變。
也許最有名的語句類型是 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 是可選的。關(guān)鍵字 'elif' 是 'else if' 的縮寫，這個可以有效避免過深的縮進(jìn)。if ... elif ... elif ...序列用于替代其它語言中的switch或case 語句。
Python 中的for語句和 C 或 Pascal 中的略有不同。通常的循環(huán)可能會依據(jù) 一個等差數(shù)值步進(jìn)過程（如 Pascal），或由用戶來定義迭代步驟和中止條件（如 C ），Python 的 for 語句依據(jù)任意序列（鏈表或字符串）中的子項(xiàng)，按它們在序 列中的順序來進(jìn)行迭代。例如（沒有暗指）：
>>> # Measure some strings:
... words = ['cat', 'window', 'defenestrate']
>>> for w in words:
... print(w, len(w))
...
cat 3
window 6
defenestrate 12在迭代過程中修改迭代序列不安全（只有在使用鏈表這樣的可變序列時才會有這 樣的情況）。如果你想要修改你迭代的序列（例如，復(fù)制選擇項(xiàng)），你可以迭代 它的復(fù)本。使用切割標(biāo)識就可以很方便的做到這一點(diǎ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']range() 函數(shù)如果你需要一個數(shù)值序列，內(nèi)置函數(shù)range()會很方便，它生成一個等差級 數(shù)鏈表：
>>> for i in range(5):
... print(i)
...
0
1
2
3
4 range(10) 生成了一個包含 10 個值的鏈表，它用鏈表的索引值填充了這個長度為 10 的列表，所生成的鏈表中不包括范圍中的結(jié)束值。也可以讓 range 操作從另一 個數(shù)值開始，或者可以指定一個不同的步進(jìn)值（甚至是負(fù)數(shù)，有時這也被稱為 “步長”）
range(5, 10)
5 through 9
range(0, 10, 3)
0, 3, 6, 9
range(-10, -100, -30)
-10, -40, -70 需要迭代鏈表索引的話，如下所示結(jié)合使 用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()，請參見Looping Techniques循環(huán)技巧 。
如果你只是打印一個序列的話會發(fā)生奇怪的事情：
>>> print(range(10))
range(0, 10)在不同方面range()函數(shù)返回的對象表現(xiàn)為它是一個列表，但事實(shí)上它并不是。 當(dāng)你迭代它時，它是一個能夠像期望的序列返回連續(xù)項(xiàng)的對象；但為了節(jié)省空間，它并不真正構(gòu)造列表。
我們稱此類對象是可迭代的，即適合作為那些期望從某些東西中獲得連續(xù)項(xiàng)直到結(jié)束的函數(shù)或結(jié)構(gòu)的一個目標(biāo)（參數(shù)）。 我們已經(jīng)見過的 for語句就是這樣一個 迭代器 。list()函數(shù)是另外一個（迭代器），它從可迭代（對象）中創(chuàng)建列表：
>>> list(range(5))
[0, 1, 2, 3, 4]稍后我們會看到更多返回可迭代（對象）和以可迭代（對象）作為參數(shù)的函數(shù)。
break語句和 C 中的類似，用于跳出最近的一級for或while循環(huán)。
循環(huán)可以有一個else子句；它在循環(huán)迭代完整個列表（對于for）或執(zhí)行條件為false （對于while）時執(zhí)行，但循環(huán)被break中止的情況下不會執(zhí)行。以下搜索素數(shù)的示例程序演示了這個子句：
>>> 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(Yes, 這是正確的代碼?？醋屑?xì):else語句是屬于for循環(huán)之中,?不是if語句.)
當(dāng)循環(huán)使用，else子句有更多的共同點(diǎn)與try語句的else子句比它如果語句是：a try語句的else子句時，沒有發(fā)生異常運(yùn)行，一個循環(huán)的else子句時，沒有發(fā)生中斷運(yùn)行。欲了解更多關(guān)于try語句和異常，請?zhí)幚懋惓！?br />
continue語句是從 C 中借鑒來的，它表示循環(huán)繼續(xù)執(zhí)行下一次迭代：
>>> 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 9pass語句什么也不做。它用于那些語法上必須要有什么語句，但程序什么也不做的場合，例如：
>>> while True:
... pass # Busy-wait for keyboard interrupt (Ctrl+C)
...這通常用于創(chuàng)建最小結(jié)構(gòu)的類
>>> class MyEmptyClass:
... pass
...另一方面，pass可以在創(chuàng)建新代碼時用來做函數(shù)或控制體的占位符?？梢宰屇阍诟橄蟮募墑e上思考。pass可以默默的被忽視：
>>> def initlog(*args):
... pass # Remember to implement this!
... 我們可以定義一個函數(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引入了一個函數(shù) 定義 。在其后必須跟有函數(shù)名和包 括形式參數(shù)的圓括號。函數(shù)體語句從一行開始，必須是縮進(jìn)的。
函數(shù)體的第一行可以是一個字符串值，這個字符串是該函數(shù)的文檔字符串 ，或稱 docstring 。（更進(jìn)步的文檔字符串介紹可以在這一節(jié)找Documentation Strings() 文檔字符串 。）有些工具使用文 檔字符串在線的生成及打印文檔，或者允許用戶在代碼中交互式的瀏覽；編寫代 碼進(jìn)加入文檔字符串是個好的風(fēng)格，應(yīng)該養(yǎng)成習(xí)慣。
執(zhí)行函數(shù)時會為局部變量引入一個新的符號表。所有的局部變量都存儲在這個局部符號表中。引用參數(shù)時，會先從局部符號表中查找，然后是全局符號表，然后是內(nèi)置命名表。因此，全局參數(shù)雖然可被引用，但它們不能在函數(shù)中直接 賦值（除非它們用 global 語句名）。
函數(shù)引用的實(shí)際參數(shù)在函數(shù)調(diào)用時引入局部符號表，因此，實(shí)參總是傳值調(diào)用（這里的值總是一個對象引用，而不是該對象的值）[1]一個函數(shù)被另一個函數(shù)調(diào)用時，一個新的局部符號表在調(diào)用過程中被創(chuàng)建。
函數(shù)定義在當(dāng)前符號表中引入函數(shù)名。作為用戶定義函數(shù)，函數(shù)名有一個為解釋器認(rèn)可的類型值。這個值可以賦給其它命名，使其能夠作為一個函數(shù)來使用。這 就像一個重命名機(jī)制
>>> fib
<function fib at 10042ed0>
>>> f = fib
>>> f(100)
0 1 1 2 3 5 8 13 21 34 55 89你可能認(rèn)為 fib 沒有返回值，它不是一個函數(shù)（ function ），而是一個 過程（ procedure ）。實(shí)際上，即使函數(shù)沒有 return 語句，它也 有返回值，雖然是一個不討人喜歡的。這個值被稱為 None （這是一個內(nèi)置命 名）。如果一個值只是 None 的話，通常解釋器不會寫出來，如果你真想要查看 它的話，可以這樣做
>>> fib(0)
>>> print(fib(0))
None定義一個返回斐波那契數(shù)列數(shù)字列表的函數(shù)，而不是打印它，是很簡單的：
>>> 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 語句從函數(shù)中返回一個值，不帶表達(dá)式的return返回None。過程結(jié)束后也會返回None。
語句result.append(b)稱為鏈表對象result 的一個方法。方法是一個“屬于”某個對象的函數(shù)，它被命名為 obj.methodename，這里的obj是某個對象（可能是一個表達(dá)式），methodename是某個在該對象類型定義中的方法的命名。不同的類型定義不同的方法。不同類型可能有同樣名字的方法，但不會混淆。（當(dāng)你定義自己的對象類型和方法時，可能會出現(xiàn)這種情況，class的定義方法詳見類）。示例中演示的append()方法由鏈表對象定義，它向鏈表中加入一個新元素。在示例中它等同于result?=?result?+?[b]，不過效率更高。
在 Python 中，你也可以定義包含若干參數(shù)的函數(shù)。 這里有三種可用的形式，也可以混合使用。
最常用的一種形式是為一個或多個參數(shù)指定默認(rèn)值。 這會創(chuàng)建一個可以使用比定義時允許的參數(shù)更少的參數(shù)調(diào)用的函數(shù)，例如：
def ask_ok(prompt, retries=4, complaint='Yes or no, please!'):
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 OSError('uncooperative user')
print(complaint)這個函數(shù)可以通過幾種不同的方式調(diào)用：
只給出必要的參數(shù)：ask_ok('Do?you?really?want?to?quit?')
給出一個可選的參數(shù)：ask_ok('OK?to?overwrite?the?file?',?2)
或者給出所有的參數(shù)：ask_ok('OK?to?overwrite?the?file?', 2, 'Come on, only yes or no!')
這個例子還介紹了in關(guān)鍵字。它測定序列中是否包含某個確定的值。
默認(rèn)值在函數(shù)定義作用域被解析，如下所示：
i = 5
def f(arg=i):
print(arg)
i = 6
f()將會輸出 5 。
重要警告：默認(rèn)值只被賦值一次。這使得當(dāng)默認(rèn)值是可變對象時會有所不同，比如列表、字典或者大多數(shù)類的實(shí)例。例如，下面的函數(shù)在后續(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]如果你不想讓默認(rèn)值在后續(xù)調(diào)用中累積，你可以像下面一樣定義函數(shù)：
def f(a, L=None):
if L is None:
L = []
L.append(a)
return L函數(shù)可以通過關(guān)鍵字參數(shù) keyword argument 的形式來調(diào)用，形如kwarg=value。例如，以下的函數(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, "!")接受一個必選參數(shù) (voltage) 以及三個可選參數(shù) (state,action, 和type) 可以用以下的任一方法調(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不過以下幾種調(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ù)列表必須先書寫位置參數(shù)然后才是關(guān)鍵字參數(shù)，這里關(guān)鍵字必須來自于形參。 形參是否有一個默認(rèn)值并不重要。 任何參數(shù)都不能被多次賦值——在同一個調(diào)用中，與位置參數(shù)相同的形參名字不能用作關(guān)鍵字。 這里有一個違反此限制而出錯的例子：
>>> def function(a):
... pass
...
>>> function(0, a=0)
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: function() got multiple values for keyword argument 'a'引入一個形如**name的參數(shù)時，它接收一個字典，該字典包含了所有未出現(xiàn)在形式參數(shù)列表中的關(guān)鍵字參數(shù)。這里可能還會組合使用一個形如 *name （下一小節(jié)詳細(xì)介紹） 的形 式參數(shù)，它接收一個元組（下一節(jié)中會詳細(xì)介紹），包含了所有沒有出現(xiàn)在形式 參數(shù)列表中的參數(shù)值（*name 必須在 **name 之前出現(xiàn)）例如，我們這樣定義一個函數(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)
keys = sorted(keywords.keys())
for kw in keys:
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)然它會按如下內(nèi)容打?。?/p>
-- 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注意在打印關(guān)鍵字參數(shù)字典的內(nèi)容前先調(diào)用sort()方法。否則的話，打印參數(shù)時的順序是未定義的。
最后，一個最不常用的選擇是可以讓函數(shù)調(diào)用可變個數(shù)的參數(shù)。這些參數(shù)被包裝進(jìn)一個元組（參見元組和序列）。在這些可變個數(shù)的參數(shù)之前，可以有零到多個普通的參數(shù)。
def write_multiple_items(file, separator, *args):
file.write(separator.join(args))通常，這些?可變?參數(shù)是參數(shù)列表中的最后一個， 因?yàn)樗鼈儗阉械氖Ｓ噍斎雲(yún)?shù)傳遞給函數(shù)。任何出現(xiàn)在*args后的參數(shù)是關(guān)鍵字參數(shù)，這意味著，他們只能被用作關(guān)鍵字，而不是位置參數(shù)。
>>> def concat(*args, sep="/"):
... return sep.join(args)
...
>>> concat("earth", "mars", "venus")
'earth/mars/venus'
>>> concat("earth", "mars", "venus", sep=".")
'earth.mars.venus'另有一種相反的情況: 當(dāng)你要傳遞的參數(shù)已經(jīng)是一個列表，但要調(diào)用的函數(shù)卻接受分開一個個的參數(shù)值。這時候你要把已有的列表拆開來. 例如內(nèi)建函數(shù)?range()?需要要獨(dú)立的?start?,?stop?參數(shù). 你可以在調(diào)用函數(shù)時加一個*?操作符來自動把參數(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]以同樣的方式，可以使用?**?操作符分拆關(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 !出于實(shí)際需要，有幾種通常在函數(shù)式編程語言例如 Lisp 中出現(xiàn)的功能加入到了 Python 。通過?lambda?關(guān)鍵字，可以創(chuàng)建短小的匿名函數(shù)。這里有一個函數(shù)返回它的兩個參數(shù)的和：?lambda?a,?b:?a+b?。 Lambda 形式可以用于任何需要的函數(shù)對象。出于語法限制，它們只能有一個單獨(dú)的表達(dá)式。語義上講，它們只是普通函數(shù)定義中的一個語法技巧。類似于嵌套函數(shù)定義，lambda 形式可以從外部作用域引用變量：
>>> def make_incrementor(n):
... return lambda x: x + n
...
>>> f = make_incrementor(42)
>>> f(0)
42
>>> f(1)
43上面的示例使用一個 lambda 表達(dá)式返回一個函數(shù)。另一個用途是通過一個小函數(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')]這里介紹的文檔字符串的概念和格式。
第一行應(yīng)該是關(guān)于對象用途的簡介。簡短起見，不用明確的陳述對象名或類型，因?yàn)樗鼈兛梢詮膭e的途徑了解到（除非這個名字碰巧就是描述這個函數(shù)操作的動詞）。這一行應(yīng)該以大寫字母開頭，以句號結(jié)尾。
如果文檔字符串有多行，第二行應(yīng)該空出來，與接下來的詳細(xì)描述明確分隔。接下來的文檔應(yīng)該有一或多段描述對象的調(diào)用約定、邊界效應(yīng)等。
Python 的解釋器不會從多行的文檔字符串中去除縮進(jìn)，所以必要的時候應(yīng)當(dāng)自己清除縮進(jìn)。這符合通常的習(xí)慣。第一行之后的第一個非空行決定了整個文檔的縮進(jìn)格式。（我們不用第一行是因?yàn)樗ǔ＞o靠著起始的引號，縮進(jìn)格式顯示的不清楚。）留白“相當(dāng)于”是字符串的起始縮進(jìn)。每一行都不應(yīng)該有縮進(jìn)，如果有縮進(jìn)的話，所有的留白都應(yīng)該清除掉。留白的長度應(yīng)當(dāng)?shù)扔跀U(kuò)展制表符的寬度（通常是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.函數(shù)注釋是完全可選的,任意元數(shù)據(jù)信息用戶定義函數(shù)。無論是Python本身還是以任何方式使用標(biāo)準(zhǔn)庫函數(shù)注釋;這部分只顯示語法。第三方項(xiàng)目是免費(fèi)使用功能注釋文檔類型檢查和其他用途
注釋存儲在函數(shù)的__annotations__屬性字典,不會影響其他功能的一部分。參數(shù)注釋是由冒號后的參數(shù)名稱,后跟一個注釋的值的表達(dá)式。文字- >返回注釋定義,其次是一個表達(dá)式,參數(shù)列表和結(jié)腸之間表示 def 語句的結(jié)束。下面的例子有一個位置參數(shù),一個關(guān)鍵字參數(shù),返回值注釋和廢話：
>>> 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'此時你已經(jīng)可以寫一此更長更復(fù)雜的 Python 程序，是時候討論一下 編碼風(fēng)格 了。大多數(shù)語言可以寫（或者更明白的說， 格式化 ）作幾種不 同的風(fēng)格。有些比其它的更好讀。讓你的代碼對別人更易讀是個好想法，養(yǎng)成良 好的編碼風(fēng)格對此很有幫助。
對于 Python， PEP 8 引入了大多數(shù)項(xiàng)目遵循的風(fēng)格指導(dǎo)。它給出了一個高 度可讀，視覺友好的編碼風(fēng)格。每個 Python 開發(fā)者都應(yīng)該讀一下，大多數(shù)要點(diǎn) 都會對你有幫助：
a = f(1, 2) + g(3, 4) 。統(tǒng)一函數(shù)和類命名。 小寫_和_下劃線?？偸怯?self 作為方法的第一個參數(shù)。 腳注
[1]實(shí)際上，引用對象調(diào)用描述的更為準(zhǔn)確。如果傳入一個可變對像，調(diào)用者會看到調(diào)用操作帶來的任何變化（如子項(xiàng)插入到列表中）。
掃碼關(guān)注鍍金池微信號
手機(jī)訂課，優(yōu)惠多多