Python程式碼結構：函式

歡迎關注「issnail」

“一起學習，一起成長！“

1。定義函式與呼叫函式

定義python函式：依次輸入def、函式名、帶有函式引數的圓括號，最後緊跟一個冒號（：）

函式命名規範：必須使用字母或者下劃線_開頭，僅能含有字母、數字和下劃線；

定義函式：

def do_nothing（）：

。。。 pass

注：python函式中的pass表明函式沒有做任何事情。和這一頁故意留白有同樣的作用。

呼叫函式：

do_nothing（）

注意：

寫在def語句中函式名後面的變數通常叫做函式的形參，而呼叫函式的時提供的值時實參，或者稱為引數。

引入引數（基礎）：

def echo（anything）：

。。。 return anything+“ ”+anything

傳入到函式的值稱為引數。

輸入引數函式例子：

需求：呼叫commentary函式，把color作為輸入的引數，使它返回對顏色的評論字串：

def commentary（color）：

if color==‘red’：

return “It‘s a tomato”

elif color==’green‘：

return “It’s a green pepper”

elif color==‘bee purple’：

return “I don‘t hnow what it is，but noly bees can see it。”

else：

return “I’ve never heard of the color ”+color+“。”

傳入字串引數‘blue’，呼叫函式commentary（）：

comment=commentary（‘blue’）

這個函式做了以下事情：

把‘blue’賦值給函式的內部引數color；

執行if-elif-else的邏輯鏈；

返回一個字串；

將該字串賦值給變數comment；

得到返回值：

>>>print（comment）

I‘ve never heard of the color blue。

如果函式不顯示呼叫return函式，那麼會預設返回None。

2。位置引數

位置引數：傳入引數的值是按照順序依次複製過去的。

弊端：必須熟記每個位置的引數的含義。

下面建立一個帶有位置引數的函式，並且返回一個字典：

def menu（wine，entree，dessert）：

return {’wine‘：wine，’entree‘：entree，’dessert‘：dessert}

呼叫函式：

>>>menu（’beef‘，’bagel‘，’bordeaux‘）

{’dessert‘：’bordeau‘，’wine‘：’beef‘，’entree‘：’bagel‘}

3。關鍵字引數

為了避免位置引數帶來的混亂，呼叫函式時可以指定對應引數的名字，甚至可以採用與函式定義不同的順序呼叫：

>>>menu（entree=’beef‘，dessert=’bagel‘，wine=’bordeaux‘）

{’dessert‘：’bagel‘，’wine‘：’bordeaux‘，’entree‘：’beef‘}

把位置引數和關鍵字引數混合起來，位置引數必須放置於關鍵詞引數之前：

>>>menu（’frontenac‘，dessert=’flan‘，entree=’fish‘）

{’entree‘：’fish‘，’dessert‘：’flan‘，’wine‘：’frontenac‘}

4。指定預設引數值

指定預設引數值：

>>>def menu（wine，entree，dessert=’pudding‘）

。。。 return {’wine‘：wine，’entree‘：entree，’dessert‘：dessert}

實用例子：

說明：函式buggy（）在每次呼叫時，新增引數arg到一個空的列表result，然後列印輸出一個單值列表。但是存在一個問題：只有在第一次呼叫時列表是空的，第二次呼叫時就會存在之前呼叫的返回值：

>>>def buggy（arg，result=［］）：

。。。 result。append（arg）

。。。 print（result）

>>>buggy（’a‘）

［’a‘］

>>>buggy（’b‘）

［’a‘，’b‘］

如果寫成下面的樣子就回解決剛才的問題：

>>>def works（arg）

。。。 result=［］

。。。 result。append（arg）

。。。 return result

>>>works（’a‘）

［’a‘］

>>>wokers（’b‘）

［’b‘］

這樣的修改也為了表明是第一次呼叫跳過一些操作：

>>>def nonbuggy（arg，result=None）：

。。。 if result is None：

。。。 result=［］

。。。 result。append（arg）

。。。 print（result）

>>>nonbuggy（’a‘）

［’a‘］

>>>nonbuggy（’b‘）

［’b‘］

5。使用*收集位置引數（元組）

星號（*）將一組可變數量的位置引數集合成引數值的元祖，例如：

>>>def print_args（*args）：

。。。 print（’Positional argument tuple：‘，args）

