看完本文大概需要8分鐘，看完后，仔細看下代碼，認真回一下，函式基本知識就OK了，最好還是把代碼敲一下，
PS特別注意：很多人學Python程序中會遇到各種煩惱問題，沒有人幫答疑容易放棄，為此小編建了個Python全堆疊免費答疑.裙 ：七衣衣九起起巴而五（數字的諧音）轉換下可以找到了，不懂的問題有老司機解決里面還有最新Python教程專案可拿,，一起相互監督共同進步！
一、函式基礎
簡單地說，一個函式就是一組Python陳述句的組合，它們可以在程式中運行一次或多次運行，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的習慣寫法，當然也可以用其他引數名，但最好使用習慣用法，
注意：很多人學Python程序中會遇到各種煩惱問題，沒有人幫答疑容易放棄，為此小編建了個Python全堆疊免費答疑.裙 ：七衣衣九起起巴而五（數字的諧音）轉換下可以找到了，不懂的問題有老司機解決里面還有最新Python教程專案可拿,，一起相互監督共同進步！
本文的文字及圖片來源于網路加上自己的想法,僅供學習、交流使用,不具有任何商業用途,著作權歸原作者所有,如有問題請及時聯系我們以作處理，
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/181835.html
標籤：Python