聲明:
想學習的朋友可以直接看http://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000
調用函數
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
定義函數:
在Python中,定義一個函數要使用def
語句,依次寫出函數名、括號、括號中的參數和冒號:
,然後,在縮進塊中編寫函數體,函數的返回值用return
語句返回。
我們以自定義一個求絕對值的my_abs
函數爲例:
def my_abs(x):
if x >= 0:
return x
else:
return -x
空函數
如果想定義一個什麼事也不做的空函數,可以用pass
語句:
def nop():
pass
pass
語句什麼都不做,那有什麼用?實際上pass
可以用來作爲佔位符,比如現在還沒想好怎麼寫函數的代碼,就可以先放一個pass
,讓代碼能運行起來。
參數組合
在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)
的形式調用它,無論它的參數是如何定義的。
遞歸函數
在函數內部,可以調用其他函數。如果一個函數在內部調用自身本身,這個函數就是遞歸函數。
舉個例子,我們來計算階乘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(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)
函數改成尾遞歸方式,也會導致棧溢出。