一、函數(shù)基礎

簡單地說，一個函數(shù)就是一組Python語句的組合，它們可以在程序中運行一次或多次運行。Python中的函數(shù)在其他語言中也叫做過程或子例程，那么這些被包裝起來的語句通過一個函數(shù)名稱來調(diào)用。

[[271067]]

有了函數(shù)，我們可以在很大程度上減少復制及粘貼代碼的次數(shù)了(相信很多人在剛開始時都有這樣的體驗)。我們可以把相同的代碼可以提煉出來做成一個函數(shù)，在需要的地方只需要調(diào)用即可。那么，這樣就提高了代碼的復用率了，整體代碼看起來比較簡練，沒有那么臃腫了。

函數(shù)在Python中是很基本的程序結構，用來充分地讓我們的代碼進行復用;與此同時，函數(shù)可以把一個錯綜復雜的系統(tǒng)分割為可管理的多個部分，簡化編程、代碼復用。

接下來我們看看什么是函數(shù)，及函數(shù)該如何定義。有兩種方式可以進行函數(shù)的定義，分別是def及l(fā)ambda關鍵字。

1. 函數(shù)定義

先總結一下為什么要使用函數(shù)?

代碼復用***化及最小化冗余代碼;過程分解(拆解)。把一個復雜的任務拆解為多個小任務。

函數(shù)定義的語法為：

def func_name(arg1, arg2, arg3, ..., argN):  
statement  
return value 

根據(jù)上面定義，可以簡單地描述為：Python中的函數(shù)是具有0個或多個參數(shù)，具有若干行語句并且具有返回值(返回值可有可無)的一個語句塊(注意縮進)。

那么我們就定義一個比較簡單的函數(shù)，該函數(shù)沒有參數(shù)，進入ipython交互式環(huán)境：

In[1]: def hello(): 
...: print('Leave me alone, the world')  
...: 

調(diào)用(執(zhí)行)該函數(shù)：

In[2]: hello() 
Leave me alone, the world 

我們發(fā)現(xiàn)hello()函數(shù)并沒有return語句，在Python中，如果沒有顯式的執(zhí)行return語句，那么函數(shù)的返回值默認為None。

我們說過，定義函數(shù)有兩種形式，另外一種形式是使用lambda來定義。使用lambda定義的函數(shù)是匿名函數(shù)，這個我們在后面的內(nèi)容進行講解，這里暫且不表。

二、函數(shù)參數(shù)

定義函數(shù)的時候，我們把參數(shù)的名字和位置確定下來，函數(shù)的接口定義就完成了。對于函數(shù)的調(diào)用者來說，只需要知道如何傳遞正確的參數(shù)，以及函數(shù)將返回什么樣的值就夠了，函數(shù)內(nèi)部的復雜的邏輯被封裝起來，調(diào)用者無需了解。

Python的函數(shù)定義非常簡單，但靈活度卻非常大。除了正常定義的必選參數(shù)外，還可以使用默認參數(shù)、可變參數(shù)和關鍵字參數(shù)，使得函數(shù)定義出來的接口，不但能處理復雜的參數(shù)，還可以簡化調(diào)用者的代碼。

1. 默認參數(shù)

默認參數(shù)使得API簡潔，但不失靈活性。當一個參數(shù)有默認值時，調(diào)用時如果不傳遞此參數(shù)時，會使用默認值。

def inc(init, step=1): 
return init + step 
# 調(diào)用一下這個函數(shù) 
>>> inc(3) 
4 
>>> inc(3, 2) 
5 

默認參數(shù)有一個坑，就是非默認參數(shù)要放到默認參數(shù)的前面(不然Python的解釋器會報語法錯誤)。允許有多個默認參數(shù)，但默認參數(shù)需要放在參數(shù)列表的***面。

def append(x, lst=[]): 
return lst.append(x) 

此函數(shù)有問題。(函數(shù)中的形參是全局變量?lst在append函數(shù)中叫l(wèi)st，但在全局作用域中，我們不知道lst具體叫什么名字。)

修改之后的函數(shù)為：

def append(x, lst=None): 
if lst is None: 
lst = [] 
lst.append(x) 
return lst 

通常來說，當默認參數(shù)是可變的時候，需要特別注意作用域的問題，我們需要上述的技巧(不可變的數(shù)據(jù)類型是值傳遞，可變的數(shù)據(jù)類型是引用傳遞。)。目前可變的對象為list，dict，set，bytearray。

