Python學習筆記—函數

函數

咱們知道圓的面積計算公式爲：

S = πr2

當咱們知道半徑r的值時，就能夠根據公式計算出面積。假設咱們須要計算3個不一樣大小的圓的面積：

r1 = 12.34
r2 = 9.08
r3 = 73.1
s1 = 3.14 * r1 * r1
s2 = 3.14 * r2 * r2
s3 = 3.14 * r3 * r3

當代碼出現有規律的重複的時候，你就須要小心了，每次寫3.14 * x * x不只很麻煩，並且，若是要把3.14改爲3.14159265359的時候，得所有替換。

有了函數，咱們就再也不每次寫s = 3.14 * x * x，而是寫成更有意義的函數調用s = area_of_circle(x)，而函數area_of_circle自己只須要寫一次，就能夠屢次調用。

基本上全部的高級語言都支持函數，Python也不例外。Python不但能很是靈活地定義函數，並且自己內置了不少有用的函數，能夠直接調用。

抽象

抽象是數學中很是常見的概念。舉個例子：

計算數列的和，好比：1 + 2 + 3 + ... + 100，寫起來十分不方便，因而數學家發明了求和符號∑，能夠把1 + 2 + 3 + ... + 100記做：

100

∑n

n=1

這種抽象記法很是強大，由於咱們看到∑就能夠理解成求和，而不是還原成低級的加法運算。

並且，這種抽象記法是可擴展的，好比：

100

∑(n2+1)

n=1

 

還原成加法運算就變成了：

(1 x 1 + 1) + (2 x 2 + 1) + (3 x 3 + 1) + ... + (100 x 100 + 1)

可見，藉助抽象，咱們才能不關心底層的具體計算過程，而直接在更高的層次上思考問題。

寫計算機程序也是同樣，函數就是最基本的一種代碼抽象的方式。

 

調用函數

Python內置了不少有用的函數，咱們能夠直接調用。

要調用一個函數，須要知道函數的名稱和參數，好比求絕對值的函數abs，只有一個參數。能夠直接從Python的官方網站查看文檔：

http://docs.python.org/2/library/functions.html#abs

也能夠在交互式命令行經過help(abs)查看abs函數的幫助信息。

調用abs函數：

>>> abs(100)
100
>>> abs(-20)
20
>>> abs(12.34)
12.34

調用函數的時候，若是傳入的參數數量不對，會報TypeError的錯誤，而且Python會明確地告訴你：abs()有且僅有1個參數，但給出了兩個：

