python核心编程 第十一章函数 关键字**字典，非关键字*元组可变成参数 lambda

# 关键字和非关键字可变长参数都有可能用在同一个函数中，只要关键字字典是最后一个参数并
# 且非关键字元组先于它之前出现

def newfoo(arg1,arg2,*nkw,**kw):
    print 'formal arg1:',arg1
    print 'formal arg2:',arg2
    for eacharg in nkw:
        print 'other non-keyword arg:',eacharg
    for eacharg in kw.keys():
        print 'another keyword arg %s:%s'%(eacharg,str(kw[eacharg]))
#逐个列出变量参数
newfoo(10,20,30,40,foo=50,bar=60)
print '/n'
#非关键字参数放在元组中，关键字参数放在字典中
newfoo(2,4,*(6,8),**{'foo':10,'bar':12})
print '/n'
#在函数调用之外创建字典和元组
aTuple = (6,7,8)
aDict = {'z':9}
newfoo(1,2,3,x=4,y=5,*aTuple,**aDict)
#1,2  3,6,7,8  4,5,9

 

# testit()用其参数地调用了一个给定的函数，成功的话，返回一个和那函数返回值打包的 True
# 的返回值，或者 False 和失败的原因。

def testit(func,*nkwargs,**kwargs):
    try:
        retval = func(*nkwargs,**kwargs)
        result = (True,retval)
    except Exception,diag:
        result = (False,str(diag))
    return result

def test():
    funcs = (int,long,float)
    vals = (1234,12.34,'1234','12.34')
    for eachFunc in funcs:
        print '-'*20
        for eachVal in vals:
            retval = testit(eachFunc,eachVal)
            if retval[0]:
                print '%s(%s) = ' % (eachFunc.__name__,'eachVal'),retval[1]
            else:
                print '%s(%s) = FAILED' % (eachFunc.__name__,'eachVal'),retval[1]

if __name__ == '__main__':
    test()

 

'''----------------函数式编程---------------------'''
#lambda匿名函数,不用def，表达式定义和声明在一行，返回可调用的函数对象
#lambda 参数：表达式

def true():
    return True

#用lambda创建一个函数，把它保存到一个变量中，方便调用。

a = lambda:True
print a()

 

#带函数式编程构建的lambda表达式，默认以及可变参数也可以

def add(x,y):
    return x+y
lambda x,y:x+y

def Add2(x, y=2):
    return x+y 
lambda x, y=2: x+y

def showAllAsTuple(*z):
    return z 
lambda *z: z

a = lambda x,y=2:x+y    #a()等价于add2()
print a(3)  #add2(3,2)
print a(3,5)      #add2(3,5)

b = lambda *z:z
print b(23,'xyz')    #(23,'xyt')
print b(42)            #(42,)

 

'''--------------------内建函数----------------------------'''
#filter()保留函数返回为真的对象，过滤
# filter(func, seq)b 调用一个布尔函数 func 来迭代遍历每个 seq 中的元素； 返回一个
# 使 func 返回值为 ture 的元素的序列。

from random import randint
def odd(n):
    return n % 2

allNums = []
#产生10个1到100之间的随机数
for eachNum in range(9):
    allNums.append(randint(1,99))
#除掉所有的偶数
print filter(odd,allNums)

#用lambda表达式替换odd()
print filter(lambda n:n%2,allNums)
#list综合使用可以替换filter()
print [n for n in allNums if n%2]

 

#map(func,seq) 返回func(seq[i])
# map()
# 将函数调用“映射”到每个序列的元素上，并返回一个含有所有返回值的列表。

print map((lambda x:x+2),[0,1,2,3,4])
print [x+2 for x in range(6)]
#多个序列，使用map
print map(lambda x,y:x+y,[1,3,5],[2,4,6])#3,7,11
print map(None,[1,3,5],[2,4,6]) #[(1,2),(3,4),(5,6)]

 

#reduce(func, [1, 2, 3,4]) = func(func(func(1, 2), 3),4)

print 'the total is:', reduce((lambda x,y: x+y), range(5))

# reduce（）函数运行了如下的算术操作。
# ((((0 + 1) + 2) + 3) + 4) => 10