無引數呼叫，什麼都不返回：

>>>print_args（）

Positional argument tuple：（）

給函式傳入的所有引數都會以元祖的形式返回輸出：

>>>print_args（3，2，1，’wait！‘，’uh。。。‘）

Positional argument tuple：（3，2，1，’wait！‘，’uh。。。‘）

應用：

說明：這樣的技巧對於編寫像print（）一樣接受可變數量的引數的函式是非常有用的。如果你的函式同時有限定的位置引數，那麼*args會收集剩下的引數：

>>>def print_more（required1，required2，*args）：

。。。 print（’Need this one：‘，required1）

。。。 print（’Need this one too：‘required2）

。。。 print（’All the rest：‘，args）

>>>print_more（’cap‘，’gloves‘，’scarf‘，’mostache‘，’mustache wax‘）

Need this one：cap

Need this one too：gloves

All the rest：（’scarf‘，’mostache‘，’mustache wax‘）

當使用*時，不一定要把元祖引數命名為args，但這是python中的一個常見做法。

6。使用**收集關鍵字引數（字典）

概述：

使用兩個星號（**）可以將引數收集到一個字典中，引數的名字是字典的鍵，對應引數的值是字典的值。

>>>def print_kwargs（**kwargs）：

。。。 print（’Keyword arguments：‘，kwargs）

使用關鍵字引數呼叫函式：

>>>print_kwargs（wine=’merlot‘，entree=’mutton‘，dessert=’macaroon‘）

Keyword arguments：{’wine‘：’merlot‘，’entree‘：’mutton‘，’dessert‘：’macaroon‘}

如果把帶有*args和**kwargs的位置引數混合起來，他們必須按照順序出現。

7。文件化函式（給函式寫文件）

概述：如果想要給函式寫文件，讓其他使用該函式的人能理解的話：

加入註釋（以#開頭）；

直接寫上字串（又稱文件字串）。如果在函式的開頭寫下字串，它就會作為函式的一部分進行儲存，這稱為文件字串。

文件字串：

>>>def echo（anything）

。。。 ’echo returns its input argument‘

。。。 return anything

可以定義非常長的文件字串，加上詳細的規範說明，例如：

def print_if_true（thing，check）：

’‘’

Prints the first argument if a second argument is true。

The operation is：

1。Check whether the *second* argument is true。

2。If it is，print the *first* argument。

呼叫Python函式help（）列印輸出一個函式的文件字串：

>>>help（echo）

Help on function echo in module _main_：

echo（anything）：

echo returns its input argument

如果僅僅想得到文件字串：

>>>print（echo。_doc_）

echo returns its input argument

注意：

_doc_是函式屬性，作為函式中變數的文件字串的名字。屬性名中的雙下劃線表示它是個特殊屬性

8。一等公民：函式

Python中一切都是物件，包括數字、字串、元組、列表、字典和函式。

函式是Python中的一等公民，可以把它們（返回值）賦給變數，可以作為引數被其他函式呼叫，也可以從其他函式中返回值。它可以幫助在python中實現其他語言難以實現的功能。

舉例如下：

No。1

>>>def answer（）：

。。。 print（42）

>>>answer（）

42

No。2

>>>def run_something（func）：

。。。 func（）

>>>run_something（answer）

42

注意：傳給函式的是answer，不是answer（）。在Python中圓括號意味著呼叫函式。在沒有圓括號的情況下，python會把函式當作普通物件。這是因為在其他情況下，它也僅僅代表一個物件：

>>>type（run_something）

No。3

>>>def add_args（arg1，arg2）：

。。。 print（arg1+arg2）

add_args的型別是？

>>>type（add_args）

No。4

此刻定義一個函式run_something_with_args，它帶有三個引數：

func-可以執行的函式

arg1-func函式的第一個引數

arg2-func函式的第二個引數

>>>def run_something_with_args（func，arg1，arg2）：

。。。 func（arg1，arg2）

當呼叫run_something_with_args（）時，呼叫方傳來的函式賦值給func引數，而arg1和arg2從引數列表中獲得值。然後執行帶引數的func（arg1，arg2）。

>>>run_something_with_args（add_args，5，9）

14

程式最後執行：

func（5，9）

同樣可以在此用上*args（位置引數收集）和**args（關鍵字引數收集）的技巧：

