15.函数式编程和偏函数

 

 

五、函数式编程

 

匿名函数与lambda

1、python允许用lambda关键字创造匿名函数

2、匿名是因为不需要以标准的def方式来声明

3、一个完整的lambda语句代表了一个表达式，这个表达式的定义体必须和声明放在同一行

lambda [arg1[, arg2, ... argN]]: expression

 

 例子1：

>>> a = lambda x, y: x + y
>>> print a(3, 4)
7

 

例子2：

>>> def add(x,y):           #定义一个加法函数
    return x+y              #返回两个参数的相加的值
 
>>> z=add(3,4)               
>>> print z 
7                                     #调用加法函数返回7
>>> lambda x,y:x+y
<function <lambda> at 0x0000020F385B86A8>   
#可以看到lambda是一个   function（函数）类对象
>>> f=lambda x,y:x+y          #功能实现的跟add(x,y)一样       
>>> f(1,2)
3
>>> f(3,4)
7
>>> def multiply(x,y):
    return x*y
 
>>> multiply(3,4)
12
>>> multiply=lambda x,y:x*y
>>> multiply(3,4)
12
>>> def subtract(x,y):
    return x-y
 
>>> subtract(3,4)
-1
>>> subtract=lambda x,y:x-y
>>> subtract(3,4)
-1
 
>>> def divide(x,y):
    return x/y
 
>>> divide(4,2)
2.0
>>> divide=lambda x,y:x/y
>>> divide(4,2)
2.0
 
#上面的乘法函数，减法函数，除法函数都可以用lambda表达式来代替，更方便

 

 

 

 

 

高阶函数

 

高阶函数

 

结论：

一个函数可以作为参数传给另外一个函数，或者一个函数为另外一个函数的返回值（若返回值为该函数本身，则为递归），满足其一则为高阶函数。

 

高阶函数英文叫Higher-order function。什么是高阶函数？我们以实际代码为例子，一步一步深入概念

 

变量可以指向函数

 

函数本身也可以赋值给变量，即：变量可以指向函数。如果一个变量指向了一个函数，那么，可以通过该变量来调用这个函数

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

>>> abs(-10)
10

 

但是，如果只写abs呢？

>>> abs
<built-in function abs>

 

可见，abs(-10)是函数调用，而abs是函数本身。

要获得函数调用结果，我们可以把结果赋值给变量：

>>> x = abs(-10)
>>> x
10

 

但是，如果把函数本身赋值给变量呢？

>>> f = abs
>>> f
<built-in function abs>

 

结论：函数本身也可以赋值给变量，即：变量可以指向函数。

如果一个变量指向了一个函数，那么，可否通过该变量来调用这个函数？用代码验证一下：

>>> f = abs
>>> f(-10)
10

 

成功！说明变量f现在已经指向了abs函数本身。直接调用abs()函数和调用变量f()完全相同。

 

 

函数名也是变量

那么函数名是什么呢？函数名其实就是指向函数的变量！对于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函数，请重启Python交互环境。

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

 

传入函数

 

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

 

 一个最简单的高阶函数：

 

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

 

当我们调用add(-5, 6, abs)时，参数x，y和f分别接收-5，6和abs，根据函数定义，我们可以推导计算过程为：

 

x = -5
y = 6
f = abs
f(x) + f(y) ==> abs(-5) + abs(6) ==> 11
return 11

 

用代码验证一下

>>> add(-5, 6, abs)
11

 

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

小结

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

 

函数作为返回值

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

我们来实现一个可变参数的求和。通常情况下，求和的函数是这样定义的：

def calc_sum(*args):
    ax = 0
    for n in args:
        ax = ax + n
    return ax

但是，如果不需要立刻求和，而是在后面的代码中，根据需要再计算怎么办？可以不返回求和的结果，而是返回求和的函数：

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return 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时，相关参数和变量都保存在返回的函数中，这种称为"闭包"的程序结构拥有极大的威力。

