函数式编程——Python学习笔记05

前言

函数是Python内建支持的一种封装，我们通过把大段代码拆成函数，通过一层层的函数调用，就可以把复杂的任务分解成简单的任务，这种分解称为面对过程的程序设计。函数就是面向过程的程序设计的基本单元。
而函数式编程 ——Functional Programming，虽然也可归结到面向过程的程序设计，但其思想更接近数学计算。
函数式编程的一个特点是，允许把函数本身作为参数传入另一个函数，还允许返回一个函数。
Python对函数式编程提供部分支持，由于Python允许使用变量，所以，Python不是纯函数式编程语言。

---

高阶函数

变量可以指向函数
abs(-10)是函数调用，abs是函数本身。要获得函数调用结果，可以把结果赋值给变量，如果要赋值给函数本身：

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

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

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

函数名也是变量

函数名其实是指向函数的变量！

对于abs()这个函数，完全可以把函数名abs看成变量，它指向一个可以计算绝对值的函数！
把abs指向10后，就无法通过abs(-10)调用该函数了！因为abs这个变量已经不指向求绝对值函数而是指向一个整数10！
注：由于abs函数实际上是定义在import builtins模块中的，所以要让修改abs变量的指向在其他模块也生效，要用import builtins; builtins.abs = 10。

传入函数
变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称为高阶函数。
例如，一个简单的高阶函数：

def add(x, y, f):
    return f(x) + f(y)
>>>add(5, 6, abs)
11

函数式编程就是指这种高度抽象的编程范式。

map/reduce

map()函数接收两个参数，一个是函数，一个是Iterable，

map将传入的函数一次作用到序列的每个元素，并把结果作为新的Iterator返回。

Iiterator是惰性序列，因此可以通过list()函数让它把整个序列都计算处理并返回一个list。
map()作为高阶函数，事实上它把运算规则抽象了,其可以计算任意复杂的函数，如把这个list的所有数字转为字符串:

>>>list(map(str, [1, 2, 3, 4, 5, 6, 7, 8]))
[‘1’, ‘2’, ‘3’, ‘4’, ‘5’, ‘6’, ‘7’, ‘8’]

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

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

可以用lambda函数简化写出str转为int的函数：

from functools import reduce
def char2num(s):
    return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
def str2int(s):
    return reduce(lambda x, y: x * 10 + y, map(char2num, s))

>>> L=['1', '2', '3']
>>> reduce(lambda x, y: x * 10 + y, map(int, L), 0)  
123

L[::-1]表示将L内元素反过来

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

# -*- coding: utf-8 -*-
from functools import reduce
def str2float(s):
    t = s if ’.’ in s else s+ ‘.’
    d, f = s.split(‘.’)    #split()通过指定分隔符对字符串进行切片，返回分割后的字符串列表
    return reduce(lambda x,y: x * 10 + y, map(int,d), 0) + reduce(lambda x, y: x / 10 + y, map(int,reverse[‘0’ + f]), 0)

#reduce()函数内有三个元素时，因为指定了第三个元素为0，所以第一次执行时，x = 0, y = f[0]；第二次执行的时候，x =f[0], y =f[1]

#reverse()函数表示将list中的元素反向排序。[‘0’ + f]中的0相当于代替’.’进行循环，把’.'放在开头 

print(str2float('345.678'))       # 345.678
print(str2float('0'))             # 0.0
print(str2float('123.456'))       # 123.456
print(str2float('123.45600'))     # 123.456
print(str2float('0.1234'))        # 0.1234
print(str2float('.1234'))         # 0.1234
print(str2float('120.0034'))      # 120.0034
print(str2float('.'))             # 0.0

filter

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

和map()类似，filter也接收一个函数和一个序列。不同的是filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素，关键在于正确实现一个“筛选”函数。
如，移除一个序列中的空字符串：

def not_empty(s):
    return s and s.strip()    #
