python-函数式编程

     

map()是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回	def f(x): return x*x print map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9]) def format_name(s): return s[0].upper() + s[1:].lower() print map(format_name, ['adam', 'LISA', 'barT'])
python3中如果要使用reduce函数，需要先导入。from functools import reduce reduce()函数也是Python内置的一个高阶函数。reduce()函数接收的参数和 map()类似，一个函数 f，一个list，但行为和 map()不同，reduce()传入的函数 f 必须接收两个参数，reduce()对list的每个元素反复调用函数f，并返回最终结果值。	def f(x, y): return x + y reduce()还可以接收第3个可选参数，作为计算的初始值。如果把初始值设为100，计算：reduce(f, [1, 3, 5, 7, 9], 100) 结果将变为125，因为第一轮计算是： 计算初始值和第一个元素：f(100, 1)，结果为101。
filter()函数是  Python 内置的另一个有用的高阶函数，filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。	利用filter()，可以完成很多有用的功能，例如，删除 None 或者空字符串 def is_not_empty(s): return s and len(s.strip()) > 0 filter(is_not_empty, ['test', None, '', 'str', ' ', 'END']) 注意: s.strip(rm) 删除 s 字符串中开头、结尾处的 rm 序列的字符。 当rm为空时，默认删除空白符（包括' ', ' ', ' ', ' ') 利用filter()过滤出1~100中平方根是整数的数，即结果应该是： [1, 4, 9, 16, 25, 36, 49, 64, 81, 100] import math def is_sqr(x): r = int(math.sqrt(x)) return r*r==x print filter(is_sqr, range(1, 101))
python中自定义排序函数 Python内置的 sorted()函数可对list进行排序： >>>sorted([36, 5, 12, 9, 21]) [5, 9, 12, 21, 36] 但 sorted()也是一个高阶函数，它可以接收一个比较函数来实现自定义排序，比较函数的定义是，传入两个待比较的元素 x, y，如果 x 应该排在 y 的前面，返回 -1，如果 x 应该排在 y 的后面，返回 1。如果 x 和 y 相等，返回 0。	对字符串排序时，有时候忽略大小写排序更符合习惯。请利用sorted()高阶函数，实现忽略大小写排序的算法。 def cmp_ignore_case(s1, s2):     if s1.lower()>s2.lower():         return 1     elif s1.lower()<s2.lower():         return -1     else:         return 0 print sorted(['bob', 'about', 'Zoo', 'Credit'], cmp_ignore_case)
python中返回函数 Python的函数不但可以返回int、str、list、dict等数据类型，还可以返回函数！	def f():     print ('call f()...')     # 定义函数g:     def g():         print ('call g()...')     # 返回函数g:     return g kk = f() kk() def calc_prod(lst):     def test():         return reduce(lambda x,y:x*y,lst)     return test f = calc_prod([1, 2, 3, 4]) print f()
python中闭包 注意: 发现没法把 lazy_sum 移到 calc_sum 的外部，因为它引用了 calc_sum 的参数 lst。 像这种内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包（Closure） 闭包的特点是返回的函数还引用了外层函数的局部变量，所以，要正确使用闭包，就要确保引用的局部变量在函数返回后不能变。举例:	def calc_sum(lst): def lazy_sum(): return sum(lst) return lazy_sum def count(): fs = [] for i in range(1, 4): def f(): return i*i fs.append(f) return fs f1, f2, f3 = count() 你可能认为调用f1()，f2()和f3()结果应该是1，4，9，但实际结果全部都是 9 原因就是当count()函数返回了3个函数时，这3个函数所引用的变量 i 的值已经变成了3。由于f1、f2、f3并没有被调用， 所以，此时他们并未计算 i*i， f1现在才计算i*i，但现在i的值已经变为3 因此，返回函数不要引用任何循环变量，或者后续会发生变化的变量。 正确引用方式： def count(): fs = [] for i in range(1, 4): def f(j): def g(): return j*j return g r = f(i) fs.append(r) return fs
python中匿名函数 高阶函数可以接收函数做参数，有些时候，我们不需要显式地定义函数，直接传入匿名函数更方便。 关键字lambda 表示匿名函数 匿名函数有个限制，就是只能有一个表达式，不写return，返回值就是该表达式的结果	>>> map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]) [1, 4, 9, 16, 25, 36, 49, 64, 81]   返回函数的时候，也可以返回匿名函数： >>> myabs = lambda x: -x if x < 0 else x >>> myabs(-1) 1 >>> myabs(1) 1 print filter(lambda s: s and len(s.strip())>0, ['test', None, '', 'str', '  ', 'END'])
python中的装饰器decorator 定义了一个函数 在运行的过程中动态的给这个函数添加功能 又不想改变函数本身的代码 Python的 decorator 本质上就是一个高阶函数，它接收一个函数作为参数，然后，返回一个新函数 使用 decorator 用Python提供的 @ 语法，这样可以避免手动编写 f = decorate(f) 这样的代码。 要让 @log 自适应任何参数定义的函数，可以利用Python的 *args 和 **kw，保证任意个数的参数总是能正常调用：	def log(f): def fn(x): print 'call ' + f.__name__ + '()...' return f(x) return fn @log def factorial(n): return reduce(lambda x,y: x*y, range(1, n+1)) print factorial(10) 但是，对于参数不是一个的函数，调用将报错： @log def add(x, y): return x + y print add(1, 2) 结果： Traceback (most recent call last): File "test.py", line 15, in <module> print add(1,2) TypeError: fn() takes exactly 1 argument (2 given) def log(f): def fn(*args, **kw): print 'call ' + f.__name__ + '()...' return f(*args, **kw) return fn 现在，对于任意函数，@log 都能正常工作。 请编写一个@performance，它可以打印出函数调用的时间。 import time def performance(f):     def time_test(*args, **kw):         t1 = time.time()         r = f(*args, **kw)         t2 = time.time()         print 'call %s() in %fs' % (f.__name__, (t2 - t1))         return f(*args, **kw)     return time_test    @performance def factorial(n):     return reduce(lambda x,y: x*y, range(1, n+1)) print factorial(10)
python中编写带参数decorator  带参数的装饰器函数首先返回一个decorator函数，再让这个decorator函数接收被装饰的函数并返回新函数  在3层嵌套的decorator定义中，最内层的wrapper引用了最外层的参数prefix，所以，把一个闭包拆成普通的函数调用会比较困难。不支持闭包的编程语言要实现同样的功能就需要更多的代码。	例： def log(prefix):     def log_decorator(f):         def wrapper(*arg,**kw):             print ("logging:", prefix)             print ("start func:", f.__name__)             r=f(*arg, **kw)             print ("func run end:",f.__name__)             return r         return wrapper     return log_decorator @log("DEBUG") def my_test():     print ("kkk") my_test() 执行结果：    >>logging: DEBUG 　>>start func: my_test    >>kkk    >>func run end: my_test 实例2： import time def performance(unit):     def p_decorator(f):         def wrapper(*args,**kw):             k=time.time()             r=f(*args,**kw)             k1=time.time()             print ("the all run time is:{0}".format((k1-k)*1000 if unit=="ms" else k1-1))             return r         return wrapper     return p_decorator @performance('ms') def factorial(n):     return reduce(lambda x,y: x*y, range(1, n+1)) print factorial(10)
python中完善decorator       @decorator可以动态实现函数功能的增加，但是，经过    @decorator“改造”后的函数，和原函数相比，除了功能多一点外，有没有其它不同的地方？ 由于decorator返回的新函数函数名已经不是'f2'，而是@log内部定义的'wrapper'。这对于那些依赖函数名的代码就会失效。decorator还改变了函数的__doc__等其它属性。如果要让调用者看不出一个函数经过了@decorator的“改造”，就需要把原函数的一些属性复制到新函数中 最后需要指出，由于我们把原函数签名改成了(*args, **kw)，因此，无法获得原函数的原始参数信息。即便我们采用固定参数来装饰只有一个参数的函数： def log(f): @functools.wraps(f) def wrapper(x): print 'call...' return f(x) return wrapper 也可能改变原函数的参数名，因为新函数的参数名始终是 'x'，原函数定义的参数名不一定叫 'x'。	在没有decorator的情况下，打印函数名： def f1(x): pass print f1.__name__ 输出： f1 有decorator的情况下，再打印函数名： def log(f): def wrapper(*args, **kw): print 'call...' return f(*args, **kw) return wrapper @log def f2(x): pass print f2.__name__ 输出： wrapper 例： def log(f): def wrapper(*args, **kw): print 'call...' return f(*args, **kw) wrapper.__name__ = f.__name__ wrapper.__doc__ = f.__doc__ return wrapper 这样写decorator很不方便，因为我们也很难把原函数的所有必要属性都一个一个复制到新函数上，所以Python内置的functools可以用来自动化完成这个“复制”的任务： import functools def log(f): @functools.wraps(f) def wrapper(*args, **kw): print 'call...' return f(*args, **kw) return wrapper
python中偏函数 当一个函数有很多参数时，调用者就需要提供多个参数。如果减少参数个数，就可以简化调用者的负担。 比如，int()函数可以把字符串转换为整数，当仅传入字符串时，int()函数默认按十进制转换： 但int()函数还提供额外的base参数，默认值为10。如果传入base参数，就可以做 N 进制的转换： 假设要转换大量的二进制字符串，每次都传入int(x, base=2)非常麻烦，于是，我们想到，可以定义一个int2()的函数，默认把base=2传进去： functools.partial就是帮助我们创建一个偏函数的，不需要我们自己定义int2()，可以直接使用下面的代码创建一个新的函数int2： 所以，functools.partial可以把一个参数多的函数变成一个参数少的新函数，少的参数需要在创建时指定默认值，这样，新函数调用的难度就降低了	>>> int('12345', base=8) 5349 >>> int('12345', 16) 74565 def int2(x, base=2): return int(x, base) >>> int2('1000000') 64 >>> int2('1010101') 85 >>> import functools >>> int2 = functools.partial(int, base=2) >>> int2('1000000') 64 >>> int2('1010101') 85 import functools sorted_ignore_case = functools.partial(sorted, cmp=lambda s1, s2: cmp(s1.upper(), s2.upper())) print sorted_ignore_case(['bob', 'about', 'Zoo', 'Credit'])