Python 函數基礎知識匯總，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 - yminus(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 23 4>>> fn(1, 2, **{'x': 3, 'y': 4})1 23 4def fn(a, b, *):  print(a, b)def fn(a, b, *):...  print(a, b)File "<stdin>", line 1SyntaxError: named arguments must follow bare *

幾個例子：

def fn01(*, x=1, y=5):  print(x)  print(y)>>> fn01()15def fn02(x=1, *, y):  print(x)  print(y)>>> fn02(y=3)13

參數槽之坑：

*之後必須有參數
非具名引數有預設值時，具名引數可以沒有預設值
預設參數應該在每段參數的最後
使用參數槽時，不能使用可變位置參數，可變關鍵之參數必須放在具名引數之後

三、進階用法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)>>>8times('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的習慣寫法，當然也可以用其他參數名，但最好使用習慣用法。