Python函数式编程——高阶函数、返回函数、匿名函数、装饰器、偏函数

本文主要是介绍Python函数式编程——高阶函数、返回函数、匿名函数、装饰器、偏函数，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

函数式编程

    函数是Python内建支持的一种封装，通过把大段代码拆成函数，通过一层一层的函数调用，把复杂任务分解成简单的任务，这种分解称之为面向过程的程序设计。函数就是面向过程的程序设计的基本单元。

    函数式编程——Functional Programming，虽然也可以归结到面向过程的程序设计，但其思想更接近数学计算。

    函数式编程是一种抽象程度很高的编程范式，纯粹的函数式编程语言编写的函数没有变量，因此，任意一个函数，只要输入是确定的，输出就是确定的，这种纯函数我们称之为没有副作用。而允许使用变量的程序设计语言，由于函数内部的变量状态不确定，同样的输入，可能得到不同的输出，因此，这种函数是有副作用的。

    函数式编程的一个特点就是，允许把函数本身作为参数传入另一个函数，还允许返回一个函数！Python对函数式编程提供部分支持。由于Python允许使用变量，因此，Python不是纯函数式编程语言。

一、高阶函数Higher-order function

1.变量可以指向函数

    以Python内置的求绝对值的函数abs()为例，调用该函数用以下代码：

a=abs
print(a(-10))

2.函数名也是变量

    函数名其实是指向函数的变量！对于abs()函数，可以把函数名abs看成变量，它指向一个可以计算绝对值的函数！

    如果把abs指向其他对象：

>>> abs = 10
>>> abs(-10)
Traceback (most recent call last):File "<stdin>", line 1, in <module>
TypeError: 'int' object is not callable

    把abs指向10后，就无法通过abs(-10)调用该函数了！因为abs这个变量已经不指向求绝对值函数而是指向一个整数10！

    注：由于abs函数实际上是定义在__builtin__模块中的，所以要让修改abs变量的指向在其它模块也生效，要用__builtin__.abs = 10。

3.传入函数

    变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

    简单的高阶函数：结果为11

def add(x,y,f):return f(x)+f(y)
m=add(-5,6,abs)
print(m)

    编写高阶函数，就是让函数的参数能够接收别的函数。

    小结：把函数作为参数传入，这样的函数称为高阶函数，函数式编程就是指这种高度抽象的编程范式。

4.map/reduce函数

    Python内建了map()和reduce()函数。

    map()函数接收两个参数，一个是函数，一个是Iterable可迭代对象，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。

    例如，函数f(x)=x²，把这个函数作用在一个list [1, 2, 3, 4, 5, 6, 7, 8, 9]上，就可以用map()实现如下：

    用Python代码实现：

def f(x):return x**2
r = map(f,[1,2,3,4,5,6,7,8,9])
print(list(r))

    map()传入的第一个参数是f，即函数对象本身。由于结果r是一个Iterator，Iterator是惰性序列，因此通过list()函数让它把整个序列都计算出来并返回一个list。

    map()作为高阶函数，它把运算规则抽象了，因此，我们不但可以计算简单的f(x)=x²，还可以计算任意复杂的函数，比如，把这个list所有数字转为字符串：

r2 =list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))

    reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，其效果就是：

reduce(f, [x1, x2, x3, x4]) = f( f( f(x1, x2), x3), x4)

    序列求和，用reduce实现：（求和运算可以直接用Python内建函数sum()）

from functools import reduce
def add(x,y):return x + y
r3 = reduce(add,[1,3,5,7,9])
print(r3)

    把序列[1, 3, 5, 7, 9]变换成整数13579

def fn(x,y):return x * 10 + y
r4 = reduce(fn,[1,3,5,7,9])
print(r4)

    考虑到字符串str也是一个序列，配合map()，我们就可以写出把str转换为int的函数：

from functools import reduce
def str2int(s):def fn(x, y):return x * 10 + ydef char2num(s):#[s]是key，函数通过s参数查找字典中的key，进而获取value，返回value的值。return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}return reduce(fn, map(char2num, s))

    练习1：    利用map()函数，把用户输入的不规范的英文名字，变为首字母大写，其他小写的规范名字。输入：['adam', 'LISA', 'barT']，输出：['Adam', 'Lisa', 'Bart']：

def normalize(name):return name.title()
L1 = ['adam', 'LISA', 'barT']
L2 = list(map(normalize, L1))
print(L2)

    练习2：   请编写一个prod()函数，可以接受一个list并利用reduce()求积：

from functools import reduce
def prod(L):def fn(x,y):return x * yreturn reduce(fn,L)
print('3 * 5 * 7 * 9 =', prod([3, 4, 5, 6]))

    练习3：   利用map和reduce编写一个str2float函数，把字符串'123.456'转换成浮点数123.456：

