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')