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

高阶函数

• 变量可以指向函数

# 获取绝对值
print(abs(-1))
# 可见，abs(-1)是函数调用，而abs是函数本身。
print(abs)
# 函数本身也可以赋值给变量，即：变量可以指向函数，变量f现在已经指向了abs函数本身。
# 直接调用abs()函数和调用变量f()完全相同。
f = abs
print(f(-1))

结果
1
<built-in function abs>
1

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

abs = 10
print(abs)
print(abs(-1))

把abs指向10后，就无法通过abs(-10)调用该函数了！因为abs这个变量已经不指向求绝对值函数而是指向一个整数10！
当然实际代码绝对不能这么写，这里是为了说明函数名也是变量。要恢复abs函数，请重启Python交互环境。
注：由于abs函数实际上是定义在import builtins模块中的，所以要让修改abs变量的指向在其它模块也生效，要用import builtins; builtins.abs = 10。

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

# 以下就是高阶函数
def test(x,y,f):
    return f(x)*f(y)

print(test(2,-9,abs))

# 结果
x = 2
y = -9
f = abs
f(x) * f(y) ==> abs(-5) * abs(6) ==> 11
return 18

map/reduce

• map(fn,Iterable)：map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。

def count(x):
    return x*x

# map()传入的第一个参数是f，即函数对象本身。所以它也是高阶函数，由于结果r是一个Iterator，
# Iterator是惰性序列，因此通过list()函数让它把整个序列都计算出来并返回一个list。
print(list(map(count,[1,2,3,4,5,6,7,8,9])))

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

• reduce(fn,Iterable)：reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，其效果就是：reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)，如下例子，如何实现将一个str转成int类型的函数：

from functools import reduce

def fn(x,y):
    return x*10+y

def char2num(s):
    digits = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
    return digits[s]

# map将'14789'转成了分开的int类型的集合，reduce将分开的int集合合成可14789
print(reduce(fn,map(char2num,'14789'))) 

整合成一个函数就是：

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}

def str2Int(s):
    def fn(x,y):
        return x*10 + y
    def char2Num(s):
        return DIGITS[s]
    return reduce(fn,map(char2Num,s))

print(str2Int('14789'))

filter

和map()类似，filter()也接收一个函数和一个序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。比如下面，我要删除集合中的偶数：

def dell(n):
    return n % 2 == 1

# filter()函数返回的是一个Iterator，也就是一个惰性序列，所以要强迫filter()完成计算结果，需要用list()函数获得所有结果并返回list。
print(list(filter(dell, [1, 2, 3, 4, 5, 6, 7, 8, 9])))

以下是利用Python的filter函数实现筛选素数的埃氏筛法：

# 构建一个只会生成奇数的生成器,构成的是无限序列
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) # 筛选序列的素数，然后构造新序列

# 打印筛选出来的素数
for n in primes():
    if n<100:
        print(n)
    else:
        break

sorted

说白了，就是给集合进行排序的算法，看看以下几个示例：

# 将集合按照绝对值排序
print(sorted([-1, 5, -3, 8, -37, -20, 10], key=abs))
# 默认情况下，字符串排序是按照首字母的ASCII的大小排序，小的在前，大的在后
print(sorted(['hello', 'Case', 'about', 'Like']))
# 可以忽略首字母大小写来排序
print(sorted(['hello', 'Case', 'about', 'Like'],key=str.lower))
# 将函数进行反转
print(sorted(['hello', 'Case', 'about', 'Like'], reverse=True))

返回函数

高阶函数除了可以接受函数作为参数外，还可以把函数作为结果值返回，具体看示例：

# 定一个函数，里面有一个求和函数，并且将求和函数作为参数返回
def add(*agr):
    def sum():
        s = 0
        for n in agr:
            s = n + s
        return s
    return sum

# 调用add函数，返回的是里面求和函数，而不是求和结果
su = add(1,2,3,4,5,6)
# 这样才是返回求和结果
print(su())

闭包

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

