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

1 高阶函数

2 返回函数

3 匿名函数

4 装饰器

5 偏函数

1 高阶函数

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

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

拓展：

• abs(-10)是函数调用，而abs是函数本身
• 变量可以指向函数（函数本身也可以赋值给变量），直接调用abs()函数和调用变量f()完全相同

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

1.1 map/reduce

1，map()函数
（1）map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。
（2）举例：将函数f(x)=x2作用在一个list [1, 2, 3, 4, 5, 6, 7, 8, 9]上，就可以用map()实现

image.png

>>> 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]

map()传入的第一个参数是f，即函数对象本身，结果r是一个Iterator。

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

（3）查看Iterator生成的结果：Iterator是惰性序列，因此通过list()函数让它把整个序列都计算出来并返回一个list。
2，reduce()函数
（1）reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算

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

（2）例子：序列求和（同sum()）

>>> from functools import reduce
>>> def add(x, y):
...     return x + y
...
>>> reduce(add, [1, 3, 5, 7, 9])
25

3，实例：构建一个函数，可以实现把str转换为int

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 chr2num(s):
    return DIGITS[s]

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

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

# -*- coding: utf-8 -*-
def normalize(name):
    return name.title()

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

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

# -*- coding: utf-8 -*-
from functool import reduce
def prod(L):
    def f(x1, x2):
        return x1*x2
    return reduce(f,L)

#测试
print('3 * 5 * 7 * 9 =', prod([3, 5, 7, 9]))
if prod([3, 5, 7, 9]) == 945:
    print('测试成功!')
else:
    print('测试失败!')

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

# -*- coding: utf-8 -*-
from functool import reduce
def str2float(s):
    return float(s)

#或者
def str2float(s):
    return reduce(lambda x, y: x + y * pow(10, -3), map(int, s.split('.')))

1.2 filter

1，filter()
filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。
filter()函数返回的是一个Iterator，也就是一个惰性序列，所以要强迫filter()完成计算结果，需要用list()函数获得所有结果并返回list。
2，应用：用filter求素数
（1）埃氏筛法

• 首先，列出从2开始的所有自然数，构造一个序列
• 取序列的第一个数2，它一定是素数，然后用2把序列的2的倍数筛掉
• 取新序列的第一个数3，它一定是素数，然后用3把序列的3的倍数筛掉
• 取新序列的第一个数5，然后用5把序列的5的倍数筛掉
• 不断筛下去，就可以得到所有的素数
  （2）用Python来实现

#构造一个从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

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

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

# 测试:
output = filter(is_palindrome, range(1, 1000))
print('1~1000:', list(output))
if list(filter(is_palindrome, range(1, 200))) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55, 66, 77, 88, 99, 101, 111, 121, 131, 141, 151, 161, 171, 181, 191]:
    print('测试成功!')
else:
    print('测试失败!')

1.3 sorted

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

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

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

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

（2）忽略大小写的排序

#默认情况下，对字符串排序，是按照ASCII的大小比较的，由于'Z' < 'a'，结果，大写字母Z会排在小写字母a的前面
>>> sorted(['bob', 'about', 'Zoo', 'Credit'])
['Credit', 'Zoo', 'about', 'bob']

#先把字符串都变成大写（或者都变成小写），再比较，即可实现忽略大小写来比较两个字符串
>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower)
['about', 'bob', 'Credit', 'Zoo']

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

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

3，小结：用sorted()排序的关键在于实现一个映射函数
4，练习
问：请对表示学生名字和成绩的一组tuple

L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]

（1）用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)

（2）再按成绩从高到低排序：

# -*- coding: utf-8 -*-
L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
def by_score(t):
    return -t[1]
L2 = sorted(L, key=by_score)
print(L2)