>>> abs(1, 2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: abs() takes exactly one argument (2 given)

若是傳入的參數數量是對的，但參數類型不能被函數所接受，也會報TypeError的錯誤，而且給出錯誤信息：str是錯誤的參數類型：

>>> abs('a')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: bad operand type for abs(): 'str'

而比較函數cmp(x, y)就須要兩個參數，若是x<y，返回-1，若是x==y，返回0，若是x>y，返回1：

>>> cmp(1, 2)
-1
>>> cmp(2, 1)
1
>>> cmp(3, 3)
0

數據類型轉換

Python內置的經常使用函數還包括數據類型轉換函數，好比int()函數能夠把其餘數據類型轉換爲整數：

>>> int('123')
123
>>> int(12.34)
12
>>> float('12.34')
12.34
>>> str(1.23)
'1.23'
>>> unicode(100)
u'100'
>>> bool(1)
True
>>> bool('')
False

函數名其實就是指向一個函數對象的引用，徹底能夠把函數名賦給一個變量，至關於給這個函數起了一個「別名」：

>>> a = abs # 變量a指向abs函數
>>> a(-1) # 因此也能夠經過a調用abs函數
1

小結

調用Python的函數，須要根據函數定義，傳入正確的參數。若是函數調用出錯，必定要學會看錯誤信息，因此英文很重要！

 

二、定義函數

在Python中，定義一個函數要使用def語句，依次寫出函數名、括號、括號中的參數和冒號:，而後，在縮進塊中編寫函數體，函數的返回值用return語句返回。

咱們以自定義一個求絕對值的my_abs函數爲例：

def my_abs(x):
    if x >= 0:
        return x
    else:
        return -x

請自行測試並調用my_abs看看返回結果是否正確。

請注意，函數體內部的語句在執行時，一旦執行到return時，函數就執行完畢，並將結果返回。所以，函數內部經過條件判斷和循環能夠實現很是複雜的邏輯。

若是沒有return語句，函數執行完畢後也會返回結果，只是結果爲None。

return None能夠簡寫爲return。

空函數

若是想定義一個什麼事也不作的空函數，能夠用pass語句：

def nop():
    pass

pass語句什麼都不作，那有什麼用？實際上pass能夠用來做爲佔位符，好比如今還沒想好怎麼寫函數的代碼，就能夠先放一個pass，讓代碼能運行起來。

pass還能夠用在其餘語句裏，好比：

if age >= 18:
    pass

缺乏了pass，代碼運行就會有語法錯誤。

參數檢查

調用函數時，若是參數個數不對，Python解釋器會自動檢查出來，並拋出TypeError：

>>> my_abs(1, 2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: my_abs() takes exactly 1 argument (2 given)

可是若是參數類型不對，Python解釋器就沒法幫咱們檢查。試試my_abs和內置函數abs的差異：

>>> my_abs('A')
'A'
>>> abs('A')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: bad operand type for abs(): 'str'

當傳入了不恰當的參數時，內置函數abs會檢查出參數錯誤，而咱們定義的my_abs沒有參數檢查，因此，這個函數定義不夠完善。

讓咱們修改一下my_abs的定義，對參數類型作檢查，只容許整數和浮點數類型的參數。數據類型檢查能夠用內置函數isinstance實現：

def my_abs(x):
    if not isinstance(x, (int, float)):
        raise TypeError('bad operand type')
    if x >= 0:
        return x
    else:
        return -x

添加了參數檢查後，若是傳入錯誤的參數類型，函數就能夠拋出一個錯誤：

>>> my_abs('A')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in my_abs
TypeError: bad operand type

錯誤和異常處理將在後續講到。

返回多個值

函數能夠返回多個值嗎？答案是確定的。

好比在遊戲中常常須要從一個點移動到另外一個點，給出座標、位移和角度，就能夠計算出新的新的座標：

import math

def move(x, y, step, angle=0):
    nx = x + step * math.cos(angle)
    ny = y - step * math.sin(angle)
    return nx, ny

這樣咱們就能夠同時得到返回值：

>>> x, y = move(100, 100, 60, math.pi / 6)
>>> print x, y
151.961524227 70.0

但其實這只是一種假象，Python函數返回的仍然是單一值：

>>> r = move(100, 100, 60, math.pi / 6)
>>> print r
(151.96152422706632, 70.0)

原來返回值是一個tuple！可是，在語法上，返回一個tuple能夠省略括號，而多個變量能夠同時接收一個tuple，按位置賦給對應的值，因此，Python的函數返回多值其實就是返回一個tuple，但寫起來更方便。

小結

定義函數時，須要肯定函數名和參數個數；

若是有必要，能夠先對參數的數據類型作檢查；

函數體內部能夠用return隨時返回函數結果；

函數執行完畢也沒有return語句時，自動return None。

函數能夠同時返回多個值，但其實就是一個tuple。

 

三、函數的參數

定義函數的時候，咱們把參數的名字和位置肯定下來，函數的接口定義就完成了。對於函數的調用者來講，只須要知道如何傳遞正確的參數，以及函數將返回什麼樣的值就夠了，函數內部的複雜邏輯被封裝起來，調用者無需瞭解。

Python的函數定義很是簡單，但靈活度卻很是大。除了正常定義的必選參數外，還可使用默認參數、可變參數和關鍵字參數，使得函數定義出來的接口，不但能處理複雜的參數，還能夠簡化調用者的代碼。

默認參數

咱們仍以具體的例子來講明如何定義函數的默認參數。先寫一個計算x2的函數：

def power(x):
    return x * x

 

當咱們調用power函數時，必須傳入有且僅有的一個參數x：

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

如今，若是咱們要計算x3怎麼辦？能夠再定義一個power3函數，可是若是要計算x四、x5……怎麼辦？咱們不可能定義無限多個函數。

你也許想到了，能夠把power(x)修改成power(x, n)，用來計算xn，說幹就幹：

def power(x, n):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

 

對於這個修改後的power函數，能夠計算任意n次方：

>>> power(5, 2)
25
>>> power(5, 3)
125

可是，舊的調用代碼失敗了，緣由是咱們增長了一個參數，致使舊的代碼沒法正常調用：

>>> power(5)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: power() takes exactly 2 arguments (1 given)

這個時候，默認參數就排上用場了。因爲咱們常常計算x2，因此，徹底能夠把第二個參數n的默認值設定爲2：

def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

這樣，當咱們調用power(5)時，至關於調用power(5, 2)：

>>> power(5)
25
>>> power(5, 2)
25

而對於n > 2的其餘狀況，就必須明確地傳入n，好比power(5, 3)。

從上面的例子能夠看出，默認參數能夠簡化函數的調用。設置默認參數時，有幾點要注意：

一是必選參數在前，默認參數在後，不然Python的解釋器會報錯（思考一下爲何默認參數不能放在必選參數前面）；

二是如何設置默認參數。

當函數有多個參數時，把變化大的參數放前面，變化小的參數放後面。變化小的參數就能夠做爲默認參數。

使用默認參數有什麼好處？最大的好處是能下降調用函數的難度。

舉個例子，咱們寫個一年級小學生註冊的函數，須要傳入name和gender兩個參數：

def enroll(name, gender):
    print 'name:', name
    print 'gender:', gender

這樣，調用enroll()函數只須要傳入兩個參數：

>>> enroll('Sarah', 'F')
name: Sarah
gender: F

若是要繼續傳入年齡、城市等信息怎麼辦？這樣會使得調用函數的複雜度大大增長。

咱們能夠把年齡和城市設爲默認參數：

def enroll(name, gender, age=6, city='Beijing'):
    print 'name:', name
    print 'gender:', gender
    print 'age:', age
    print 'city:', city

這樣，大多數學生註冊時不須要提供年齡和城市，只提供必須的兩個參數：

>>> enroll('Sarah', 'F')
Student:
name: Sarah
gender: F
age: 6
city: Beijing

只有與默認參數不符的學生才須要提供額外的信息：

enroll('Bob', 'M', 7)
enroll('Adam', 'M', city='Tianjin')

可見，默認參數下降了函數調用的難度，而一旦須要更復雜的調用時，又能夠傳遞更多的參數來實現。不管是簡單調用仍是複雜調用，函數只須要定義一個。

有多個默認參數時，調用的時候，既能夠按順序提供默認參數，好比調用enroll('Bob', 'M', 7)，意思是，除了name，gender這兩個參數外，最後1個參數應用在參數age上，city參數因爲沒有提供，仍然使用默認值。

也能夠不按順序提供部分默認參數。當不按順序提供部分默認參數時，須要把參數名寫上。好比調用enroll('Adam', 'M', city='Tianjin')，意思是，city參數用傳進去的值，其餘默認參數繼續使用默認值。

默認參數頗有用，但使用不當，也會掉坑裏。默認參數有個最大的坑，演示以下：

先定義一個函數，傳入一個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']

不少初學者很疑惑，默認參數是[]，可是函數彷佛每次都「記住了」上次添加了'END'後的list。

緣由解釋以下：

Python函數在定義的時候，默認參數L的值就被計算出來了，即[]，由於默認參數L也是一個變量，它指向對象[]，每次調用該函數，若是改變了L的內容，則下次調用時，默認參數的內容就變了，再也不是函數定義時的[]了。

因此，定義默認參數要牢記一點：默認參數必須指向不變對象！

要修改上面的例子，咱們能夠用None這個不變對象來實現：

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

如今，不管調用多少次，都不會有問題：

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

爲何要設計str、None這樣的不變對象呢？由於不變對象一旦建立，對象內部的數據就不能修改，這樣就減小了因爲修改數據致使的錯誤。此外，因爲對象不變，多任務環境下同時讀取對象不須要加鎖，同時讀一點問題都沒有。咱們在編寫程序時，若是能夠設計一個不變對象，那就儘可能設計成不變對象。

可變參數

在Python函數中，還能夠定義可變參數。顧名思義，可變參數就是傳入的參數個數是可變的，能夠是1個、2個到任意個，還能夠是0個。

咱們以數學題爲例子，給定一組數字a，b，c……，請計算a2 + b2 + c2 + ……。

要定義出這個函數，咱們必須肯定輸入的參數。因爲參數個數不肯定，咱們首先想到能夠把a，b，c……做爲一個list或tuple傳進來，這樣，函數能夠定義以下：

def calc(numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

　　

可是調用的時候，須要先組裝出一個list或tuple：

>>> calc([1, 2, 3])
14
>>> calc((1, 3, 5, 7))
84

　　

若是利用可變參數，調用函數的方式能夠簡化成這樣：

>>> calc(1, 2, 3)
14
>>> calc(1, 3, 5, 7)
84

　　

因此，咱們把函數的參數改成可變參數：

def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

　　

定義可變參數和定義list或tuple參數相比，僅僅在參數前面加了一個*號。在函數內部，參數numbers接收到的是一個tuple，所以，函數代碼徹底不變。可是，調用該函數時，能夠傳入任意個參數，包括0個參數：

>>> calc(1, 2)
5
>>> calc()
0

　　

若是已經有一個list或者tuple，要調用一個可變參數怎麼辦？能夠這樣作：

>>> nums = [1, 2, 3]
>>> calc(nums[0], nums[1], nums[2])
14

　　

這種寫法固然是可行的，問題是太繁瑣，因此Python容許你在list或tuple前面加一個*號，把list或tuple的元素變成可變參數傳進去：

>>> nums = [1, 2, 3]
>>> calc(*nums)
14

　　

這種寫法至關有用，並且很常見。

關鍵字參數

可變參數容許你傳入0個或任意個參數，這些可變參數在函數調用時自動組裝爲一個tuple。而關鍵字參數容許你傳入0個或任意個含參數名的參數，這些關鍵字參數在函數內部自動組裝爲一個dict。請看示例：

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

　　

函數person除了必選參數name和age外，還接受關鍵字參數kw。在調用該函數時，能夠只傳入必選參數：

>>> person('Michael', 30)
name: Michael age: 30 other: {}

　　

也能夠傳入任意個數的關鍵字參數：

>>> person('Bob', 35, city='Beijing')
name: Bob age: 35 other: {'city': 'Beijing'}
>>> person('Adam', 45, gender='M', job='Engineer')
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}

　　

關鍵字參數有什麼用？它能夠擴展函數的功能。好比，在person函數裏，咱們保證能接收到name和age這兩個參數，可是，若是調用者願意提供更多的參數，咱們也能收到。試想你正在作一個用戶註冊的功能，除了用戶名和年齡是必填項外，其餘都是可選項，利用關鍵字參數來定義這個函數就能知足註冊的需求。

和可變參數相似，也能夠先組裝出一個dict，而後，把該dict轉換爲關鍵字參數傳進去：

>>> kw = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, city=kw['city'], job=kw['job'])
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

　　

固然，上面複雜的調用能夠用簡化的寫法：

>>> kw = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, **kw)
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

　　