请再注意一点，当我们调用lazy_sum()时，每次调用都会返回一个新的函数，即使传入相同的参数：

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

f1()和f2()的调用结果互不影响。

 

 内建高阶函数

 

map()函数

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

 

返回值
Python 2.x 返回列表。
Python 3.x 返回迭代器。

 

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

 

 现在，我们用Python代码实现：

>>> def f(x):
...     return x * x
...
>>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> list(r)
[1, 4, 9, 16, 25, 36, 49, 64, 81]

 

如果不是交互式的话，可以这样做：

def f(x):
    return x * x

print map(f,[1, 2, 3, 4, 5, 6, 7, 8, 9])

或者

def f(x):
    return x * x

print map(f,[i for i in range(1,10)])

 

执行结果：

[1, 4, 9, 16, 25, 36, 49, 64, 81]

 map()传入的第一个参数是f，即函数对象本身。由于结果r是一个Iterator，Iterator是惰性序列，因此通过list()函数让它把整个序列都计算出来并返回一个list。
你可能会想，不需要 map() 函数，写一个循环，也可以计算出结果：

def f(x):
    return x * x

L = []
for n in [1, 2, 3, 4, 5, 6, 7, 8, 9]:
    L.append(f(n))
print L

执行结果：

[1, 4, 9, 16, 25, 36, 49, 64, 81]

 

 

的确可以，但是，从上面的循环代码，能一眼看明白"把f(x)作用在list的每一个元素并把结果生成一个新的list"吗？
所以， map() 作为高阶函数，事实上它把运算规则抽象了，因此，我们不但可以计算简单的f(x)=x ，还可以计算任意复杂的函数，比如，把这个list所有数字转为字符串：

def f(x):
    return x * x

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

执行结果：

['1', '2', '3', '4', '5', '6', '7', '8', '9']

 只需要一行代码。

 

filter()函数

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

例如，在一个list中，删掉偶数，只保留奇数，可以这么写：

 

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

 

或者使用filter+lambda结合：

print filter(lambda n:n %2, [1, 2, 4, 5, 6, 9, 10, 15])

 

执行结果：

[1, 5, 9, 15]

 

 

reduce()函数

 

同样的接收两个参数，一个是函数，一个是可迭代对象 Iterable Object（eg: list列表）。reduce中的函数必须也要接收2个参数，执行时把前一个结果继续和序列的下一个元素做累积计算，其效果就是：

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

python2中，为内置函数

python3中，导入reduce, from functools import reduce

 

 

比方说对一个序列求和，就可以用reduce实现：

 

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

print reduce(add,[1,3,5,7,9])

执行结果：

25

 

阶乘

 

#!/usr/bin/env python
#coding:utf8

def mulit(x,y):
    return x * y

print reduce(mulit,[1,3,5,7,9])

 

执行结果：

945

 

 

 

sorted函数

 

 

列表里面提供了sort方法，其它数据结构没有.sorted方法可以对任何可迭代对象排序
sort方法支持原地排序(变量排序后，变量本身改变),sorted排序后返回一个新的列表，并不改变原有变量
默认sort和sorted方法由小到大进行排序排序，reverse=True时，由小到大进行排序

 

排序是在程序中经常用到的算法。无论使用冒泡排序还是快速排序，排序的核心是比较两个元素的大小。如果是数字，我们可以直接比较，但如果是字符串或者两个dict呢？直接比较数学上的大小是没有意义的，因此，比较的过程必须通过函数抽象出来。

 

1.sorted() 函数就可以对list进行排序

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

2、sorted() 函数也是一个高阶函数，它还可以接收一个比较函数来实现自定义的排序。比如，如果要倒序排序，我们就可以自定义一个 reversed_cmp 函数：

def reversed_cmp(x, y):
　　if x > y:
　　　　return -1
　　if x < y:
　　　　return 1
　　return 0

传入自定义的比较函数 reversed_cmp ，就可以实现倒序排序：

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

 

