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) #直接进行函数对象的引用
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')