python 函数式编程 高阶函数 装饰器

# -*- coding:gb2312 -*-
#coding=utf-8
# 高阶函数
import math
def is_sqr(x):
y = int(math.sqrt(x))
return x == y*y
print filter(is_sqr, range(1, 101))

# 返回函数
# 作用：延迟执行
def calc_prod(lst):
def lazy_prod():
def f(x,y):
return x*y
return reduce(f, lst)

return lazy_prod

f = calc_prod([1, 2, 3, 4])
print f()

# 匿名函数
print filter(lambda s: s and len(s.strip()) > 0, ['test', None, '', 'str', '  ', 'END'])

# 装饰器 @decorator
print "....装饰器...."
def log(f):
# 写法一
# def fn(x):
# print 'call ' + f.__name__ + '()...'
# return f(x)
# return fn
# 写法二
print 'call ' + f.__name__ + '()...'
return f

@log
def factorial(n):
return reduce(lambda x,y: x*y, range(1, n+1))
print factorial(10)

# 无参数装饰器
print "....无参数装饰器...."

import time
# 写法一，接收一个函数返回一个新函数，但是返回的新函数必须符合原函数的调用规则，即参数应该一致。
# 如，log()是无参函数，则调用就不能传递参数
def performance(f):
def log(x):
print time.time()
return f(x)
return log

# 写法二，不用函数封装，直接添加新的操作
def performance2(f):
print time.time()
return f

# 写法一优化,被装饰的函数前后可以执行不同的操作，即，返回的新函数可以在任意时候调用被装饰的函数
def performance3(f):
def log(x):
start_time = time.time()
r = f(x)  # 在新函数的此处调用被装饰函数，但是，此时被装饰函数尚未被调用，因为log函数尚未被调用，只是返回了函数对象
time.sleep(1)
end_time = time.time()
print 'call %s() in %fs' % (f.__name__, (end_time - start_time))
return r
return log

# 写法二优化，不用函数封装，直接添加新的操作
def performance4(f):
start_time = time.time()
r = f # 在此处调用被装饰函数
time.sleep(1)
end_time = time.time()
print 'call %s() in %fs' % (f.__name__, (end_time - start_time))
return r

@performance4
def factorial(n):
return reduce(lambda x,y: x*y, range(1, n+1))

print factorial(10)

# 带参数装饰器
print "....带参数装饰器...."

def performance_parm(unit='s'):
def performance5(f):
def log(x):
start_time = time.time()
r = f(x)  # 在新函数的此处调用被装饰函数，但是，此时被装饰函数尚未被调用，因为log函数尚未被调用，只是返回了函数对象
time.sleep(1)
end_time = time.time()
print 'call %s() in %fs %s' % (f.__name__, (end_time - start_time), unit)
return r
return log
return performance5

@performance_parm('M')
def factorial(n):
return reduce(lambda x,y: x*y, range(1, n+1))

print factorial(10)

# 完善decorator
print "....完善decorator...."
print factorial.__name__
# => log
# 可见，由于decorator返回的新函数函数名已经不是'f2'，而是@log内部定义的'wrapper'。这对于那些依赖函数名的代码就会失效。
# decorator还改变了函数的__doc__等其它属性。
# 如果要让调用者看不出一个函数经过了@decorator的“改造”，就需要把原函数的一些属性复制到新函数中。
# Python内置的functools可以用来自动化完成这个“复制”的任务
import functools
def performance5(f):
@functools.wraps(f)
def log(x):
start_time = time.time()
r = f(x)  # 在新函数的此处调用被装饰函数，但是，此时被装饰函数尚未被调用，因为log函数尚未被调用，只是返回了函数对象
time.sleep(1)
end_time = time.time()
print 'call %s() in %fs %s' % (f.__name__, (end_time - start_time), unit)
return r
return log

@performance5
def factorial(n):
return reduce(lambda x,y: x*y, range(1, n+1))
print "....装饰器修改后...."
print factorial.__name__