我们再看一个字符串排序的例子：

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

默认情况下，对字符串排序，是按照ASCII的大小比较的，由于 'Z' < 'a' ，结果，大写字母 Z 会排在小写字母 a的前面。
现在，我们提出排序应该忽略大小写，按照字母序排序。要实现这个算法，不必对现有代码大加改动，只要我们能定义出忽略大小写的比较算法就可以：

def cmp_ignore_case(s1, s2):
　　u1 = s1.upper()
　　u2 = s2.upper()
　　if u1 < u2:
　　　　return -1
　　if u1 > u2:
　　　　return 1
　　return 0

忽略大小写来比较两个字符串，实际上就是先把字符串都变成大写（或者都变成小写），再比较。
这样，我们给 sorted 传入上述比较函数，即可实现忽略大小写的排序：

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

 

 

 

偏函数

 

 

偏函数（Partial function）是通过将一个函数的部分参数预先绑定为某些值，从而得到一个新的具有较少可变参数的函数。

在Python中，可以通过functools中的partial高阶函数来实现偏函数功能。

首先介绍下偏函数partial。首先借助help来看下partial的定义

 

首先来说下第一行解释的意思：

partial 一共有三个部分：

（1）第一部分也就是第一个参数，是一个函数，这个函数可以是你定义的，也可以是Python内置函数

（2）第二部分是一个可变参数，*args，比如内置函数max的参数就是一个可变参数，max（1,2,3,4,5）=5

（3）第三部分是一个关键字参数，比如内置函数int的第二个参数就是命名关键字参数，默认base=10，表示int转换时默认是10进制的：

partial函数的作用就是：将所作用的函数作为partial（）函数的第一个参数，原函数的各个参数依次作为partial（）函数的后续参数，原函数有关键字参数的一定要带上关键字，没有的话，按原有参数顺序进行补充。

 

>>> from operator import add
>>> from functools import partial
>>> add10 = partial(add, 10)
>>> print add10(25)
35

 

 

 

myadd.py内容：

#!/usr/bin/env python
#coding:utf8

from functools import partial

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

if __name__ == "__main__":
    print add(10, 8)
    print add(10,30)
    print add(10,5)
    add10 = partial(add,10)
    print add10(50) 

 

执行结果

18
40
15
60

 

编写一个窗口程序，要求如下
1. 窗口程序提供三个按钮

#!/usr/bin/env python
#coding:utf8

import Tkinter
from functools import partial

root = Tkinter.Tk()
MyButton = partial(Tkinter.Button,root,fg='white',bg='blue')
b1 = MyButton(text="Button1")
b2 = MyButton(text="Button")
qb = MyButton(text='quit',command=root.quit)
b1.pack()
b2.pack()
qb.pack()
Tkinter.mainloop()

 编写一个窗口程序，要求如下
1. 窗口程序提供三个按钮
2. 其中两个按钮的前景色均为白色，背景色为蓝色
3. 第三个按钮前景色为红色，背景色为红色
4. 按下第三个按钮后，程序退出

 方案

python 可以使用 tkinter 模块实现 GUI 编程，系统默认没有安装相关模块，需要将对
应的 RPM 安装好。
由于创建按钮的实例需要很多参数，同时这些参数使用相同的值，那么可以使用偏函数
的方式将这些值固定下来以简化程序的编写。

实现此案例需要按照如下步骤进行。
步骤一：安装相关的程序包
[root@py01 bin]# yum install -y tkinter

 

步骤二：编写脚本

 

#!/usr/bin/env python
#coding:utf-8
import Tkinter #导入模块，用于编写 GUI 界面
from functools import partial #仅导入偏函数相关的功能函数

root = Tkinter.Tk() #创建背景窗口