>>>def sum_args（*args）：

。。。 return sum（args）

再定義一個新的函式run_with_positional_args（），接收一個函式名以及任意數量的位置引數：

>>>def run_with_positional_args（func，*args）：

。。。 return func（*args）

直接呼叫：

>>>run_with_positional_args（sum_args，1，2，3，4）

10

注意：同樣可以把函式作為列表、元組、集合和字典的元素。函式名時不可變的，因此可以把函式用作字典的鍵。

9。內部函式

在Python中，可以在函式中定義另外一個函式：

>>>def outer（a，b）：

。。。 def inner（c，d）：

。。。 return c+d

。。。 return inner（a，b）

>>>outer（4，7）

特點：當需要在函式內部多次執行復雜的任務時，內部函式時非常有用的，從而避免了迴圈和程式碼的堆疊重複。

>>>def knights（saying）：

。。。 def inner（quote）：

。。。 return “We are the knights who say：‘%s’” % quote

。。。 return inner（saying）

>>>knights（‘Ni！’）

“We are the knights who say：‘Ni！’”

10。閉包

概述：內部函式可以看作一個閉包。閉包是一個可以由另一個函式動態生成的函式，並且可以改變和儲存函式外建立的變數的值。

>>>def knights2（saying）：

。。。 def inner2（）：

。。。 return “We are the knights who say：‘%s’ %saying”

。。。 return inner2

inner2（）函式可以得到saying引數的值並且記錄下來。return inner2這一行返回的是inner2函式的複製（沒有直接呼叫）。所以它就是一個閉包：一個被動態建立的可以記錄外部變數的函式。

>>>a=knights2（‘Duck’）

>>>b=knights2（‘Hasenpfeffer’）

>>>type（a）

>>>type（b）

如果呼叫它們，它們會記錄被knights2函式建立時的外部變數saying：

>>>a（）

“We are the knights who say：‘Duck’ ”

>>>b（）

“We are the knights who say：‘Hasenpfeffer’ ”

11。匿名函式：lambda（）函式

Python中，lambda函式是用一條語句表達的匿名函式。可以用它來代替小的函式。

>>>def edit_story（words，func）：

。。。 for word in words：

。。。 print（func（word））

>>>stairs=［‘thud’，‘meow’，‘thud’，‘hiss’］

對於函式，它要將每個單詞的首字母變為大寫，然後在末尾加上感嘆號：

>>>def enliven（word）： #讓這些單詞更有情感

>>>edit_story（stairs，enliven）

Thud！

Meow！

Thud！

Hiss！

最後，到了lambda。enliven（）函式可以簡潔地用下面的一個lambda代替：

>>>edit_story（stairs，lambda word：word。capitalize（） + ‘！’）

Thud！

Meow！

Thud！

Hiss！

lambda函式接收一個引數word。在冒號和末尾圓括號之間的部分為函式的定義。

在定義很多小的函式以及記住它們的名字時，lambda會非常有用。尤其實在圖形使用者介面中，可以使用lambda來定義回撥函式。

12。生成器

生成器是用來建立python序列的一個物件。使用它可以迭代龐大的序列，且不需要在記憶體中建立和儲存整個序列。通常，生成器是為迭代器產生資料的。

>>>sum（range（1，101））

5050

特點：每次迭代生成器時，它會記錄上一次呼叫的位置，並且返回下一個值。這一點和普通的函式是不一樣的，一般函式都不記錄前一次呼叫，而且都會在函式的第一行開始執行。

如果你想建立一個比較大的序列，使用生成器推導的程式碼會很長，這時可以嘗試寫一個生成器函式。生成器函式和普通函式類似，但是它的返回值使用yield語句宣告而不是return。

>>>def my_range（first=0，last=10，step=1）

。。。 number=first

。。。 while number

。。。 yield number

。。。 number +=step

>>>my_range

>>>ranger=my_range（1，5）

>>>ranger

>>>for x in ranger：

。。。 print（x）

。。。

1

2

3

4

「親，如果筆記對您有幫助，收藏的同時，記得給點個贊、加個關注哦！感謝！」

「誠邀關注“issnail”，會有驚喜哦！」

「文中程式碼均親測過，若有錯誤之處，歡迎批評指正，一起學習，一起成長！」

參考書目：python語言及其應用