list(filter(not_empty,['A', 'B', '', None, 'C', ' ']))
['A', 'B', 'C’]

注意filter()函数返回的也是一个惰性序列(Iterator)，需要用list()函数获得所有结果并返回到list。
用filter求素数
可以用python实现计算素数的一个方法——埃氏筛法：
1.可以先构造一个从3开始的奇数序列(这是个生成器，并且是个无限数列)：

def _odd_iter():
    n = 1
    while True:
        n = n + 2
        yield n

2.定义一个筛选函数：

def _not_divisible(n):
    return lambda x: x % n > 0  

3.定义一个生成器，不断返回下一个素数：

def primes():
    yield 2
    t = _odd_iter()#初始序列
    while True:
        n = next(t)#返回序列第一个数
        yield n
        t = filter(_not_divisible(n), t)

这个生成器先返回第一个素数2，然后，利用filter()不断产生筛选后的新的序列
4.因primes()也是一个无限数列，所以调用时需要设置一个退出循环的条件：

for n in primes():
    if n < 1000:
        print(n)
    else:
        break

sorted
排序的核心是比较两个元素的大小。比较的过程必须通过函数抽象出来。
Python内置的sorted()函数就可以对list进行排序:

>>> sorted([36,5,-6, 0,-21])
[-21, -6, 0, 5, 36]

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

>>> sorted([36, 5, -6, 0, -21],key = abs)
[0, 5, -6, -21, 36]

key指定的函数将作用于list的每一个元素上，把元素传入key函数后返回的结果进行排序，并按照对应关系返回list相应的元素。
要实现忽略大小写的排序，给sorted传入这样的key函数：key = str.lower
要进行反向排序，不必改动key函数，可以传入第三个参数reverse = True ：

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

用sorted()排序的关键在于实现一个映射函数。

---

返回函数

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

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

在这个函数中，我们在函数lazy_sum中定义了函数sum，并且，内部函数的sum可以引用外部函数lazy_sum的参数和局部变量，当lazy_sum返回函数sum时，相关参数和变量都保存在返回的函数中，这种称为“闭包（Closure）”程序。
在我们调用lazy_sum()时，每次调用都会返回一个新的函数，即使传入相同的参数：

>>> f1 = lazy_sum(1,2,3)
>>> f2 = lazy_sum(1,2,3)
>>>f1()
6
>>>f2()
6
>>> f1 ==f2
False

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

闭包
注意到上面的返回函数在其定义内部引用了局部变量args，故当一个函数返回了一个函数后，其内部的局部变量还被新函数引用。
返回的函数并没有立即执行，直到调用f()才执行。如：

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

每次循环，都创建了一个新的函数，然后把创建的3个函数都返回了。

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

返回的函数引用了变量i，但它并非立即执行。等到3个函数都返回时，它们所引用的变量i已经变成了3，因此最终结果为9.

返回闭包时牢记一点：返回函数不要引用任何循环变量，或者后续会发生变化的变量。

如果一定要引用循环变量，方法是再创建一个函数，用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变：

def count():
    def f(j):
        def g():
            return j * j
        return g
    fs = []
    for i in range(1,4):
        fs.append(f(i))    #f(i)立刻被执行，因此i的当前值被传入f()
    return fs

运行结果：

>>>f1, f2 ,f3 = count()
>>> f1()
1
>>> f2()
4
>>> f3()
9

---

匿名函数

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

lambda x :x * y关键字lambda表示匿名函数，冒号前面的x表示函数参数。

匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。
匿名函数有个好处，不用担心函数名冲突，而且，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数：

>>> f = lambda x: x*x
>>> f
<function <lambda> at 0x100656f28>
>>> f(2)
4

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

def build(x, y):#可以用lambda缩短代码
    return lambda: x * x + y * y

---

装饰器

由于函数也是一个对象，而且函数对象可以被赋值给变量，所以，通过变量也能调用该函数。

>>> def now():
    print(‘2017-5-19')
>>> f = now
>>> f()
2017-5-19

函数对象有一个__name__属性，可以拿到函数的名字：

>>>now.__name__
‘now'

在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。

本质上，decorator就是一个返回函数的高阶函数。我们可以定义一个能打印日志的decorator：

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

这个log是一个decorator，接受一个函数作为参数，并返回一个函数。

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

@log
def now()
    print(‘2017-5-19’)

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

>>>now()
call now():
2017-5-19

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

>>>now = log(now)

原来的now()函数仍然存在，只是现在同名的now变量指向了新的函数，于是调用now()将执行新函数，即在log()函数中返回的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 wrapper
    return decorator

这个3层嵌套的decorator的用法为：

>>> @log('execute')
def now():
    print('2017-5-19')

>>> now()
execute now():
2017-5-19

和两层嵌套的decorator相比，3层嵌套的效果是这样的：

>>>now = log(‘execute’)(now)

上面的语句，首先执行log(‘execute’)，返回的是decorator函数，再调用返回的函数，参数是now函数，返回值最终是wrapper函数。

经过decorator装饰之后的函数，它们的__name__已经由原来的’now’ 变成了’wrapper’。因为返回的wrapper()函数名字就是’wrapper’，所以，需要把原始函数的__name__等属性复制到wrapper()函数中，否则有些依赖函数签名的代码执行会出错。

Python内置的functools.wraps可以代替wrapper.__name__ = func.__name__这样的代码，一个完整的decorator的写法应该是把functools.wraps写在定义wrapper()的前面：

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

在面向对象（OOP）的设计模式中，decorator被称为装饰模式。OOP的装饰模式需要通过继承和组合来实现，而Python除了能支持OOP的decorator外，直接从语法层次支持decorator。Python的decorator可以用函数实现，也可以用类实现。decorator可以增强函数的功能。

---

偏函数

Python的functools提供了很多功能，其中包括偏函数。
functools.partial就是帮助我们创建一个偏函数，我们可以直接使用下面代码创建一个新的函数int2：

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

functools.partial的作用就是把某个函数的某个参数给固定（也就是设置默认值），返回一个新的函数，调用这个新的函数会更简单。
上面的int2函数仅仅是把base参数重新设定默认值为2，也可以在函数调用时传入其他的值。

创建偏函数时，实际可以接收：函数对象、*args、**kw三个参数。

定义了int2实际上是固定了int()函数的参数base：

int2(‘1000’)

相当于

kw={‘base’ = 2}
int(‘1000’, **kw)