#使用偏函数定义按钮的默认参数
MyButton = partial(Tkinter.Button, root, fg = 'white', bg = 'blue')
b1 = MyButton(text = 'Button 1') #创建按钮，指定按钮上的文字
b2 = MyButton(text = 'Button 2')
qb = MyButton(text = 'QUIT', bg = 'red', command = root.quit)

b1.pack() #将安装到背景窗口上
b2.pack()
qb.pack(fill = Tkinter.X, expand = True)
root.title('PFAs!') #设置背景窗口标题
root.mainloop() #启动窗口程序

执行结果：

 

二、偏函数的使用

A、偏函数的第二个部分(可变参数)，按原有函数的参数顺序进行补充，参数将作用在原函数上，最后偏函数返回一个新函数（类似于，装饰器decorator，对于函数进行二次包装，产生特殊效果；但又不同于装饰器，偏函数产生了一个新函数，而装饰器，可改变被装饰函数的函数入口地址也可以不影响原函数）

 

注意：如果不理解装饰器，可以先去看一下装饰器的内容

案例：我们定义一个sum函数，参数为*args可变，计算这些可变参数的和。

扩展：我们想要对sum函数求和后的结果，再加上10加上20甚至加更多，得到一个新的结果

实现：我们分别用decorator和partial来实现，对比一下二者的区别

 

（一）装饰器 decorator 实现

 

test.py

# /usr/bin/env Python3
# -*- encoding:UTF-8 -*-

from functools import wraps

def sum_add(*args1): #我们要给我们的装饰器decorator，带上参数
    def decorator(func):
        @wraps(func) #加上这句，原函数func被decorator作用后，函数性质不变
        def my_sum(*args2): #注意，参数要和原函数保持一致，真正实行扩展功能的是外层的装饰器
            my_s = 0
            for n in args1:
                my_s = my_s +n #这个是我们新加的求和结果
            return func(*args2) + my_s #这个，我们在原求和函数的结果上再加上s，并返回这个值
        return my_sum #返回my_sum函数，该函数扩展原函数的功能
    return decorator  #返回我们的装饰器

@sum_add(10,20) #启用装饰器 对sum函数进行功能扩展 
def sum(*args):
    s = 0
    for n in args:
        s = s+n
    return s
print(sum(1,2,3,4,5))
print(sum.__name__)

 

sum(1,2,3,4,5)返回的结果绝不是15，这样就失去了装饰器存在的意义，当然，这里，我们知道，sum最后返回的值应该是10+20+15 = 45，这样一来，我们的decorator就实现了我们想要的扩展功能，最后，发现，原函数sum的name属性，仍然是sum，说明，这种装饰扩展功能，不影响我们的原函数：

 

（二）偏函数 partial function 实现

这才是我们本篇的重点，准备好了，我们就开始：

我们先来看下普通函数，我们是怎么来实现

A：普通函数可变参数顺序执行

 

#!/usr/bin/env python
#coding:utf8


def sum(*args):
    s = 0
    for n in args:
        s = s + n
    return s


print(sum(10, 20) + sum(1, 2, 3, 4, 5))

 

 

 

我们如果想实现+10+20的效果，必须写两遍sum，这样写，显然是最易懂的，但是，却显得很邋遢

 

 

B：普通函数可变参数加关键字参数组合

针对上面的A过程，我们改下代码，使我们的代码看起来稍显复杂，但是略显专业：

 

 

#!/usr/bin/env python
#coding:utf8




def sum(*args, **others):
    s = 0
    for n in args:
        s = s + n
    s1 = 0
    for k in others:
        s1 = s1 + others[k]  # 我们还要算一下，关键字参数里蕴藏的求和结果，k是dict中的关键字key
    return s + s1  # 最终，我们实现扩展功能，顺序参数和关键字参数结果相加


D = {'value1': 10, 'value2': 20}
print(sum(1, 2, 3, 4, 5, **D))

 

 

 

 

代码看起来，是显得专业了，但是感觉冗余，没必要

 

C：偏函数可变参数顺序填充一步到位

 

 