默認參數(shù)很有用，但使用不當，也會掉坑里。默認參數(shù)有個很大的坑，演示如下：

# 先定義一個函數(shù)，傳入一個list，添加一個END再返回

def add_end(L=[]): 
L.append('END') 
return L 

當我們正常調(diào)用時，結果似乎不錯：

>>> add_end([1, 2, 3]) 
[1, 2, 3, 'END'] 
>>> add_end(['x', 'y', 'z']) 
['x', 'y', 'z', 'END'] 

當我們使用默認參數(shù)調(diào)用時，一開始結果也是對的：

>>> add_end() 
['END'] 

但是，再次調(diào)用add_end()時，結果就不對了：

>>> add_end() 
['END', 'END'] 
>>> add_end() 
['END', 'END', 'END'] 

原因解釋如下：

Python函數(shù)在定義的時候，默認參數(shù)L的值就被計算出來了，即[]，因為默認參數(shù)L也是一個變量，它指向?qū)ο骩]，每次調(diào)用該函數(shù)，如果改變了L的內(nèi)容，則下次調(diào)用時，默認參數(shù)的內(nèi)容就變了，不再是函數(shù)定義時的[]了。

所以，定義默認參數(shù)要牢記一點：默認參數(shù)必須指向不變對象!

要修改上面的例子，我們可以用None這個不變對象來實現(xiàn)：

def add_end(L=None): 
if L is None: 
L = [] 
L.append('END') 
return L 

為什么要設計str、None這樣的不變對象呢?因為不變對象一旦創(chuàng)建，對象內(nèi)部的數(shù)據(jù)就不能修改，這樣就減少了由于修改數(shù)據(jù)導致的錯誤。此外，由于對象不變，多任務環(huán)境下同時讀取對象不需要加鎖，同時讀一點問題都沒有。我們在編寫程序時，如果可以設計一個不變對象，那就盡量設計成不變對象。

2. 位置參數(shù)

我們先寫一個計算x^2的函數(shù)：

def power(x): 
return x * x 

對于power(x)函數(shù)，參數(shù)x就是一個位置參數(shù)。當我們調(diào)用power函數(shù)時，必須傳入有且僅有的一個參數(shù)x：

>>> power(5) 
25 
>>> power(15) 
225 

現(xiàn)在，如果我們要計算x^3怎么辦呢?可以再定義一個power3函數(shù)，但是如果要計算x^4、x^5、x^n，怎么辦?我們不可能定義***多個函數(shù)，我們可以把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. 關鍵字參數(shù)

可變參數(shù)允許我們傳入0個或任意個參數(shù)，這些可變參數(shù)在函數(shù)調(diào)用時自動組裝為一個tuple。而關鍵字參數(shù)允許你傳入0個或任意個含參數(shù)名的參數(shù)，這些關鍵字參數(shù)在函數(shù)內(nèi)部自動組裝為一個dict。示例如下：

def person(name, age, **kwargs): 
print('name:', name, 'age:', age, 'other:', kwargs) 

函數(shù)person除了必選參數(shù)name和age外，還接受關鍵字參數(shù)kwargs。在調(diào)用該函數(shù)時，可以只傳入必選參數(shù)：

>>> person('LavenLiu', 25) 
name: LavenLiu age: 25 other: {} 

也可以傳入任意個數(shù)的關鍵字參數(shù)：

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

關鍵字參數(shù)有什么用?它可以擴展函數(shù)的功能。比如，在person函數(shù)里，我們保證能接收到name和age這兩個參數(shù)，但是，如果調(diào)用者愿意提供更多的參數(shù)，我們也能收到。試想你正在做一個用戶注冊的功能，除了用戶名和年齡是必填項外，其他都是可選項，利用關鍵字參數(shù)來定義這個函數(shù)就能滿足注冊的需求。

和可變參數(shù)類似，也可以先組裝出一個dict，然后，把該dict轉(zhuǎn)換為關鍵字參數(shù)傳進去：

>>> kwargs = {'city': 'Hebei', 'job': 'Test'} 
>>> person('Taoqi', 25, **kwargs) 
name: Taoqi age: 25 other: {'city': 'Hebei', 'job': 'Test'} 

4. 位置參數(shù)和關鍵字參數(shù)

位置參數(shù)和關鍵字參數(shù)是函數(shù)調(diào)用時的概念。

