python中函數的總結之三

1、 可變長參數

在函數中可變長參數分爲兩種：一種是非關鍵字參數，表示爲元組；一種是關鍵字參數，表示爲字典。

具體看下面的例子代碼，相當於單元測試：

#!/usr/bin/env python
#'this is a example of the unit test'
def testit(func,*nkwargs,**kwargs):
    'this is the test of the function'
    try:
        retval = func(*nkwargs,**kwargs) #調用函數來進行測試
        result = (True,retval) #返回值爲一個元組
    except Exception,diag:
        result = (False,str(diag))
    return result

def main():
    'this is the unittest input'
    funcs = (int,long,float)
    vars = (12,12.34,'12','12.34')
    for eachFunc in funcs:
        print '-'*20
        for eachVal in vars:
            result = testit(eachFunc,eachVal)
            if result[0]:
                print '%s(%s) = ' % (eachFunc.__name__,eachVal),result[1]
            else:
                print '%s(%s) FAILED:' % (eachFunc.__name__,eachVal),result[1]

if __name__== '__main__':
    main()

在主函數main中，主要是輸入的參數和需要測試的方法，在循環中，依次對函數進行了測試

輔助函數testit接收了三個參數，一個是函數對象，一個是非關鍵字參數，一個是關鍵字參數

返回值爲一個元組，然後使用元組的值來進行判斷，是否成功調用。

2、 內建函數reduce

內建函數reduce的語法如下：

reduce(func,seq[,init])

將二元函數作用域seq序列的元素，每次使用seq的兩個元素，當前的元素和下一個序列的元素，當指定了init的時候，那麼表示使用init的值和第一個元素，連續的將現在的結果和下面的值作用於獲得的隨後結果上，最後，返回一個單一的值。

例子如下：

>>> reduce(lambda x,y :x+y,(1,2,3,4))
10
>>> reduce(lambda x,y :x+y,(1,2,3,4),10)
20

使用了一個lambda函數，來計算兩個元素相加，在以上的例子中，表示將序列每個元素進行相加，最後得到一個結果，指定了init=10之後，表示也是相加的結果

3、偏函數

一個帶有n個參數的，偏函數將一個參數固化爲固定參數，並返回第一個和帶n-1個函數的函數對象，在這裏使用的functools模塊的partial，如下例子：

>>> from operator import add,mul
>>> from functools import partial
>>> add1 = partial(add,1)
>>> add1(10)
11
>>> add1(11)
12

在add的時候，本來是需要兩個參數的，然後固定一個參數爲1，那麼每次調用的時候，只要調用偏函數即可。

#!/usr/bin/env python

from functools import partial
import Tkinter

root = Tkinter.Tk()
MyButton = partial(Tkinter.Button,root,fg='white',bg='blue') #固化其中的背景色和前置顏色
b1 = MyButton(text='Button1 ') #在生成的時候，直接使用偏函數對象即可
b2 = MyButton(text='Button2 ')
qb = MyButton(text='QUIT ',bg='red',command=root.quit) #偏函數對象中的參數可以修改
b1.pack()
b1.pack()
qb.pack(fill=Tkinter.X,expand=True)
root.title('PFAs!')
root.mainloop()

在以上代碼中，主要是進行固話部分參數，例如背景顏色，前面的顏色，從而不用在每次進行定義的時候都進行定義，這就是偏函數的引用，也就是固話其中的一些參數，從而簡化代碼。

3、 傳遞參數

函數是可以被引用的（訪問或者以其他變量作爲別名），也作爲參數傳入函數，已經作爲字典和列表等容器對象的元素。

函數是可以調用：一是可以用其他的變量作爲函數的別名；而是可以通過函數操作來調用他們

如：

foo——表示函數對象的引用

foo()——便是函數對象的調用

#!/usr/bin/env python

def convert(func,seq):
    return [func(eachNum) for eachNum in seq] #調用函數

if __name__ == '__main__':
    myseq = (123,45.67,9999L)
    print convert(int,myseq) #直接進行函數對象的引用

python函數的形參集合由在調用時要傳入函數的的所有參數的組成，這參數與函數聲明中的列表精確配對。

a、 位置參數：所有的位置參數必須出現在任何一個默認參數之前，位置參數必須傳入，不按位置用關鍵字參數傳入

b、 關鍵字參數

c、 默認參數---主要是用來方便使用，使用默認參數的時候，使用方便。

4、 遞歸

遞歸主要是用來用來一種循環的方式來使用，在使用遞歸的時候，必須有基本的條件從而可以結束：

#!/usr/bin/env python
def factoral(n):
    if n == 0 or n == 1:
        return n
    else:
        return n*factoral(n-1)
print factoral(4)

以上爲一個遞歸的例子，主要是用來求階乘。在使用遞歸的時候，必須確定結束的條件，從而來進行循環遞歸。

5、閉包和裝飾器例子

主要用來寫入日誌，在調用函數之前或者之後進行寫入日誌的操作，代碼如下：

#!/usr/bin/env python
from time import time

def logged(when):
    def log(f,*args,**kargs): #主要的記錄日誌的函數
        print '''Called:
        function:%s
        args:%s
        kargs:%r''' %(f,args,kargs)

    def pre_logged(f): #在函數使用之前的記錄
        def wrapper(*args,**kargs):
            log(f,*args,**kargs)
            return f(*args,**kargs)
        return wrapper

    def post_logged(f):#在函數使用之後記錄
        def wrapper(*args,**kargs):
            now = time()
            try:
                return f(*args,**kargs)
            finally:
                log(f,*args,**kargs)
                print 'time delta:%s' %(time()-now)
        return wrapper

    try:
        return {'pre':pre_logged,'post':post_logged}[when] #查看調用何種函數進行處理
    except KeyError,e:
        raise ValueError(e),'must be pre or post'

@logged('pre')#裝飾器1
@logged('post')#裝飾器2
def hello(name):
    print 'Hello',name

hello('WORD')