def str2float(s):def fn(x,y):return x * 10 + yn = s.index('.')s1 = list(map(int,[x for x in s[:n]]))s2 = list(map(int,[x for x in s[n+1:]]))return reduce(fn,s1)+ reduce(fn,s2) / 10 ** len(s2)
print('str2float(\'123.456\') =', str2float('123.456'))

解析： 

        n = s.index('.') 

    利用 index() 函数确定字符串 S 中 ‘.’的位置。 

     s1 = list(map(int,[x for x in s[:n]]))
s2 = list(map(int,[x for x in s[n+1:]]))    

    先利用切片把传入的 str 分成以前以后两个部分（根据小数点分成整数和浮点数，分别处理），然后再把切割好的 s 利用列表生成式变成单个数字字符，map() 函数再负责把 int 函数作用到截取的s的每个元素中去。 

5.filter函数

    Python内建的filter()函数用于过滤序列。

    filter()接收一个函数和一个序列。把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。

    删掉偶数，只保留奇数

def is_odd(n):return n % 2 == 1
list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
# 结果: [1, 5, 9, 15]

    把一个序列中的空字符串删掉，可以这么写：

def not_empty(s):return s and s.strip()#移除字符串头尾空字符
list(filter(not_empty, ['A', '', 'B', None, 'C', '  ']))
# 结果: ['A', 'B', 'C']

    注意：filter()函数返回的是一个Iterator，也就是一个惰性序列，所以要强迫filter()完成计算结果，需要用list()函数获得所有结果并返回list。

    PS：关于Lambda

fun = [(lambda n : i + n) for i in range(10)]  
print fun[3](4)  
print fun[4](4)  

    输出为13,13......首先fun为一个函数数组， i是外部变量，i等于range最后输出的9，fun[x](y)的意思是第x个函数，n赋值为y，由于i为9，n=4，所以输出为13,13

fun = [(lambda n,m = i : m + n) for i in range(10)]  
print fun[3](4)  
print fun[4](4) 

    输出为7,8......m得到了外部的i值形成了闭包，fun [3](4) = lambda n,m=3:3+n n为4

用filter求素数

    计算素数的一个方法是埃氏筛法.

    列出从2开始的所有自然数，构造一个序列：2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...

    取序列的第一个数2，它一定是素数，然后用2把序列的2的倍数筛掉：3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...

    取新序列的第一个数3，它一定是素数，然后用3把序列的3的倍数筛掉：5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...

    取新序列的第一个数5，然后用5把序列的5的倍数筛掉：7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...不断筛下去，就可以得到所有的素数。

def _odd_iter():#初始数列直接考虑奇数列，除2之外的偶数都不是素数n = 1 while True:#数列生成器，不担心没有退出条件n = n+2yield n
def _not_divisible(n):#排除条件return lambda x:x % n >0
def primes():yield 2it = _odd_iter()#初始数列，其为无穷数列while True:n = next(it)yield n it = filter(_not_divisible(n),it) #filter()将it中的元素分别作用于参数为n的_not_divisible函数，为False的都删除
for n in primes():#限定一个输出范围，否则无限输出下去if n<100:print(n)else:break

    第一轮输出为yield 2，第二轮输出为循环第一步yield n 为 3时，此时以n为3的参数，对it进行元素筛选，能被3整除的元素都删除，然后输出第一个元yield n 为5，再筛选能被5整除的元素，依次进行下去.......

    练习：回数是指从左向右读和从右向左读都是一样的数，例如12321，909。请利用filter()滤掉非回数：

def is_palindrome(n):I,m = n,0while I:m = I%10+m*10I = I//10return (n==m)output = filter(is_palindrome,range(0,1000))
print(list(output))

    小结：filter()的作用是从一个序列中筛出符合条件的元素。由于filter()使用了惰性计算，所以只有在取filter()结果的时候，才会真正筛选并每次返回下一个筛出的元素。

6.sorted排序算法

    Python内置的sorted()函数就可以对list进行排序：

>>> sorted([36, 5, -12, 9, -21])
[-21, -12, 5, 9, 36]

    sorted()函数也是一个高阶函数，它还可以接收一个key函数来实现自定义的排序，例如按绝对值大小排序：

>>> sorted([36, 5, -12, 9, -21], key=abs)
[5, 9, -12, -21, 36]

    key指定的函数将作用于list的每一个元素上，并根据key函数返回的结果进行排序。

    字符串排序，默认情况下，对字符串排序，是按照ASCII的大小比较的，由于'Z' < 'a'，结果，大写字母Z会排在小写字母a的前面：

>>> sorted(['bob', 'about', 'Zoo', 'Credit'])
['Credit', 'Zoo', 'about', 'bob']

    用一个key函数把字符串映射为忽略大小写排序即可再比较。