參數組合

在Python中定義函數，能夠用必選參數、默認參數、可變參數和關鍵字參數，這4種參數均可以一塊兒使用，或者只用其中某些，可是請注意，參數定義的順序必須是：必選參數、默認參數、可變參數和關鍵字參數。

好比定義一個函數，包含上述4種參數：

def func(a, b, c=0, *args, **kw):
    print 'a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw

　　

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

>>> func(1, 2)
a = 1 b = 2 c = 0 args = () kw = {}
>>> func(1, 2, c=3)
a = 1 b = 2 c = 3 args = () kw = {}
>>> func(1, 2, 3, 'a', 'b')
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}
>>> func(1, 2, 3, 'a', 'b', x=99)
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}

　　

最神奇的是經過一個tuple和dict，你也能夠調用該函數：

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

　　

因此，對於任意函數，均可以經過相似func(*args, **kw)的形式調用它，不管它的參數是如何定義的。

小結

Python的函數具備很是靈活的參數形態，既能夠實現簡單的調用，又能夠傳入很是複雜的參數。

默認參數必定要用不可變對象，若是是可變對象，運行會有邏輯錯誤！

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

*args是可變參數，args接收的是一個tuple；

**kw是關鍵字參數，kw接收的是一個dict。

以及調用函數時如何傳入可變參數和關鍵字參數的語法：

