3.函数式编程

函数式编程就是一种抽象程度很高的编程范式，纯粹的函数式编程语言编写的函数没有变量，因此，任意一个函数，只要输入是确定的，输出就是确定的，这种纯函数我们称之为没有副作用。
而允许使用变量的程序设计语言，由于函数内部的变量状态不确定，同样的输入，可能得到不同的输出，因此，这种函数是有副作用的。
函数式编程的一个特点就是，允许把函数本身作为参数传入另一个函数，还允许返回一个函数
Python对函数式编程提供部分支持。由于Python允许使用变量，因此，Python不是纯函数式编程语言。

高阶函数

变量可以指向函数，函数名也是变量，一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。编写高阶函数，就是让函数的参数能够接收别的函数

map/reduce

Python内建了map()和reduce()函数。
Google著名论文“MapReduce: Simplified Data Processing on Large Clusters”

map

map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回
map的作用是将运算规则抽象，允许计算复杂的函数规则，例如：把list所有数字转为字符串只需要一行代码

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

reduce

reduce把一个函数作用在一个序列[x1, x2, x3, …]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，效果等价于
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
例如str2int函数的实现：

from functools import reduce

DIGITS = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}

# way 1
def str2int(s):
    def fn(x, y):
        return x * 10 + y
    def char2num(s):
        return DIGITS[s]
    return reduce(fn, map(char2num, s))

# way 2: lambda function
def char2num(s):
    return DIGITS[s]

def str2int(s):
    return reduce(lambda x, y: x * 10 + y, map(char2num, s))

练习1

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

# -*- coding: utf-8 -*-
def normalize(name):
    return name[0].upper() + name[1:].lower()

L1 = ['adam', 'LISA', 'barT']
L2 = list(map(normalize, L1))
print(L2)

练习2

Python提供的sum()函数可以接受一个list并求和，请编写一个prod()函数，可以接受一个list并利用reduce()求积：

# -*- coding: utf-8 -*-
from functools import reduce
def prod(L):
    return reduce(lambda x, y: x * y, L)

练习3

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

# -*- coding: utf-8 -*-
from functools import reduce
###########################################################
# 实现方法1
###########################################################
def str2float(s):
    n = 0 # 浮点的位数
    for i in range(0,len(s)):
        if (s[i]=='.'):
            n = len(s) - i - 1
            break
    newstr = (s[:n] + s[n+1:]) if (n>0) else ['0']*(len(s)-1)
    
    DIGITS = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, 
    '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
    def char2num(st):
        return DIGITS[st]
    return reduce(lambda x, y: x * 10 + y, map(char2num, newstr)) / pow(10,n)

###########################################################
# 实现方法2
###########################################################
def str2float(s):
    newstr = s.split('.')
    DIGITS = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, 
    '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
    def char2num(st):
        return DIGITS[st]
    intpart = reduce(lambda x, y: x * 10 + y, map(char2num, newstr[0]))
    decpart = reduce(lambda x, y: x * 10 + y, map(char2num, newstr[1]))
    return intpart + decpart/pow(10,len(newstr[1]))

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()关键在于正确实现一个“筛选”函数。filter()函数返回的是一个Iterator，因此一个惰性序列，所以要强迫filter()完成计算结果，需要用list()函数获得所有结果并返回list。
Iterator是惰性计算的序列，所以我们可以用Python表示“全体自然数”，“全体素数”这样的序列，而代码非常简洁。
例如，用filter实现以埃氏算法计算素数：

# 构造一个从3开始的奇数序列
def _odd_iter():
    n = 1
    while True:
        n = n + 2
        yield n

# 定义一个筛选函数
def _not_divisible(n):
    return lambda x: x % n > 0

# 定义一个生成器，不断返回下一个素数
def primes():
    yield 2
    it = _odd_iter() # 初始序列
    while True:
        n = next(it) # 返回序列的第一个数
        yield n
        it = filter(_not_divisible(n), it) # 构造新序列

# 打印1000以内的素数:
for n in primes():
    if n < 1000:
        print(n)
    else:
        break

练习

回数是指从左向右读和从右向左读都是一样的数，例如12321，909。请利用filter()筛选出回数：

# -*- coding: utf-8 -*-
def is_palindrome(n):
    return str(n)[::-1] == str(n)

sorted

排序也是在程序中经常用到的算法。无论使用冒泡排序还是快速排序，排序的核心是比较两个元素的大小。如果是数字，我们可以直接比较，但如果是字符串或者两个dict呢？直接比较数学上的大小是没有意义的，因此，比较的过程必须通过函数抽象出来。
Python内置的sorted()函数可以对list进行排序，sorted()函数也是一个高阶函数，它可以接收一个key函数来实现自定义的排序
key指定的函数将作用于list的每一个元素上，并根据key函数返回的结果进行排序。然后sorted()函数按照keys进行排序，并按照对应关系返回list相应的元素
高阶函数的抽象能力非常强大，而且核心代码可以保持得非常简洁
以字符串排序为例：

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

sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower)
# 忽略大小写排序：['about', 'bob', 'Credit', 'Zoo']

sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)
# 忽略大小写逆序：['Zoo', 'Credit', 'bob', 'about']

练习

假设我们用一组tuple表示学生名字和成绩，请用sorted()对上述列表分别按名字排序，再按成绩从高到低排序

# -*- coding: utf-8 -*-

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

返回函数

函数作为返回值

高阶函数除了可以接受函数作为参数外，还可以把函数作为结果值返回。
例如：实现可变参数的求和，在函数lazy_sum中又定义了函数sum，并且，内部函数sum可以引用外部函数lazy_sum的参数和局部变量，当lazy_sum返回函数sum时，相关参数和变量都保存在返回的函数中

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

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

注意：每次调用lazy_sum()都会返回一个新的函数，即使传入相同的参数
这种程序结构称为“闭包（closure）”

闭包

返回的函数在其定义内部引用了局部变量args，所以，当一个函数返回了一个函数后，其内部的局部变量还被新函数引用
返回的函数并没有立刻执行，而是直到调用了才执行。返回闭包时牢记一点：返回函数不要引用任何循环变量，或者后续会发生变化的变量。

练习

利用闭包返回一个计数器函数，每次调用它返回递增整数：

# -*- coding: utf-8 -*-
def createCounter():
    count = list([0])
    def counter():
        count[0] = count[0] + 1
        return count[0]   
    return counter

匿名函数

Python中，对匿名函数提供了有限支持。关键字lambda表示匿名函数，冒号前面的x表示函数参数。
匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果
用匿名函数有个好处，因为函数没有名字，不必担心函数名冲突。此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数，也可以把匿名函数作为返回值返回

练习

请用匿名函数改造下面的代码：

# -*- coding: utf-8 -*-
def is_odd(n):
    return n % 2 == 1
# 原有情况
L = list(filter(is_odd, range(1, 20)))
# 匿名函数改造
L = list(filter(lambda x: x % 2 == 1, range(1,20)))

print(L)

装饰器

要增强某一函数的功能，比如，在函数调用前后自动打印日志，但又不希望修改原函数的定义，这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）
在面向对象（OOP）的设计模式中，decorator被称为装饰模式。OOP的装饰模式需要通过继承和组合来实现，而Python除了能支持OOP的decorator外，直接从语法层次支持decorator。Python的decorator可以用函数实现，也可以用类实现。
decorator可以增强函数的功能，定义起来虽然有点复杂，但使用起来非常灵活和方便。
本质上，decorator就是一个返回函数的高阶函数。
例1：定义一个能打印日志的decorator

def log(func):
    # wrapper()函数的参数定义是(*args, **kw)
    # 因此，wrapper()函数可以接受任意参数的调用
    def wrapper(*args, **kw):
        # 在wrapper()函数内，首先打印日志，再紧接着调用原始函数。
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper

@log # 把@log放到now()函数的定义处，相当于执行了语句：now = log(now)
def now():
    print('2015-3-25')

# log()是一个decorator，返回一个函数
# 原来的now()函数仍然存在，只是现在同名的now变量指向了新的函数
# 调用now()将执行新函数，即在log()函数中返回的wrapper()函数
>>> now()
call now():
2015-3-25

例2：定义一个能打印日志的decorator，且自定义log的文本，是一个3层嵌套的decorator

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

@log('execute') # 相当于now = log('execute')(now)
def now():
    print('2015-3-25')

# 执行now()等价于执行log('execute')(now)
# 先执行log('execute')，返回decorator函数
# 再调用返回的函数，参数是now函数
# 最终返回wrapper函数
>>> now()
execute now():
2015-3-25

经过decorator装饰之后的函数，它们的__name__已经从原来的’now’变成了’wrapper’，有问题！有些依赖函数签名的代码执行会出错。
需要把原始函数的__name__等属性复制到wrapper()函数中，Python内置了functools.wraps，一个完整的decorator写法如下：

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

# 例2
def log(text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator

练习1

请设计一个decorator，它可作用于任何函数上，并打印该函数的执行时间：

# -*- coding: utf-8 -*-
import time, functools

def metric(fn):
    @functools.wraps(fn)
    def wrapper(*args, **kw):
        start = time.time()
        value = fn(*args, **kw)
        print('%s executed in %s ms' % (fn.__name__, (time.time()-start)*1000))
        return value
    return wrapper

练习2

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

@log
def f():
    pass

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

所需的decorator如下

import functools
def log(text=''):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(func):
            print('begin call '+text)
            v = func(*args, **kw)
            print('end call')
            return v
        return wrapper
    return decorator

一篇讲装饰器的优秀文章：
https://www.runoob.com/w3cnote/python-func-decorators.html

偏函数

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

import functools
# 固定base的值为2，相当于 kw = { 'base': 2 } 再调用 int(str, **kw)
int2 = functools.partial(int, base=2)