def count():
    fs = []
    for i in range(1, 4):
        def f():
            return i * i

        fs.append(f)
    return fs

f1, f2, f3 = count()

print(f1(), f2(), f3())

9 9 9

为啥结果和预料不一样？应该是1，4，9才对，原因就在于返回的函数引用了变量i，但它并非立刻执行。等到3个函数都返回时，它们所引用的变量i已经变成了3，因此最终结果为9。

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

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

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


f1, f2, f3 = count()

print(f1(), f2(), f3())

lambda(匿名函数)

当我们在传入函数时，有些时候，不需要显式地定义函数，直接传入匿名函数更方便。关键字lambda表示匿名函数，冒号前面的x表示函数参数。匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。

# 定义可一个函数f
def f(x):
    return x * x


# 传入了一个匿名函数,这个匿名函数等同于上面的f函数
print(list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9])))

# 同样匿名函数也是一个函数对象，可以赋值
f = lambda x: x * x
print(f(15))


# 当然，也可以作为函数返回值
def build(x, y):
    return lambda: x * y

装饰器

这个就好比装饰设计模式，不改变原来函数，但是给函数添加新的功能，而这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。
比如我们定义一个简单的打印hello的函数：

def print_hello():
    print('hello')
    return

然后我们需要在不改变函数的代码情况下，加上打印本函数名称的方法，下面演示装饰器的用法：

# 定义一个装饰器decorator,本质上，decorator就是一个返回函数的高阶函数。所以，我们要定义一个能打印日志的decorator，可以定义如下
def log(func):
    def wrapper(*args, **kw):
        # func.__name__ 中__name__ 是函数对象的一个属性，表示函数名字
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper

# 我们要借助Python的@语法，把decorator置于函数的定义处，
# 把@log()函数print_hello()的定义处，相当于执行了语句 print_hello = log(print_hello)
@log
def print_hello():
    print('hello')
    return

print_hello()

# 结果
call print_hello():
hello

由于log()是一个decorator，返回一个函数，所以，原来的print_hello()函数仍然存在，只是现在同名的print_hello变量指向了新的函数，于是调用print_hello()将执行新函数，即在log()函数中返回的wrapper()函数。wrapper()函数的参数定义是(*args, **kw)，因此，wrapper()函数可以接受任意参数的调用。在wrapper()函数内，首先打印日志，再紧接着调用原始函数。

如果decorator本身需要传入参数，那就需要编写一个返回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('执行了')
def print_hello():
    print('hello')
    return

# 其实就是执行了  print_hello = log('execute')(print_hello)
print_hello()

# 结果
执行了 print_hello():
hello

首先执行log('execute')，返回的是decorator函数，再调用返回的函数，参数是print_hello函数，返回值最终是wrapper函数。以上两种decorator的定义都没有问题，但还差最后一步。因为我们讲了函数也是对象，它有name等属性，但你去看经过decorator装饰之后的函数，它们的name已经从原来的'print_hello'变成了'wrapper'。因为返回的那个wrapper()函数名字就是'wrapper'，所以，需要把原始函数的name等属性复制到wrapper()函数中，否则，有些依赖函数签名的代码执行就会出错。

如果你要解决这个问题，不需要编写wrapper.name = func.name这样的代码，Python内置的functools.wraps就是干这个事的：

import functools

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

偏函数

偏函数的作用就是和我们讲到，通过设定参数的默认值，可以降低函数调用的难度这一点作用差不多。比如如下函数，第二个参数默认是10：

int('12345', base=8)

我们可以改变默认参数来达到效果，但是如果我们要经常调用int('12345', base=2)，这样感觉很麻烦，这个时候我们可以使用偏函数达到效果：

import functools

# functools.partial的作用就是，把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单。
int2 = functools.partial(int, base=2)

print(int2('1010101'))
# 新的int2函数，仅仅是把base参数重新设定默认值为2，但也可以在函数调用时传入其他值
print(int2('1000000', base=10))

实际上可以接收函数对象、args和kw这3个参数。其实上面的操作，等同于改变*kw的操作。