要調用一個函數,需要知道函數的名稱和參數,比如求絕對值的函數 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
str()函數把其他類型轉換成 str:
>>> str(123)
'123'
>>> str(1.23)
'1.23'
編寫函數:
在Python中,定義一個函數要使用 def 語句,依次寫出函數名、括弧、括弧中的參數和冒號:,然後,在縮排塊中編寫函數體,函數的傳回值用 return 語句返回。
我們以自訂一個求絕對值的 my_abs 函數為例:
def my_abs(x):
if x >= 0:
return x else:
return -x
請注意,函數體內部的語句在執行時,一旦執行到return時,函數就執行完畢,並將結果返回。因此,函數內部通過條件判斷和迴圈可以實現非常複雜的邏輯。
如果沒有return語句,函數執行完畢後也會返回結果,只是結果為 None。
return None可以簡寫為return。
返回多值:
函數可以返回多個值嗎?答案是肯定的。
比如在遊戲中經常需要從一個點移動到另一個點,給出座標、位移和角度,就可以計算出新的座標:
# math包提供了sin()和 cos()函數,我們先用import引用它:
import math
def move(x, y, step, angle):
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)
用print列印返回結果,原來傳回值是一個tuple!
但是,在文法上,返回一個tuple可以省略括弧,而多個變數可以同時接收一個tuple,按位置賦給對應的值,所以,Python的函數返回多值其實就是返回一個tuple,但寫起來更方便。
遞迴函式:
在函數內部,可以調用其他函數。如果一個函數在內部調用自身本身,這個函數就是遞迴函式。
舉個例子,我們來計算階乘 n! = 1 * 2 * 3 * ... * n,用函數 fact(n)表示,可以看出:
def fact(n):
if n==1:
return 1
return n * fact(n - 1)
遞迴函式的優點是定義簡單,邏輯清晰。理論上,所有的遞迴函式都可以寫成迴圈的方式,但迴圈的邏輯不如遞迴清晰。
使用遞迴函式需要注意防止棧溢出。在電腦中,函數調用是通過棧(stack)這種資料結構實現的,每當進入一個函數調用,棧就會加一層棧幀,每當函數返回,棧就會減一層棧幀。由於棧的大小不是無限的,所以,遞迴調用的次數過多,會導致棧溢出。可以試試計算 fact(10000)。
函數 move(n, a, b, c) 的定義是將 n 個圓盤從 a 藉助 b 移動到 c。
參考代碼:
def move(n, a, b, c):
if n ==1:
print a, '-->', c
return
move(n-1, a, c, b)
print a, '-->', c
move(n-1, b, a, c)
move(4, 'A', 'B', 'C')
解決遞迴調用棧溢出的方法是通過尾遞迴最佳化,事實上尾遞迴和迴圈的效果是一樣的,所以,把迴圈看成是一種特殊的尾遞迴函式也是可以的。
尾遞迴是指,在函數返回的時候,調用自身本身,並且,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內建的 int() 函數,其實就有兩個參數,我們既可以傳一個參數,又可以傳兩個參數:
>>> int('123')
123
>>> int('123', 8)
83
int()函數的第二個參數是轉換進位,如果不傳,預設是十進位 (base=10),如果傳了,就用傳入的參數。
可見,函數的預設參數的作用是簡化調用,你只需要把必須的參數傳進去。但是在需要的時候,又可以傳入額外的參數來覆蓋預設參數值。
我們來定義一個計算 x 的N次方的函數:
def power(x, n):
s = 1
while n > 0:
n = n - 1
s = s * x
return s
假設計算平方的次數最多,我們就可以把 n 的預設值設定為 2:
def power(x, n=2):
s = 1
while n > 0:
n = n - 1
s = s * x
return s
這樣一來,計算平方就不需要傳入兩個參數了:
>>> power(5)
25
由於函數的參數按從左至右的順序匹配,所以預設參數只能定義在必需參數的後面:
# OK:def fn1(a, b=1, c=2):
pass# Error:def fn2(a=1, b):
pass
先定義一個函數,傳入一個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這樣的不變對象呢?因為不變對象一旦建立,對象內部的資料就不能修改,這樣就減少了由於修改資料導致的錯誤。此外,由於對象不變,多任務環境下同時讀取對象不需要加鎖,同時讀一點問題都沒有。我們在編寫程式時,如果可以設計一個不變對象,那就盡量設計成不變對象。
定義可變參數:
如果想讓一個函數能接受任意個參數,我們就可以定義一個可變參數:
def fn(*args):
print args
可變參數的名字前面有個 * 號,我們可以傳入0個、1個或多個參數給可變參數:
>>> fn()
()
>>> fn('a')
('a',)
>>> fn('a', 'b')
('a', 'b')
>>> fn('a', 'b', 'c')
('a', 'b', 'c')
Python解譯器會把傳入的一組參數組裝成一個tuple傳遞給可變參數,因此,在函數內部,直接把變數 args 看成一個 tuple 就好了。
關鍵字參數:
可變參數允許你傳入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這兩個參數,但是,如果調用者願意提供更多的參數,我們也能收到。試想你正在做一個使用者註冊的功能,除了使用者名稱和年齡是必填項外,其他都是可選項,利用關鍵字參數來定義這個函數就能滿足註冊的需求。
命名關鍵字參數:
對於關鍵字參數,函數的調用者可以傳入任意不受限制的關鍵字參數。至於到底傳入了哪些,就需要在函數內部通過kw檢查。
仍以person()函數為例,我們希望檢查是否有city和job參數:
def person(name, age, **kw):
if 'city' in kw: # 有city參數
pass
if 'job' in kw: # 有job參數
pass
print('name:', name, 'age:', age, 'other:', kw)
但是調用者仍可以傳入不受限制的關鍵字參數:
>>> person('Jack', 24, city='Beijing', addr='Chaoyang', zipcode=123456)
如果要限制關鍵字參數的名字,就可以用命名關鍵字參數,例如,只接收city和job作為關鍵字參數。這種方式定義的函數如下:
def person(name, age, *, city, job):
print(name, age, city, job)
和關鍵字參數**kw不同,命名關鍵字參數需要一個特殊分隔字元*,*後面的參數被視為命名關鍵字參數。
調用方式如下:
>>> person('Jack', 24, city='Beijing', job='Engineer')
Jack 24 Beijing Engineer
命名關鍵字參數必須傳入參數名,這和位置參數不同。如果沒有傳入參數名,調用將報錯:
>>> person('Jack', 24, 'Beijing', 'Engineer')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>TypeError: person() takes 2 positional arguments but 4 were given
由於調用時缺少參數名city和job,Python解譯器把這4個參數均視為位置參數,但person()函數僅接受2個位置參數。
命名關鍵字參數可以有預設值,從而簡化調用:
def person(name, age, *, city='Beijing', job):
print(name, age, city, job)
由於命名關鍵字參數city具有預設值,調用時,可不傳入city參數:
>>> person('Jack', 24, job='Engineer')
Jack 24 Beijing Engineer
使用命名關鍵字參數時,要特別注意,*不是參數,而是特殊分隔字元。如果缺少*,Python解譯器將無法識別位置參數和命名關鍵字參數:
def person(name, age, city, job):
# 缺少 *,city和job被視為位置參數
pass
參數組合:
在Python中定義函數,可以用必選參數、預設參數、可變參數、關鍵字參數和命名關鍵字參數,這5種參數都可以組合使用,除了可變參數無法和命名關鍵字參數混合。但是請注意,參數定義的順序必須是:必選參數、預設參數、可變參數/命名關鍵字參數和關鍵字參數。
比如定義一個函數,包含上述若干種參數:
def f1(a, b, c=0, *args, **kw):
print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)def f2(a, b, c=0, *, d, **kw):
print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)
在函數調用的時候,Python解譯器自動按照參數位置和參數名把對應的參數傳進去。
>>> f1(1, 2)
a = 1 b = 2 c = 0 args = () kw = {}>>> f1(1, 2, c=3)
a = 1 b = 2 c = 3 args = () kw = {}>>> f1(1, 2, 3, 'a', 'b')
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}>>> f1(1, 2, 3, 'a', 'b', x=99)
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}>>> f2(1, 2, d=99, ext=None)
a = 1 b = 2 c = 0 d = 99 kw = {'ext': None}
最神奇的是通過一個tuple和dict,你也可以調用上述函數:
>>> args = (1, 2, 3, 4)>>> kw = {'d': 99, 'x': '#'}>>> f1(*args, **kw)
a = 1 b = 2 c = 3 args = (4,) kw = {'d': 99, 'x': '#'}>>> args = (1, 2, 3)>>> kw = {'d': 88, 'x': '#'}>>> f2(*args, **kw)
a = 1 b = 2 c = 3 d = 88 kw = {'x': '#'}
所以,對於任意函數,都可以通過類似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的習慣寫法,當然也可以用其他參數名,但最好使用習慣用法。
命名的關鍵字參數是為了限制調用者可以傳入的參數名,同時可以提供預設值。
定義命名的關鍵字參數不要忘了寫分隔字元*,否則定義的將是位置參數。