可變參數既能夠直接傳入：func(1, 2, 3)，又能夠先組裝list或tuple，再經過*args傳入：func(*(1, 2, 3))；

關鍵字參數既能夠直接傳入：func(a=1, b=2)，又能夠先組裝dict，再經過**kw傳入：func(**{'a': 1, 'b': 2})。

使用*args和**kw是Python的習慣寫法，固然也能夠用其餘參數名，但最好使用習慣用法。

 

四、遞歸函數

在函數內部，能夠調用其餘函數。若是一個函數在內部調用自身自己，這個函數就是遞歸函數。

舉個例子，咱們來計算階乘n! = 1 x 2 x 3 x ... x n，用函數fact(n)表示，能夠看出：

fact(n) = n! = 1 x 2 x 3 x ... x (n-1) x n = (n-1)! x n = fact(n-1) x n

因此，fact(n)能夠表示爲n x fact(n-1)，只有n=1時須要特殊處理。

因而，fact(n)用遞歸的方式寫出來就是：

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

　　

上面就是一個遞歸函數。能夠試試：

>>> fact(1)
1
>>> fact(5)
120
>>> fact(100)
93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000L

　　

若是咱們計算fact(5)，能夠根據函數定義看到計算過程以下：

===> fact(5)
===> 5 * fact(4)
===> 5 * (4 * fact(3))
===> 5 * (4 * (3 * fact(2)))
===> 5 * (4 * (3 * (2 * fact(1))))
===> 5 * (4 * (3 * (2 * 1)))
===> 5 * (4 * (3 * 2))
===> 5 * (4 * 6)
===> 5 * 24
===> 120

　　