當默認參數(shù)和關鍵字參數(shù)結合起來用的時候，很有用。

關鍵字參數(shù)必須寫在位置參數(shù)之后，否則會拋出語法錯誤。

def minus(x, y): 
return x - y 
minus(3, 5) # 位置參數(shù)，位置傳參 
minus(5, 3) # 位置參數(shù)，位置傳參 
minus(x=5, y=3) # 關鍵字參數(shù)，關鍵字傳參 
minus(y=3, x=5) # 關鍵字參數(shù)，關鍵字傳參 

位置參數(shù)和關鍵字參數(shù)可以共存，但是關鍵字參數(shù)必須寫到位置參數(shù)之后。

5. 可變位置參數(shù)

可變位置參數(shù)用*定義，在函數(shù)體內(nèi)，可變位置參數(shù)是一個元組。

可變位置參數(shù)。

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的函數(shù)中，還可以定義可變參數(shù)。可變參數(shù)就是傳入的參數(shù)個數(shù)是可變的。

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. 可變關鍵字參數(shù)

可變關鍵字參數(shù)使用**定義，在函數(shù)體內(nèi)，可變關鍵字參數(shù)是一個字典?？勺冴P鍵字參數(shù)的key都是字符串，并且符合標識符定義規(guī)范。

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} 

可變位置參數(shù)只能以位置參數(shù)的形式調(diào)用可變關鍵字參數(shù)只能以關鍵字參數(shù)的形式調(diào)用可變位置參數(shù)必須在可變關鍵字參數(shù)之前

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)  
in ()  
----> 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 

可變參數(shù)后置可變參數(shù)不和默認參數(shù)一起出現(xiàn)

7. 參數(shù)組合

在Python中定義函數(shù)，可以用必選參數(shù)、默認參數(shù)、可變參數(shù)和關鍵字參數(shù)，這4種參數(shù)都可以一起使用，或者只用其中某些，但是請注意，參數(shù)定義的順序必須是： 必選參數(shù)、默認參數(shù)、可變參數(shù)和關鍵字參數(shù)

比如定義一個函數(shù)，包含上述4種參數(shù)：

>>> def func(a, b, c=0, *args, **kwargs): 
... print('a =', a, 'b =', b, 'c =', c, 'args = ', args, 'kwargs = ', kwargs) 

在函數(shù)調(diào)用的時候，Python解釋器自動按照參數(shù)位置和參數(shù)名把對應的參數(shù)傳進去。

>>> 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，我們也可以調(diào)用該函數(shù)：

>>> args = (1, 2, 3, 4) 
>>> kwargs = {'x': 99} 
>>> func(*args, **kwargs) 
a = 1 b = 2 c = 3 args = (4,) kwargs = {'x': 99} 

所以，對于任意函數(shù)，都可以通過類似func(*args, **kwargs)的形式調(diào)用它，無論它的參數(shù)是如何定義的。

8. 參數(shù)解構

參數(shù)解構發(fā)生在函數(shù)調(diào)用時，可變參數(shù)發(fā)生函數(shù)定義的時候。參數(shù)解構分為兩種形式，一種是位置參數(shù)解構，另一種是關鍵字參數(shù)解構。

參數(shù)結構的兩種形式：

位置參數(shù)解構，使用一個星號。解構的對象為可迭代對象，解構的結果為位置參數(shù)。關鍵字參數(shù)解構，使用兩個星號。解構的對象為字典，解構的結果為關鍵字參數(shù)。

位置參數(shù)解構的一個例子：

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 
# 也可以進行如下形式的調(diào)用 
In[26]: fn(*lst) # 這種做法就叫參數(shù)解構 
1 2 3 
# *號可以把線性結構解包成位置參數(shù) 
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 

# 這里就報錯了，本來這個函數(shù)只能接收3個位置參數(shù)，lst有四個元素，通過參數(shù)解構之后，就變成了4個參數(shù)，所以就報錯了。

接下來看字典解構的例子：

In[27]: d = {'a': 1, 'b': 2, 'c': 3} 
In[28]: fn(**d) 
1 2 3 
# **可以把字典解構成關鍵字參數(shù) 

參數(shù)解構發(fā)生在函數(shù)調(diào)用時。解構的時候，線性結構的解構是位置參數(shù)，字典解構是關鍵字參數(shù)。