>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower)
['about', 'bob', 'Credit', 'Zoo']

    反向排序，不必改动key函数，可以传入第三个参数reverse=True：

>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)
['Zoo', 'Credit', 'bob', 'about']

小结：sorted()也是一个高阶函数。用sorted()排序的关键在于实现一个映射函数。

练习：    用一组tuple表示学生名字和成绩：L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]请用sorted()对上述列表分别按名字和分数排序：

方法一：

L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
def by_name(t):return t[0].lower()
def by_score(t):return t[1]	
L2 = sorted(L, key=by_name)
print(L2)
L3 = sorted(L, key=by_score,reverse=True)
print(L3)

#【分析】 

    L列表中的每个元素都是一个元组，首先按名字排序，key作用与排序中列表里的每一个元素，所以传入by_name里的参数t是一个元组，需要对元组的第一个元素进行排序，所以是t[0]。

方法二：

def by_name(t):for i in t:                       if isinstance(i,str):    return i.lower()                         

二、返回函数

高阶函数除了可以接受函数作为参数外，还可以把函数作为结果值返回。

def lazy_sum(*args):def sum():ax = 0for n in args:ax = ax + nreturn axreturn sum

调用lazy_sum()时，返回的并不是求和结果，而是求和函数：

>>> f = lazy_sum(1, 3, 5, 7, 9)
>>> f
<function lazy_sum.<locals>.sum at 0x101c6ed90>

调用函数f时，才真正计算求和的结果：

>>> f()
25

    在函数lazy_sum中定义了函数sum，并且，内部函数sum可以引用外部函数lazy_sum的参数和局部变量，当lazy_sum返回函数sum时，相关参数和变量都保存在返回的函数中，这种程序结构称为“闭包（Closure）”。

    调用lazy_sum()时，每次调用都会返回一个新的函数，调用结果互不影响，即使传入相同的参数：

>>> f1 = lazy_sum(1, 3, 5, 7, 9)
>>> f2 = lazy_sum(1, 3, 5, 7, 9)
>>> f1==f2
False

1.闭包

    注意到返回的函数在其定义内部引用了局部变量args，所以，当一个函数返回了一个函数后，其内部的局部变量还被新函数引用，所以，闭包用起来简单，实现起来可不容易。
    另一个需要注意的问题是，返回的函数并没有立刻执行，而是 直到调用了f()才执行

def count():fs = []for i in range(1, 4):def f():return i*ifs.append(f)return fsf1, f2, f3 = count()

>>> f1()
9
>>> f2()
9
>>> f3()
9

    每次循环，都创建了一个新的函数，然后，把创建的3个函数都返回了。结果为9的原因：返回的函数引用了变量i，但它并非立刻执行。等到3个函数都返回时，它们所引用的变量i已经变成了3，因此最终结果为9。

    返回闭包时牢记的一点就是：返回函数不要引用任何循环变量，或者后续会发生变化的变量。
    如果一定要引用循环变量，就再创建一个函数，用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变：

def count():def f(j):return lambda :j*jfs=[]for i in range(1,4):fs.append(f(i))return fsf1,f2,f3 = count()
print(f1())
print(f2())

小结：    一个函数可以返回一个计算结果，也可以返回一个函数。返回一个函数时，牢记该函数并未执行，返回函数中不要引用任何可能会变化的变量

三、匿名函数

    当我们在传入函数时，有些时候，不需要显式地定义函数，直接传入匿名函数更方便。在Python中，对匿名函数提供了有限支持。

>>> list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
[1, 4, 9, 16, 25, 36, 49, 64, 81]

    匿名函数lambda x: x * x实际上就是：

def f(x):return x * x

     关键字lambda表示匿名函数，冒号前面的x表示函数参数。匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。
    匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数：

>>> f = lambda x: x * x
>>> f
<function <lambda> at 0x101c6ef28>
>>> f(5)
25

    也可以把匿名函数作为返回值返回，比如：

def build(x, y):return lambda: x * x + y * y

小结：Python对匿名函数的支持有限，只有一些简单的情况下可以使用匿名函数。

四、装饰器

    假设我们要增强now()函数的功能，比如，在函数调用前后自动打印日志，但又不希望修改now()函数的定义，在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。本质上，decorator就是一个返回函数的高阶函数。

    定义一个能打印日志的decorator如下：

def log(func):def wrapper(*args, **kw):print('call %s():' % func.__name__)return func(*args, **kw)return wrapper

    函数log，是一个decorator，所以可以接受一个函数作为参数，并返回一个函数。函数对象有一个__name__属性，可以拿到函数的名字。

    借助Python的@语法，把decorator置于函数的定义处：