上面A和B我们都说过了，这两种方式都不好，显然，这么简单的事情，我们不必麻烦decorator了，那我们还有办法没？有，Python，给我们提供了偏函数，来吧，主角登场：

提示：两种使用partial功能方式

 

（1）import functools                        -->functools.partial(func,*args)
（2）from   functools import partial -->partial(func,*args)

 

 

我们这里选第二种,我们看下demo：

 

 

#!/usr/bin/env python
#coding:utf8


from functools import partial


def sum(*args):
    s = 0
    for n in args:
        s = s + n
    return s


sum_add_10 = partial(sum, 10)  # 10 作用在sum第一个参数的位置
sum_add_10_20 = partial(sum, 10, 20)  # 10 20 分别作用在sum第一个和第二个参数的位置
print('A____________我们看下原函数sum的函数地址入口：')
print(sum)
print('B______我们看下partial函数返回函数的地址入口：')
print(partial(sum, 10))
print(sum_add_10(1, 2, 3, 4, 5))  # --> 10 + 1 + 2 + 3 + 4 + 5 = 25
print(sum_add_10_20(1, 2, 3, 4, 5))  # --> 10 + 20 + 1 + 2 + 3 + 4 + 5 = 45

 

 

 

可以看出，我们针对sum函数的求和结果，再加上10，或者加10加20，甚至加更多，都是可以通过偏函数来实现的，注意偏函数的第二部分，参数是可变的，是按顺序走的，因此，偏函数产生的新函数，sum_add_10 实际上等同于sum(10,*args)：

通过几个例子，我们最终发现，还是偏函数比较方便，一行代码就搞定了，而且新定义的函数，可以根据函数名很容易知道，这个函数扩展的原函数是哪个，实现的效果是什么：

 

 

B、偏函数的第三个部分(关键字参数)，按原有函数的关键字参数进行填补，参数将作用在原函数上，最后偏函数返回一个新函数

 

 

 

案例：我们定义一个mod求余函数，两个参数，一个是被除数，一个是除数，除数我们这里用命名关键字参数表示，默认值2

 

扩展：我们的除数不固定，可以是对2就行求余，也可以对3，对4，总之我们需要指定除数的值

 

返回结果： True 或 False

 

实现：原函数实现和partial函数实现

 

demo如下：

 

 

 

#!/usr/bin/env python
#coding:utf8


import  functools
def mod(m,key=2):
    return m % key == 0
mod_to_2 = functools.partial(mod,key=2)
print('A__3___使用原函数的默认关键字参数对2进行求余：')
print(mod(3))                           #对2进行求余-- 原函数 使用默认参数
print('B__3___使用偏函数对2进行求余：')
print(mod_to_2(3))                      #对2进行求余-- 新函数 --偏函数产生
mod_to_5 = functools.partial(mod,key=5)
print('C__25___使用原函数的关键字参数对5进行求余：')
print(mod(25,key=5))                    #对5进行求余 -- 原函数
print('D__25___使用偏函数对5进行求余：')
print(mod_to_5(25))                     #对5进行求余 -- 新函数--偏函数产生  + 3 + 4 + 5 = 45

 

 

我们发现，实际上，偏函数的作用，其实和原函数差不多，只不过，我们要多次调用原函数的时候，有些参数，我们需要多次手动的去提供值，比如上述的对5进行求余，如果我们想知道，15,45,30这些数是否能够被5整除，那么，我们用原函数的话，就需要写三次，key=5，然而，我们用偏函数的话，只需要重复调用新产生的函数mod_to_5（15 or 45 or 30）即可，至于除数5，偏函数已经为我们设定了，因此：

当函数的参数个数太多，需要简化时，使用 functools.partial 可以创建一个新的函数，这个新函数可以固定住原函数的部分参数，从而在调用时更简单。当然，decorator也可以实现，如果，我们不嫌麻烦的话。

 

偏函数参考：https://www.cnblogs.com/huyangblog/p/8999866.html