傳參的順序：位置參數(shù)，線性結構解構;關鍵字參數(shù)，字典解構。盡量的少的同時使用兩種解構，除非你真的知道在做什么。

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. 參數(shù)槽(keyword-only參數(shù))

Python3中引入的。

def fn(a, b, c): 
print(a, b, c) 
fn(a=1, b=2, c=3) 

如果要強制傳入的參數(shù)為關鍵字參數(shù)：

def fn(*, a, b, c): 
print(a, b, c) 
>>> fn(1, 2, 3) 
Traceback (most recent call last): 
File "", line 1, in 
fn(1, 2, 3) 
TypeError: fn() takes 0 positional arguments but 3 were given 
>>> fn(a=1, b=2, c=3) 
1 2 3 

# *之后的參數(shù)，必須以關鍵字參數(shù)的形式傳遞，稱之為參數(shù)槽。

參數(shù)槽通常和默認參數(shù)搭配使用。

>>> def fn(a, b, *, x, y): 
print(a, b) 
print(x, y) 
>>> fn(1, 2, 3, 4) 
Traceback (most recent call last): 
File "", line 1, in 
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 "", 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 

參數(shù)槽之坑：

*之后必須有參數(shù)非命名參數(shù)有默認值時，命名參數(shù)可以沒有默認值默認參數(shù)應該在每段參數(shù)的***使用參數(shù)槽時，不能使用可變位置參數(shù)，可變關鍵之參數(shù)必須放在命名參數(shù)之后

三、高級用法

1. 遞歸函數(shù)

在函數(shù)內(nèi)部，可以調(diào)用其他函數(shù)。如果一個函數(shù)在內(nèi)部調(diào)用自身本身，這個函數(shù)就是遞歸函數(shù)。

def fact(n): 
if n==1: 
return 1 
return n*fact(n-1) 

使用遞歸函數(shù)的優(yōu)點是邏輯簡單清晰，缺點是過深的調(diào)用會導致棧溢出。

針對尾遞歸優(yōu)化的語言可以通過尾遞歸防止棧溢出。尾遞歸事實上和循環(huán)是等價的，沒有循環(huán)語句的編程語言只能通過尾遞歸實現(xiàn)循環(huán)。

2. 匿名函數(shù) lambda

python 使用 lambda 來創(chuàng)建匿名函數(shù)。

lambda只是一個表達式，函數(shù)體比def簡單很多。

lambda的主體是一個表達式，而不是一個代碼塊。僅僅能在lambda表達式中封裝有限的邏輯進去。

lambda函數(shù)擁有自己的名字空間，且不能訪問自有參數(shù)列表之外或全局名字空間里的參數(shù)。

雖然lambda函數(shù)看起來只能寫一行，卻不等同于C或C++的內(nèi)聯(lián)函數(shù)，后者的目的是調(diào)用小函數(shù)時不占用棧內(nèi)存從而增加運行效率。

fib = lambda n,x=0,y=1:x if not n else fib(n-1,y,x+y) 
print(fib(20)) 

3. Python函數(shù)中的多態(tài)

一個操作的意義取決于被操作對象的類型：

def times(x,y): 
return x*y 
>>>times(2,4) 
>>>8 
times('Python',4) # 傳遞了與上不同的數(shù)據(jù)類型 'PythonPythonPythonPython' 

四、總結

Python的函數(shù)具有非常靈活的參數(shù)形態(tài)，既可以實現(xiàn)簡單的調(diào)用，又可以傳入非常復雜的參數(shù)。

默認參數(shù)一定要用不可變對象，如果是可變對象，運行會有邏輯錯誤!

要注意定義可變參數(shù)和關鍵字參數(shù)的語法：

*args是可變參數(shù)，args接收的是一個tuple;

**kwargs是關鍵字參數(shù)，kwargs接收的是一個dict。

以及調(diào)用函數(shù)時如何傳入可變參數(shù)和關鍵字參數(shù)的語法：

可變參數(shù)既可以直接傳入：func(1, 2, 3)，又可以先組裝list或tuple，再通過*args傳入：func(*(1, 2, 3));

關鍵字參數(shù)既可以直接傳入：func(a=1, b=2)，又可以先組裝dict，再通過kwargs傳入：func({'a': 1, 'b': 2})。

使用*args和**kwargs是Python的習慣寫法，當然也可以用其他參數(shù)名，但應該使用習慣用法。