教你快速學會 Python 函式基礎知識
一、函式基礎
簡單地說，一個函式就是一組Python語句的組合，它們可以在程式中執行一次或多次執行。Python中的函式在其他語言中也叫做過程或子例程，那麼這些被包裝起來的語句通過一個函式名稱來呼叫。
有了函式，我們可以在很大程度上減少複製及貼上程式碼的次數了（相信很多人在剛開始時都有這樣的體驗）。我們可以把相同的程式碼可以提煉出來做成一個函式，在需要的地方只需要呼叫即可。那麼，這樣就提高了程式碼的複用率了，整體程式碼看起來比較簡練，沒有那麼臃腫了。
函式在Python中是最基本的程式結構，用來最大化地讓我們的程式碼進行復用；與此同時，函式可以把一個錯綜複雜的系統分割為可管理的多個部分，簡化程式設計、程式碼複用。
我還是要推薦下我自己建立的Python學習交流群935711829，這是Python學習交流的地方，不管你是小白還是大牛，小編都歡迎，不定期分享乾貨，包括我整理的一份適合零基礎學習Python的資料和入門教程。
接下來我們看看什麼是函式，及函式該如何定義。有兩種方式可以進行函式的定義，分別是def及lambda關鍵字。
1. 函式定義
先總結一下為什麼要使用函式？
-
程式碼複用最大化及最小化冗餘程式碼；
-
過程分解（拆解）。把一個複雜的任務拆解為多個小任務。
函式定義的語法為：
def func_name(arg1, arg2, arg3, ..., argN): statement return value
根據上面定義，可以簡單地描述為：Python中的函式是具有0個或多個引數，具有若干行語句並且具有返回值（返回值可有可無）的一個語句塊（注意縮排）。
那麼我們就定義一個比較簡單的函式，該函式沒有引數，進入ipython互動式環境：
In[1]: def hello():
...: print('Leave me alone, the world')
...:
呼叫（執行）該函式：
In[2]: hello() Leave me alone, the world
我們發現hello()函式並沒有return語句，在Python中，如果沒有顯式的執行return語句，那麼函式的返回值預設為None。
我們說過，定義函式有兩種形式，另外一種形式是使用lambda來定義。使用lambda定義的函式是匿名函式，這個我們在後面的內容進行講解，這裡暫且不表。
二、函式引數
定義函式的時候，我們把引數的名字和位置確定下來，函式的介面定義就完成了。對於函式的呼叫者來說，只需要知道如何傳遞正確的引數，以及函式將返回什麼樣的值就夠了，函式內部的複雜的邏輯被封裝起來，呼叫者無需瞭解。
Python的函式定義非常簡單，但靈活度卻非常大。除了正常定義的必選引數外，還可以使用預設引數、可變引數和關鍵字引數，使得函式定義出來的介面，不但能處理複雜的引數，還可以簡化呼叫者的程式碼。
1. 預設引數
預設引數使得API簡潔，但不失靈活性。當一個引數有預設值時，呼叫時如果不傳遞此引數時，會使用預設值。
def inc(init, step=1): return init + step # 呼叫一下這個函式 >>> inc(3) 4 >>> inc(3, 2) 5
預設引數有一個坑，就是非預設引數要放到預設引數的前面（不然Python的直譯器會報語法錯誤）。允許有多個預設引數，但預設引數需要放在引數列表的最後面。
def append(x, lst=[]): return lst.append(x)
此函式有問題。（函式中的形參是全域性變數？lst在append函式中叫lst，但在全域性作用域中，我們不知道lst具體叫什麼名字。）
修改之後的函式為：
def append(x, lst=None): if lst is None: lst = [] lst.append(x) return lst
通常來說，當預設引數是可變的時候，需要特別注意作用域的問題，我們需要上述的技巧（不可變的資料型別是值傳遞，可變的資料型別是引用傳遞。）。目前可變的物件為list，dict，set，bytearray。
預設引數很有用，但使用不當，也會掉坑裡。預設引數有個最大的坑，演示如下：
# 先定義一個函式，傳入一個list，新增一個END再返回
def add_end(L=[]):
L.append('END')
return L
當我們正常呼叫時，結果似乎不錯：
>>> add_end([1, 2, 3]) [1, 2, 3, 'END'] >>> add_end(['x', 'y', 'z']) ['x', 'y', 'z', 'END']
當我們使用預設引數呼叫時，一開始結果也是對的：
>>> add_end() ['END']
但是，再次呼叫add_end()時，結果就不對了：
>>> add_end() ['END', 'END'] >>> add_end() ['END', 'END', 'END']
原因解釋如下：
Python函式在定義的時候，預設引數L的值就被計算出來了，即[]，因為預設引數L也是一個變數，它指向物件[]，每次呼叫該函式，如果改變了L的內容，則下次呼叫時，預設引數的內容就變了，不再是函式定義時的[]了。
所以，定義預設引數要牢記一點：預設引數必須指向不變物件！
要修改上面的例子，我們可以用None這個不變物件來實現：
def add_end(L=None):
if L is None:
L = []
L.append('END')
return L
為什麼要設計str、None這樣的不變物件呢？因為不變物件一旦建立，物件內部的資料就不能修改，這樣就減少了由於修改資料導致的錯誤。此外，由於物件不變，多工環境下同時讀取物件不需要加鎖，同時讀一點問題都沒有。我們在編寫程式時，如果可以設計一個不變物件，那就儘量設計成不變物件。
2. 位置引數
我們先寫一個計算x^2的函式：
def power(x): return x * x
對於power(x)函式，引數x就是一個位置引數。當我們呼叫power函式時，必須傳入有且僅有的一個引數x：
>>> power(5) 25 >>> power(15) 225
現在，如果我們要計算x^3怎麼辦呢？可以再定義一個power3函式，但是如果要計算x^4、x^5、x^n，怎麼辦？我們不可能定義無限多個函式，我們可以把power(x)修改為power(x, n)，用來計算x^n，說寫就寫：
def power(x, n): s = 1 while n > 0: n = n - 1 s = s * x return s
3. 關鍵字引數
可變引數允許我們傳入0個或任意個引數，這些可變引數在函式呼叫時自動組裝為一個tuple。而關鍵字引數允許你傳入0個或任意個含引數名的引數，這些關鍵字引數在函式內部自動組裝為一個dict。示例如下：
def person(name, age, **kwargs):
print('name:', name, 'age:', age, 'other:', kwargs)
函式person除了必選引數name和age外，還接受關鍵字引數kwargs。在呼叫該函式時，可以只傳入必選引數：
>>> person('LavenLiu', 25)
name: LavenLiu age: 25 other: {}
也可以傳入任意個數的關鍵字引數：
>>> person('LavenLiu', 25)
name: LavenLiu age: 25 other: {}
>>> person('Taoqi', 25, city='Hebei')
name: Taoqi age: 25 other: {'city': 'Hebei'}
>>> person('James', 31, gender='M', job='NBA player')
name: James age: 31 other: {'gender': 'M', 'job': 'NBA player'}
關鍵字引數有什麼用？它可以擴充套件函式的功能。比如，在person函式裡，我們保證能接收到name和age這兩個引數，但是，如果呼叫者願意提供更多的引數，我們也能收到。試想你正在做一個使用者註冊的功能，除了使用者名稱和年齡是必填項外，其他都是可選項，利用關鍵字引數來定義這個函式就能滿足註冊的需求。
和可變引數類似，也可以先組裝出一個dict，然後，把該dict轉換為關鍵字引數傳進去：
>>> kwargs = {'city': 'Hebei', 'job': 'Test'}
>>> person('Taoqi', 25, **kwargs)
name: Taoqi age: 25 other: {'city': 'Hebei', 'job': 'Test'}
4. 位置引數和關鍵字引數
位置引數和關鍵字引數是函式呼叫時的概念。
當預設引數和關鍵字引數結合起來用的時候，很有用。
關鍵字引數必須寫在位置引數之後，否則會丟擲語法錯誤。
def minus(x, y): return x - y minus(3, 5) # 位置引數，位置傳參 minus(5, 3) # 位置引數，位置傳參 minus(x=5, y=3) # 關鍵字引數，關鍵字傳參 minus(y=3, x=5) # 關鍵字引數，關鍵字傳參
位置引數和關鍵字引數可以共存，但是關鍵字引數必須寫到位置引數之後。
5. 可變位置引數
可變位置引數用*定義，在函式體內，可變位置引數是一個元組。
可變位置引數。
In[1]: def fn(*args): ...: print(args) ...: In[2]: fn((1, 2, 3, 4)) ((1, 2, 3, 4),) In[3]: tup01 = (1, 2, 3, 4) In[4]: fn(tup01) ((1, 2, 3, 4),) In[5]: fn(*tup01) (1, 2, 3, 4)
在python的函式中，還可以定義可變引數。可變引數就是傳入的引數個數是可變的。
In[6]: def cacl(*numbers): ...: sum = 0 ...: for n in numbers: ...: sum = sum + n * n ...: return sum ...: In[7]: nums = [1, 2, 3] In[8]: cacl(*nums) # 這裡如果不在nums前面加*，有問題嗎？ Out[8]: 14
6. 可變關鍵字引數
可變關鍵字引數使用**定義，在函式體內，可變關鍵字引數是一個字典。可變關鍵字引數的key都是字串，並且符合識別符號定義規範。
def fn(**kwargs):
print(kwargs)
dict01 = {'name': 'Laven Liu', 'age': 29}
fn(**dict01)
# fn(dict01)
fn(name='Laven Liu', age=29)
{'name': 'Laven Liu', 'age': 29}
{'name': 'Laven Liu', 'age': 29}
-
可變位置引數只能以位置引數的形式呼叫
-
可變關鍵字引數只能以關鍵字引數的形式呼叫
-
可變位置引數必須在可變關鍵字引數之前
In[18]: def fn(*args, **kwargs):
...: print(args)
...: print(kwargs)
...:
In[19]: fn(1, 2, 3, a=1, b=2)
(1, 2, 3)
{'a': 1, 'b': 2}
In[20]: def fn(*args, x, y):
...: print(args)
...: print(x, y)
...:
In[21]: fn(1, 2, 3, 4)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-21-0ab4fbc96a17> in <module>()
----> 1 fn(1, 2, 3, 4)
TypeError: fn() missing 2 required keyword-only arguments: 'x' and 'y'
In[22]: fn(1, 2, x=3, y=4)
(1, 2)
3 4
-
可變引數後置
-
可變引數不和預設引數一起出現
7. 引數組合
在Python中定義函式，可以用必選引數、預設引數、可變引數和關鍵字引數，這4種引數都可以一起使用，或者只用其中某些，但是請注意，引數定義的順序必須是： 必選引數、預設引數、可變引數和關鍵字引數
比如定義一個函式，包含上述4種引數：
>>> def func(a, b, c=0, *args, **kwargs):
... print('a =', a, 'b =', b, 'c =', c, 'args = ', args, 'kwargs = ', kwargs)
在函式呼叫的時候，Python直譯器自動按照引數位置和引數名把對應的引數傳進去。
>>> func(1, 2)
a = 1 b = 2 c = 0 args = () kwargs = {}
>>> func(1, 2, c=3)
a = 1 b = 2 c = 3 args = () kwargs = {}
>>> func(1, 2, 3, 'a', 'b')
a = 1 b = 2 c = 3 args = ('a', 'b') kwargs = {}
>>> func(1, 2, 3, 'a', 'b', x=99)
a = 1 b = 2 c = 3 args = ('a', 'b') kwargs = {'x': 99}
>>>
最神奇的是通過一個tuple和dict，我們也可以呼叫該函式：
>>> args = (1, 2, 3, 4)
>>> kwargs = {'x': 99}
>>> func(*args, **kwargs)
a = 1 b = 2 c = 3 args = (4,) kwargs = {'x': 99}
所以，對於任意函式，都可以通過類似func(*args, **kwargs)的形式呼叫它，無論它的引數是如何定義的。
8. 引數解構
引數解構發生在函式呼叫時，可變引數發生函式定義的時候。引數解構分為兩種形式，一種是位置引數解構，另一種是關鍵字引數解構。
引數結構的兩種形式：
-
位置引數解構，使用一個星號。解構的物件為可迭代物件，解構的結果為位置引數。
-
關鍵字引數解構，使用兩個星號。解構的物件為字典，解構的結果為關鍵字引數。
位置引數解構的一個例子：
In[23]: def fn(a, b, c): ...: print(a, b, c) ...: In[24]: lst = [1, 2, 3] In[25]: fn(lst[0], lst[1], lst[2]) 1 2 3 # 也可以進行如下形式的呼叫 In[26]: fn(*lst) # 這種做法就叫引數解構 1 2 3 # *號可以把線性結構解包成位置引數 lst = [1, 2, 3, 4] fn(*lst) # -> fn(lst[0], lst[1], lst[2], lst[3]) TypeError: fn() takes 3 positional arguments but 4 were given # 這裡就報錯了，本來這個函式只能接收3個位置引數，lst有四個元素，通過引數解構之後，就變成了4個引數，所以就報錯了。
接下來看字典解構的例子：
In[27]: d = {'a': 1, 'b': 2, 'c': 3}
In[28]: fn(**d)
1 2 3
# **可以把字典解構成關鍵字引數
引數解構發生在函式呼叫時。解構的時候，線性結構的解構是位置引數，字典解構是關鍵字引數。
傳參的順序：位置引數，線性結構解構；關鍵字引數，字典解構。儘量的少的同時使用兩種解構，除非你真的知道在做什麼。
In[29]: def fn(a, b, c, d):
...: print(a, b, c, d)
...:
In[30]: fn(0, *[2], c=1, **{'d': 3})
0 2 1 3
9. 引數槽(keyword-only引數)
Python3中引入的。
def fn(a, b, c): print(a, b, c) fn(a=1, b=2, c=3)
如果要強制傳入的引數為關鍵字引數：
def fn(*, a, b, c): print(a, b, c) >>> fn(1, 2, 3) Traceback (most recent call last): File "<pyshell#17>", line 1, in <module> fn(1, 2, 3) TypeError: fn() takes 0 positional arguments but 3 were given >>> fn(a=1, b=2, c=3) 1 2 3 # *之後的引數，必須以關鍵字引數的形式傳遞，稱之為引數槽。
引數槽通常和預設引數搭配使用。
>>> def fn(a, b, *, x, y):
print(a, b)
print(x, y)
>>> fn(1, 2, 3, 4)
Traceback (most recent call last):
File "<pyshell#23>", line 1, in <module>
fn(1, 2, 3, 4)
TypeError: fn() takes 2 positional arguments but 4 were given
>>> fn(1, 2, x=3, y=4)
1 2
3 4
>>> fn(1, 2, **{'x': 3, 'y': 4})
1 2
3 4
def fn(a, b, *):
print(a, b)
def fn(a, b, *):
... print(a, b)
File "<stdin>", line 1
SyntaxError: named arguments must follow bare *
幾個例子：
def fn01(*, x=1, y=5): print(x) print(y) >>> fn01() 1 5 def fn02(x=1, *, y): print(x) print(y) >>> fn02(y=3) 1 3
引數槽之坑：
-
*之後必須有引數
-
非命名引數有預設值時，命名引數可以沒有預設值
-
預設引數應該在每段引數的最後
-
使用引數槽時，不能使用可變位置引數，可變關鍵之引數必須放在命名引數之後
三、高階用法
1. 遞迴函式
在函式內部，可以呼叫其他函式。如果一個函式在內部呼叫自身本身，這個函式就是遞迴函式。
def fact(n): if n==1: return 1 return n*fact(n-1)
使用遞迴函式的優點是邏輯簡單清晰，缺點是過深的呼叫會導致棧溢位。
針對尾遞迴優化的語言可以通過尾遞迴防止棧溢位。尾遞迴事實上和迴圈是等價的，沒有迴圈語句的程式語言只能通過尾遞迴實現迴圈。
2. 匿名函式 lambda
python 使用 lambda 來建立匿名函式。
lambda只是一個表示式，函式體比def簡單很多。
lambda的主體是一個表示式，而不是一個程式碼塊。僅僅能在lambda表示式中封裝有限的邏輯進去。
lambda函式擁有自己的名字空間，且不能訪問自有引數列表之外或全域性名字空間裡的引數。
雖然lambda函式看起來只能寫一行，卻不等同於C或C++的行內函數，後者的目的是呼叫小函式時不佔用棧記憶體從而增加執行效率。
fib = lambda n,x=0,y=1:x if not n else fib(n-1,y,x+y) print(fib(20))
3. Python函式中的多型
一個操作的意義取決於被操作物件的型別：
def times(x,y):
return x*y
>>>times(2,4)
>>>8
times('Python',4) # 傳遞了與上不同的資料型別 'PythonPythonPythonPython'
四、總結
Python的函式具有非常靈活的引數形態，既可以實現簡單的呼叫，又可以傳入非常複雜的引數。
預設引數一定要用不可變物件，如果是可變物件，執行會有邏輯錯誤！
要注意定義可變引數和關鍵字引數的語法：
*args是可變引數，args接收的是一個tuple；
**kwargs是關鍵字引數，kwargs接收的是一個dict。
以及呼叫函式時如何傳入可變引數和關鍵字引數的語法：
可變引數既可以直接傳入：func(1, 2, 3)，又可以先組裝list或tuple，再通過*args傳入：func(*(1, 2, 3))；
關鍵字引數既可以直接傳入：func(a=1, b=2)，又可以先組裝dict，再通過kwargs傳入：func({'a': 1, 'b': 2})。
使用*args和**kwargs是Python的習慣寫法，當然也可以用其他引數名，但最好使用習慣用法。