遞歸函數的優勢是定義簡單，邏輯清晰。理論上，全部的遞歸函數均可以寫成循環的方式，但循環的邏輯不如遞歸清晰。

使用遞歸函數須要注意防止棧溢出。在計算機中，函數調用是經過棧（stack）這種數據結構實現的，每當進入一個函數調用，棧就會加一層棧幀，每當函數返回，棧就會減一層棧幀。因爲棧的大小不是無限的，因此，遞歸調用的次數過多，會致使棧溢出。能夠試試fact(1000)：

>>> fact(1000)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 4, in fact
  ...
  File "<stdin>", line 4, in fact
RuntimeError: maximum recursion depth exceeded

　　

解決遞歸調用棧溢出的方法是經過尾遞歸優化，事實上尾遞歸和循環的效果是同樣的，因此，把循環當作是一種特殊的尾遞歸函數也是能夠的。

尾遞歸是指，在函數返回的時候，調用自身自己，而且，return語句不能包含表達式。這樣，編譯器或者解釋器就能夠把尾遞歸作優化，使遞歸自己不管調用多少次，都只佔用一個棧幀，不會出現棧溢出的狀況。

上面的fact(n)函數因爲return n * fact(n - 1)引入了乘法表達式，因此就不是尾遞歸了。要改爲尾遞歸方式，須要多一點代碼，主要是要把每一步的乘積傳入到遞歸函數中：

def fact(n):
    return fact_iter(n, 1)

def fact_iter(num, product):
    if num == 1:
        return product
    return fact_iter(num - 1, num * product)

　　

能夠看到，return fact_iter(num - 1, num * product)僅返回遞歸函數自己，num - 1和num * product在函數調用前就會被計算，不影響函數調用。

fact(5)對應的fact_iter(5, 1)的調用以下：

===> fact_iter(5, 1)
===> fact_iter(4, 5)
===> fact_iter(3, 20)
===> fact_iter(2, 60)
===> fact_iter(1, 120)
===> 120

　　

尾遞歸調用時，若是作了優化，棧不會增加，所以，不管多少次調用也不會致使棧溢出。

遺憾的是，大多數編程語言沒有針對尾遞歸作優化，Python解釋器也沒有作優化，因此，即便把上面的fact(n)函數改爲尾遞歸方式，也會致使棧溢出。

小結

使用遞歸函數的優勢是邏輯簡單清晰，缺點是過深的調用會致使棧溢出。

針對尾遞歸優化的語言能夠經過尾遞歸防止棧溢出。尾遞歸事實上和循環是等價的，沒有循環語句的編程語言只能經過尾遞歸實現循環。

Python標準的解釋器沒有針對尾遞歸作優化，任何遞歸函數都存在棧溢出的問題。