python中factor函数_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')