@log
def now():print('2015-3-25')

    调用now()函数，不仅会运行now()函数本身，还会在运行now()函数前打印一行日志：

>>> now()
call now():
2015-3-25

    把@log放到now()函数的定义处，相当于 在调用now()前，定义now()后执行了语句：

now = log(now)

    log()是一个decorator，返回一个函数，所以，原来的now()函数仍然存在，只是现在同名的now变量指向了新的函数wrapper()函数。

    wrapper()函数的参数定义是(*args, **kw)，因此，wrapper()函数可以接受任意参数的调用。在wrapper()函数内，首先打印日志，再紧接着调用原始函数。

    如果decorator本身需要传入参数，那就需要编写一个返回decorator的高阶函数，写出来会更复杂。比如，要自定义log的文本：

def log(text):def decorator(func):def wrapper(*args, **kw):print('%s %s():' % (text, func.__name__))return func(*args, **kw)return wrapperreturn decorator

    3层嵌套的decorator用法如下：相当于 now = log('execute')(now)

@log('execute')
def now():print('2015-3-25')

    执行结果如下：

>>> now()
execute now():
2015-3-25

    经过decorator装饰之后的函数，它们的__name__已经从原来的'now'变成了'wrapper'：

>>> now.__name__
'wrapper'

    因为返回的那个wrapper()函数名字就是'wrapper'，所以，需要把原始函数的__name__等属性复制到wrapper()函数中，否则，有些依赖函数签名的代码执行就会出错。
    不需要编写wrapper.__name__ = func.__name__这样的代码，Python内置的functools.wraps就是干这个事的，所以，一个完整的decorator的写法如下：

import functoolsdef log(func):@functools.wraps(func)def wrapper(*args, **kw):print('call %s():' % func.__name__)return func(*args, **kw)return wrapper

>>> now.__name__
'now'

    针对带参数的decorator：

import functoolsdef log(text):def decorator(func):@functools.wraps(func)def wrapper(*args, **kw):print('%s %s():' % (text, func.__name__))return func(*args, **kw)return wrapperreturn decorator

小结：在面向对象（OOP）的设计模式中，decorator被称为装饰模式。OOP的装饰模式需要通过继承和组合来实现，而Python除了能支持OOP的decorator外，直接从语法层次支持decorator。Python的decorator可以用函数实现，也可以用类实现。decorator可以增强函数的功能，定义起来虽然有点复杂，但使用起来非常灵活和方便。

练习：编写一个decorator，能在函数调用的前后打印出'begin call'和'end call'的日志。再思考一下能否写出一个@log的decorator，使它可以同时支持

@log('execute')  / @log
def f():pass 

import functoolsdef log(text):if isinstance(text,(int,str,float)):def decorator(func):@functools.wraps(func)def wrappers(*args,**kw):print('begin call %s %s():' % (text,func.__name__))out = func(*args,**kw)print('end call %s %s():' % (text,func.__name__))return outreturn wrappersreturn decoratorelse:func = text@functools.wraps(func)def wrapper(*args,**kw):print('begin call %s():' % func.__name__)out = func(*args,**kw)print('end call %s():' % func.__name__)return outreturn wrapper

五、偏函数

    Python的functools模块提供了很多有用的功能，其中一个就是偏函数（Partial function）。通过设定参数的默认值，可以降低函数调用的难度。偏函数也可以做到这一点。举例如下：

    int()函数可以把字符串转换为整数，当仅传入字符串时，int()函数默认按十进制转换：

>>> int('12345')
12345

    int()函数还提供额外的base参数，默认值为10。如果传入base参数，就可以做N进制的转换：

>>> int('12345', base=8)
5349
>>> int('12345', 16)
74565

    假设要转换大量的二进制字符串，每次都传入int(x, base=2)非常麻烦，于是，我们想到，可以定义一个int2()的函数，默认把base=2传进去，

def int2(x, base=2):return int(x, base)

    functools.partial可以创建一个偏函数，不需要自己定义int2()，可以直接使用下面的代码创建一个新的函数int2：

>>> import functools
>>> int2 = functools.partial(int, base=2)

    functools.partial的作用是，把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单。新的int2函数，base参数重新设定默认值为2， 但也可以在函数调用时传入其他值。
    创建偏函数时，实际上可以接收函数对象、*args和**kw这3个参数

max2 = functools.partial(max, 10)
max2(5, 6, 7)

    相当于：

args = (10, 5, 6, 7)
max(*args)

小结： 当函数的参数个数太多，需要简化时，使用functools.partial可以创建一个新的函数，这个新函数可以固定住原函数的部分参数，从而在调用时更简单。

这篇关于Python函数式编程——高阶函数、返回函数、匿名函数、装饰器、偏函数的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---