1 函式定義
1.1 函式概述
在程式設計中，函式的使用可以提升代碼的復用率和可維護性，
提升代碼的復用率： 程式設計中，一些代碼的功能是相同的，操作是一樣的，只不過針對的資料不一樣，此種情況下，可以將這種功能寫成一個函式模塊，要使用此功能時只需呼叫這個函式模塊就可以了，
提升代碼的可維護性： 使用函式后，實作了代碼的復用，某個功能需要核查或修改時，只需要核查或修改此功能相對應的函式就可以了，對功能的修改可以使呼叫該函式的所有模塊同時生效，極大提升了代碼的可維護性，
內建函式：內建函式也叫內置函式，即系統已經定義好的函式，開發者可以直接呼叫，為了使開發者對內函式和自定義函式有一個直觀的認識，下面給出一個簡單示例，
呼叫系統內建函式pow()：
pow(2, 4)
自定義函式func()：
def func(a, b): return a ** b func(2, 4)
上述代碼中，首先呼叫了Python語言的內建函式pow()進行冪運算；
然后，自定義了一個函式func()，功能是輸出a的b次冪；最后呼叫了自定義函式func()，輸出相應的結果，可以看出，Python語言中函式的定義和使用都是非常便捷的，
1.2 函式的定義
在Python語言中，函式通常是由函式名、引數串列以及一系列陳述句組成的函式體構成的，函式定義的一般格式如下：
def 函式名(引數串列)： 函式體
例如：
def hello(): print("hello") print("world!")
以上實體定義的hello()函式雖然不包含任何引數，但是函式名后的一對括號是不能省略的，在實際應用中，稍復雜的函式通常都會包含一個或多個引數，
下列代碼定義了一個計算矩形面積的函式area()和一個歡迎資訊列印函式welcome()，
# 計算矩形面積的函式area() def area(width, height): return width * height # 輸出漢英資訊的函式 def welcome(name): print("Welcome ", name) # 呼叫welcome函式 welcome('張三') # 呼叫area函式 w = 4 h = 9 print("with=", w, "height=", h, "area=", area(w, h))
上述代碼中，首先定義了area()和welcome()兩個函式，其中函式area()提供了width（寬）和height（高）兩個引數，函式welcome()函式只提供了一個引數name，然后，分別呼叫了area()和welcome()函式，在控制臺輸出了相應的結果，結果如下：
Welcome 張三
with= 4 height= 9 area= 36
以下代碼定義了無任何操作的空函式nop()，
def nop(): pass
在Python代碼中，pass陳述句通常可以用來作為占位符，表示什么操作都不執行，比如在專案起始階段，如果還沒想好函式具體實作時，可以先放置一個pass陳述句，讓代碼先成功運行起來，待專案框架搭建完畢后，在進行相應的具體實作，
通常情況下，在Python語言中定義一個具有特定功能的函式需要符合以下規則：
- 函式代碼塊以def關鍵字開頭，后接函式識別符號名稱和形參串列；
- 任何傳入的引數和自變數必須放在圓括號內；
- 函式的第一行陳述句可以選擇性地使用檔案字串（即函式說明）；
- 函式內容以冒號起始，并且嚴格統一縮進；
- 函式都有回傳值，默認回傳None，
1.3 形參和實參
在編程語言中，函式定義時用的是形參，呼叫時用的是實參
形參（parameter），全稱為"形式引數"，不是實際存在的變數，又稱虛擬變數，形參是在定義函式名和函式體的時候使用的引數，目的是用來接收呼叫該函式時傳入的引數，
實參(argument)，全稱為"實際引數"，是在呼叫時傳遞給函式的引數，實參可以是常量、變數、運算式、函式等，無論實參是何種型別的量，在進行函式呼叫時，它們都必須具有確定的值，以便把這些值傳送給形參，
形參和實參的功能是資料傳送，
在呼叫函式時，實參將賦值給形參，必須注意實參的個數、型別應與形參要一一對應，并且實參必須要有確定的值，形參的作用域一般僅限函式體內部，而實參的作用域根據實際設定而定，
以計算面積的函式為例：
# 計算矩形面積的函式area() def area(width, height): return width * height # 呼叫area函式 w = 4 h = 9 print("with=", w, "height=", h, "area=", area(w, h))
上述代碼中，函式area()定義處的width和height就是形式引數，函式體外定義的變數w和h是實際引數，可以看到，把實參w和h傳入函式體后，就把相應的值賦值給了形參width和height，形參width和height的作用域只限于area()函式體內，而實參w和h作用域則根據外部呼叫處的設定而定，
對于函式形參串列，默認情況下函式呼叫時的引數值與引數串列宣告中定義的順序是一致，Python語言也允許函式呼叫時引數順序與宣告時不一致，即顯示指明關鍵字引數，并根據引數的指定進行賦值，
def func(x, y): print('x+y=', x + y) print('x*y=', x * y) # 等效于func(x=3,y=2)，也等效于func(3,2) func(y=2, x=3)
上述代碼中，函式func()定義時形式引數的順序是func(x, y)，但是呼叫時實際引數的順序確是func(y = 1, x = 2)，這是因為Python語言中提供了一種關鍵字引數的機制，可以給開發者提供更大的靈活性，
1.4 函式的回傳值
函式的回傳值是函式執行完成后，系統根據函式的具體定義回傳給外部呼叫者的值，
在實際開發中，有時不僅僅要執行某個函式的功能，而且還需要把該函式的執行結果作為其他函式或功能的計算單元，所以，函式回傳值是非常有用的
在Python語言中，當函式運行到return陳述句時即執行完畢，同時將結果回傳，因此，可以在函式內部通過條件判斷和回圈設定實作較復雜的邏輯，并回傳預期的結果，如果沒有return陳述句，函式體內所有陳述句執行完畢后默認回傳None，
# 函式定義 def add(x, y): print('x+y=', x + y) return x + y # 函式呼叫 result = add(y=1, x=2) print(result)
上述代碼中，定義的add()函式回傳“x+y”的運算結果，可以看到，呼叫該函式后，把該函式的回傳值賦值給了變數result ，最后輸出了變數result 的值，
另外需要注意的是，在Python語言中，函式也可以有多個回傳值，例如：
# 函式定義 def add(x, y): print('x+y=', x + y) print('x*y=', x * y) return x + y, x * y # 函式呼叫 a, b = add(y=1, x=2) print(a, b)
上述代碼中，定義的add()函式有連個回傳值，分別是“x+y”和“x*y”，可以看到，呼叫該函式后，把該函式的回傳值分別賦值給變數a，b，最后輸出了變數a和變數b的值，
注意： 回傳值和接收變數的對應關系，是按照順序一一對應的
2 函式分類
2.1 內置函式
Python語言中自帶的函式叫做內建函式，這些內建函式對大部分常用操作進行有效封裝，可以直接呼叫，為開發提供了極大便利，由于內建函式是Python語言內置的函式，因此不需要匯入任何函式庫即可直接呼叫，常用的內建函式如圖所示，
在Python語言中，除內建函式外的其他型別函式通常被稱為第三方函式，
- 第三方函式一般是由其它開發者或組織針對某些特定需求撰寫的函式庫，并共享給大家使用，Python語言的強大功能，也正是得益于其豐富的第三方函式庫，不管是內建函式，還是第三方函式，在Python語言中都可以非常方便的使用，
- 要成功呼叫一個內建函式或第三方函式，首先需要知道的是該函式的準確名稱和引數串列資訊，如求絕對值的內建函式abs()有一個數值型別引數，
以下代碼演示了內建函式abs()的呼叫程序及內建函式max()的呼叫，
abs(100) abs(-10) max(1, 2) max(-2, 0, 4, 1)
從上述代碼可以看出，內建函式max（）可以同時回傳多個數值的最大值，而其他編程語言中的類似函式一般只能接收兩個變數，Python語言中內建函式的功能強大可見一斑，
Python語言常用的內建函式還包括資料型別轉換函式，以下代碼演示了常用型別轉換函式的方法，
print("int('12'):", int('12')) print("int(12.3):", int(12.3)) print("float('12.3'):", float('12.3')) print("str(1.23):", str(1.23)) print("str(10):", str(10)) print("bool(1):", bool(1)) print("bool(''):", bool(''))
輸出結果：
int('12'): 12 int(12.3): 12 float('12.3'): 12.3 str(1.23): 1.23 str(10): 10 bool(1): True bool(''): False
上述代碼中，分別演示了內建函式int()、float()、str()和bool()的使用方法，其中，int()函式是把傳入的引數轉換為整數型別，float ()函式是把傳入的引數轉換為浮點型別，str()函式是把傳入的引數轉換為字串型別，bool()函式是把傳入的引數轉換為布爾型別，
在Python語言中，還可以把函式名賦給一個變數，相當于給這個函式起了一個“別名”，如下代碼所示，
a = abs print(a(-1))
這里需注意，abs沒有小括號，因此加了小括號相當于呼叫函式了，Python語言中提供內建函式還有很多，由于篇幅限制，在此不一一列出，內建函式功能強大，理解并熟練掌握能較大提升開發效率，
2.2 自定義函式
當內建函式不能滿足要求時，開發者可以根據實際需要自定義函式，函式自定義完成后，開發者可以在其他代碼處通過函式名呼叫，如下代碼演示了自定義函式printme()的定義和呼叫程序，
# 自定義函式 def printme(str): "函式功能：列印傳入的字串" print(str) # 呼叫自定義函式 printme("呼叫用戶自定義函式！") printme("再次呼叫用戶自定義函式！")
輸出結果：
呼叫用戶自定義函式！
再次呼叫用戶自定義函式！
上述代碼中，自定義了一個函式printme()，并對其進行兩次呼叫，測驗相應功能，在實際開發中，涉及到大量的自定義函式，在自定義函式中，也可以呼叫內建函式或其他自定義函式，自定義函式和內建函式的定義方式是相同，只不過是自定義函式是有開發者定義的，而內建函式是由系統定義的，兩者的呼叫方式都是一樣的，
在Python語言中，內建函式可以直接使用，第三方函式需要使用import命令匯入相應的庫才能使用，對于自定義函式，其定義和呼叫可以在同一個檔案中，也可分離成不同的檔案，
from test import hello hello()
上述代碼演示了函式的定義和呼叫不在一個檔案的情形，首先，將hello()函式定義好并保存為test.py檔案，然后使用Python語言的import指令“from test import hello”將該檔案匯入，可以呼叫hello()函式了，匯入時需要注意test是檔案名并且不含.py擴展名，
3 函式引數
3.1 引數種類
函式引數分為可變型別和不可變型別，其呼叫結果是不同的，
（1）可變型別：類似c++的參考傳遞，如串列、字典等，如果傳遞的引數是可變型別，則在函式內部對傳入引數的修改會影響到外部變數，
（2）不可變型別：類似c++的值傳遞，如整數、字串、元組等，如果傳遞的引數是不可變型別，則在函式內部對傳入引數的修改不會影響到外部變數，
不可變型別引數實體：
def change_int(a): a = 10 b = 2 change_int(b) print(b) # 結果是2
上述實體中，有int型別的物件2，指向它的變數是b，在傳遞給change_int（）函式時，按傳值方式復制了變數b，a和b都指向了同一個int物件，在a=10時，則新生成一個int值物件10，并讓a指向它，
一個更詳細的例子，用id列印出變數的記憶體地址，可以看出函式內核函式外的記憶體發生了變化，說明用的是不同的記憶體單元，存放不同的資料：
可變型別引數實體：
def change_int(my_list): "修改傳入的串列" my_list.append([1, 2, 3]) print("函式內修改后的變數：", my_list) my_list = [10, 20, 30] change_int(my_list) print("函式外變數的值：", my_list)
在呼叫函式時，如果傳入的引數是可變型別，則外部變數也會被更改，在上述例子中，傳入函式的list物件和在末尾添加新內容的mylist物件用的是同一個參考，
從下圖中記憶體地址可以看出，變數的記憶體地址沒有發生變化，說明是用的同一塊記憶體：
- 在定義函式時，開發者把引數的名字和位置確定后，函式的介面定義就完成了，
- Python語言的函式定義非常簡單，但靈活度卻非常大，
- 函式定義中可能包含多個形參，因此函式呼叫中也可能包含多個實參，
- 想讓函式傳遞實參的方式有很多，可使用位置實參，要求傳入引數和定義引數的順序相同；也可使用關鍵字實參，每個實參都由變數名和值組成
3.2 位置引數
呼叫函式時，Python語言必須將函式呼叫中的每個實參都關聯到函式的相應形參，最簡單的關聯方式是基于實參的順序，這種關聯方式被稱為位置實參，下面代碼顯示學生資訊的函式，該函式輸出學生的名字及年齡，
def describe_student(person_name, student_age): "函式功能：顯示學生的資訊" print("my name is ", person_name) print(person_name + "is" + student_age + "years old") describe_student('Jack', '24')
輸出：
my name is Jack Jackis24years old
上述函式describe_student()的定義表明，它需要姓名和年齡兩個引數，呼叫describe_student()函式時，需要按順序提供姓名和年齡引數，函式呼叫時，實參’Jack’ 存盤在形參person_name中，而實參’24’ 存盤在形參student_age 中，
定義了函式后，開發者可以根據需要多次呼叫函式，如果需要再描述一名學生，只需再次呼叫describe_student() 即可，如下代碼所示，
def describe_student(person_name, student_age): "函式功能：顯示學生的資訊" print("my name is ", person_name) print(person_name + "is" + student_age + "years old") describe_student('Jack', '24') describe_student('Bob', '17')
結果：
my name is Jack Jackis24years old my name is Bob Bobis17years old
呼叫函式是一種效率極高的開發方式，如在上例中，開發者只需在函式中撰寫描述學生的代碼一次，以后需要描述新學生時，都可呼叫這個函式，并向它提供新的學生資訊，即便描述全校的學生，依然只需使用一行呼叫函式的代碼，就可實作所需功能，
在函式中，可根據需要使用任意數量的位置實參，Python語言將按順序將函式呼叫中的實參關聯到函式定義中相應的形參，但要注意的是，在使用位置實參來呼叫函式時，如果實參的順序不正確，結果可能出乎意料，如下代碼所示，
def describe_student(person_name, student_age): "函式功能：顯示學生的資訊" print("my name is ", person_name) print(person_name + "is" + student_age + "years old") describe_student('18', 'Jack')
結果：
my name is 18 18isJackyears old
在上述函式呼叫中，開發者先指定名字，再指定學生年齡，由于實參’18’ 在前，這個值將存盤到形參person_name中；同理，‘Jack’ 將存盤到形參student_age中，在實際開發中，如果執行結果和預期不一致，請核查函式呼叫中實參的順序與函式定義中形參的順序是否一致，
3.3 默認引數
撰寫函式時，可給每個形參指定默認值，在呼叫函式時，如果給形參提供了實參，Python語言將使用指定的實參值；否則，將使用形參的默認值，給形參指定默認值后，可在函式呼叫中省略相應的實參，使用默認值可簡化函式呼叫，還可清楚地指出函式的典型用法，如下方式呼叫describe_student（）函式會出現錯誤，
def describe_student(person_name, student_age): "函式功能：顯示學生的資訊" print("my name is ", person_name) print(person_name + "is" + student_age + "years old") describe_student('Jack')
提示錯誤資訊：
Traceback (most recent call last): File "D:/python_demo/demo_2.py", line 88, in <module> describe_student('Jack') TypeError: describe_student() missing 1 required positional argument: 'student_age'
上述代碼中，提示的錯誤資訊很明確，就是呼叫函式describe_student()時缺少了一個位置引數student_age，這個時候，默認引數就排上用場了
若大部分學生的年齡為18歲，開發者可以把第二個引數student_age的默認值設定為18，這樣，當開發者呼叫describe_student(Jack)時，相當于呼叫describe_student(Jack,18) ，如下代碼所示，
def describe_student(person_name, student_age='18'): "函式功能：顯示學生的資訊" print("my name is ", person_name) print(person_name + "is" + student_age + "years old") describe_student('Jack') describe_student('Jack', '18')
結果：
my name is Jack Jackis18years old my name is Jack Jackis18years old
對于年齡不是18歲的學生，就必須明確地傳入student_age，如describe_student(‘Herbie’,19)，從上面的例子可以看出，默認引數可以簡化函式的呼叫，
要注意的是，設定默認引數時，必選引數在前，默認引數在后，否則Python語言的解釋器會報錯，使用默認引數最大的好處是能降低呼叫函式的難度，撰寫一個學生注冊的函式，需要傳入name和gender兩個引數，
def enroll(name, gender): "注冊學生的資訊" print("name:", name) print("gender:", gender) enroll('Jack', 'F')
結果：
name: Jack
gender: F
def enroll(name, gender, age='18', city='Beijing'): "注冊學生的資訊" print("name:", name) print("gender:", gender) print("age:", age) print("city:", city) enroll('Sarah', 'F') print('-' * 70) enroll('Sarah', 'M', '17')
結果：
name: Sarah gender: F age: 18 city: Beijing ---------------------------------------------------------------------- name: Sarah gender: M age: 17 city: Beijing
默認引數降低了函式呼叫的難度，而一旦需要更復雜的呼叫時，又可以傳遞更多的引數來實作，無論是簡單呼叫還是復雜呼叫，函式只需要定義一個；當有多個默認引數時，呼叫時可以按順序提供默認引數，
默認引數很有用，但使用時要牢記一點，默認引數必須指向不可變物件，否則會出現錯誤，如下代碼所示，
def test_add(a=[]): a.append('END') return a print(test_add([1, 2, 3])) print(test_add(['a', 'b', 'c'])) print(test_add()) print(test_add()) print(test_add())
結果：
[1, 2, 3, 'END'] ['a', 'b', 'c', 'END'] ['END'] ['END', 'END'] ['END', 'END', 'END']
從上述代碼可以看出，默認引數是空串列[]，但是函式test_add()似乎每次都“記住了”上次添加了’END’后的list，這是因為在Python語言中，函式在定義的時候，默認引數H的值就被計算出來了，即[]，因為默認引數H也是一個變數，它指向物件[]，每次呼叫該函式，如果改變了H的內容，則下次呼叫時，默認引數的內容就變了，不再是函式定義時的[]了，
開發者也可以用None這個不可變物件來解決報錯問題，如下代碼所示，
def test_add(H=None): if H is None: H = [] H.append('END') return H print(test_add()) print(test_add())
結果：
['END'] ['END']
對于str、None等類似的不可變物件一旦創建，其內部資料就不能修改，這樣就減少了由于修改資料導致的錯誤，
此外，由于物件不變，多執行緒環境下同時讀取物件不需要加鎖，同時讀也沒有問題，開發者在撰寫程式時，如果可以設計一個不可變物件，就盡量設計成不可變物件，
3.4 不定長引數
在Python語言中，函式還可以定義不定長引數，也叫可變引數，給定一組數字a，b，c……，請計算a+b+c+ ……，要定義出這個函式，必須確定輸入的引數，開發者可以把a，b，c……作為一個list或tuple傳進來，
def calc(numbers): sum = 0 for n in numbers: sum = sum + n return sum print(calc([1, 2, 3])) # 結果是6 print(calc([1, 2, 3,4])) # 結果是10
對于以上定義的求和函式，呼叫的時候，需要先組裝出一個list或tuple；在Python語言中，可以在函式引數前面添加“*”號把該引數定義為不定長引數；可以看出，不定長引數的使用使得calc()函式定義和呼叫都變得簡潔，實體如下所示：
def calc(*numbers): sum = 0 for n in numbers: sum = sum + n return sum print(calc(1, 2, 3, 4)) print(calc()) num = [1, 2, 3] print(calc(*num))
結果：
10
0
6
3.5 關鍵字引數
關鍵字實參是傳遞引數時使用“名稱–值”對的方式，在實參中將名稱和值關聯起來，
關鍵字實參讓開發者無需考慮函式呼叫中的實參順序，清楚地指出了函式呼叫中各個值的用途，
關鍵字引數有擴展函式的功能，
3.6 命名關鍵字引數
如果要限制關鍵字引數的名字，可以用命名關鍵字引數，和關鍵字引數**kw不同，如果沒有可變引數，命名關鍵字引數就必須加一個“”號作為特殊分隔符，如果缺少“”，Python語言解釋器將無法識別位置引數和命名關鍵字引數，例如，若只接收age和city作為關鍵字引數，可以采用如下形式，
def enroll(name, gender, *, age, city): print(name, gender, age, city) enroll('Jack', 'M', age='18', city='Beijing')
輸出
Jack M 18 Beijing
結果報錯：
Traceback (most recent call last): File "D:/python_spider/python_demo/demo_2.py", line 119, in <module> enroll('Jack', 'M', '18', 'Beijing') TypeError: enroll() missing 2 required keyword-only arguments: 'age' and 'city'
def enroll(name, gender, *, age='18', city): print(name, gender, age, city) enroll('Jack', 'M', city='Beijing') # 結果是：Jack M 18 Beijing
注意：
*表示不定長引數
**表示不定長的關鍵字引數
3.7 引陣列合
在Python語言中定義函式，開發者可以組合使用這些引數（必選引數、默認引數、可變引數、關鍵字引數和命名關鍵字引數），注意引數定義是有順序的，定義的順序必須是：必選引數、默認引數、可變引數、命名關鍵字引數和關鍵字引數，比如要定義一個函式，包含上述若干種引數，如下代碼所示，
def func(a, b, c=0, *args, **kw): print('a=', a, 'b=', b, 'c=', c, 'args=', args, 'kw=', kw) print(func(1, 2)) # 輸出結果：a= 1 b= 2 c= 0 args= () kw= {} print(func(1, 2, c=3)) # 輸出結果：a= 1 b= 2 c= 3 args= () kw= {} print(func(1, 2, 3, 'a', 'b')) # 輸出結果：a= 1 b= 2 c= 3 args= ('a', 'b') kw= {} print(func(1, 2, 3, 'a', 'b', x=4)) # 輸出結果：a= 1 b= 2 c= 3 args= ('a', 'b') kw= {'x': 4} args = (1, 2, 3, 4) kw = {'x': 5} print(func(*args, **kw)) # 輸出結果：a= 1 b= 2 c= 3 args= (4,) kw= {'x': 5}
4 函式式編程
- 函式式編程是一種編程范式，是面向數學的抽象，其將計算描述為一種運算式求值，
- 函式式編程中的“函式”不是指計算機中的函式，而是指數學中的函式，即自變數的映射，
- 函式式編程的一個特點就是，允許把函式本身作為引數傳入另一個函式，還允許回傳一個函式，
- Python語言對函式式編程提供部分支持，由于允許使用變數，所以說Python語言不是純函式式編程語言，
4.1 高階函式
接受函式為引數，或者把函式作為結果回傳的函式稱為高階函式，例如，若要根據單詞的長度排序，只需把len函式傳給key引數，
fruits=['strawberry','fig','apple','cherry','raspberry','banana'] print(sorted(fruits,key=len)) # 輸出結果如下： # ['fig', 'apple', 'cherry', 'banana', 'raspberry', 'strawberry']
fruits = ['strawberry', 'fig', 'apple', 'cherry', 'raspberry', 'banana'] def reverse(word): return word[::-1] print(reverse('testing')) # 結果是：gnitset print(sorted(fruits, key=reverse)) # 輸出結果如下： # ['banana', 'apple', 'fig', 'raspberry', 'strawberry', 'cherry']
注意，上述例子中串列里的單詞沒有變，開發者只是把反向拼寫當作排序條件，因此各種漿果（berry）都排在一起，在函式式編程范式中，最為人熟知的高階函式有map、filter、reduce 和apply，其中，apply函式在Python2.3中標記為過時，在Python3已移除，
4.2 匿名函式
所謂匿名函式，即不再使用def陳述句這樣標準形式定義的函式，Python語言經常使用lambda來創建匿名函式，lambda 只是一個運算式，函式體比def定義的函式體要簡捷，lambda函式的語法如下所示，
lambda [arg1[,arg2],....argn]]:expression
sum = lambda arg1, arg2: arg1 + arg2 print(sum(1, 2)) # 結果是：3
上述代碼中，第一行定義了一個lambda函式，執行兩個數的和運算，并且把該lambda函式命名為sum，會面的代碼通過sum（）函式即實作了呼叫lambda函式的功能，
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/511021.html
標籤：其他
上一篇：實踐GoF的設計模式：訪問者模式