Python函数式编程（一）高级函数（mr,filter,sorted）

概念：

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

高阶函数

把函数作为参数传入，这样的函数称为高阶函数，函数式编程就是指这种高度抽象的编程范式。
编写高阶函数，就是让函数的参数能够接收别的函数。

变量可以指向函数

abs(-10) //函数调用
10

abs //函数本身

x = abs(-10) //获得函数调用结果，我们可以把结果赋值给变量
x
10

f = abs //函数本身赋值给变量
f

f(-10) //变量可以指向函数，此时变量就是函数
10

函数名可以理解为一个变量，此时abs和f代表的意思相同

abs = -10
abs(-10)
Traceback (most recent call last):
File “”, line 1, in
TypeError: ‘int’ object is not callable

abs
-10
函数名abs为变量，此时将-10给abs，abs就是-10

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

传入函数

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

def add(x, y, f):
    return f(x) + f(y)
#等价于
x = -5
y = 6
f = abs
f(x) + f(y) ==> abs(-5) + abs(6) ==> 11
return 11

Map/Reduce

map()

入参：函数 和Iterable，将传入函数依次作用于序列中每个元素，并作为新的Iterable返回

>>> 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，Iterator是惰性序列，因此通过list()函数让它把整个序列都计算出来并返回一个list。
或者

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

将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)

1. 序列求和

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

也可以sum（）函数

2. 序列[1, 3, 5, 7, 9]变换成整数13579

>>> from functools import reduce
>>> def fn(x, y):
...     return x * 10 + y
...
>>> reduce(fn, [1, 3, 5, 7, 9])
13579

3. 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]
...
>>> reduce(fn, map(char2num, '13579'))
13579

整理

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

使用lambda表达式

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

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

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

def normalize(name):
    return name.title()
L1 = ['adam', 'LISA', 'barT']
L2 = list(map(normalize, L1))
print(L2)

4. 求积函数

def prod(L):
    def multi(x,y):
        return x*y
    return reduce(multi,L)

5. 字符串转浮点

#利用map和reduce编写一个str2float函数，把字符串'123.456'转换成浮点数123.456
from functools import reduce
def str2float(s):
    DIGIT = {'0':0, '1':1, '2':2, '3':3, '4':4, '5':5, '6':6, '7':7, '8':8, '9':9}
    def f(x, y):
        return x*10 + y
    ss = s.split('.') # 分离整数和小数
    zheng_shu = reduce(f, map(lambda x: DIGIT[x], ss[0]))
    xiao_shu = reduce(f, map(lambda x: DIGIT[x], ss[-1]))
    return zheng_shu + xiao_shu/pow(10, len(ss[-1]))

filter

filter用于过滤序列：参数和map类似，若返回为1则保留元素

1. 保留奇数

def is_ji(x):
… return x%2==1
…

list(filter(is_ji,[1,2,3,4,5]))
[1, 3, 5]

2. 删掉序列中的空串

def not_empty(s):
    return s and s.strip()

list(filter(not_empty, ['A', '', 'B', None, 'C', '  ']))
# 结果: ['A', 'B', 'C']

filter()函数返回的是一个Iterator，也就是一个惰性序列，所以要强迫filter()完成计算结果，需要用list()函数获得所有结果并返回list。

用filter（）求素数

计算素数的一个方法是埃氏筛法，它的算法理解起来非常简单：

首先，列出从2开始的所有自然数，构造一个序列：

2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, …

取序列的第一个数2，它一定是素数，然后用2把序列的2的倍数筛掉：

3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, …

取新序列的第一个数3，它一定是素数，然后用3把序列的3的倍数筛掉：

5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, …

取新序列的第一个数5，然后用5把序列的5的倍数筛掉：

7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, …

不断筛下去，就可以得到所有的素数。

用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) # 构造新序列

这个生成器先返回第一个素数2，然后，利用filter()不断产生筛选后的新的序列。

由于primes()也是一个无限序列，所以调用时需要设置一个退出循环的条件：

打印1000以内的素数:

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

注意到Iterator是惰性计算的序列，所以我们可以用Python表示“全体自然数”，“全体素数”这样的序列，而代码非常简洁。

从左读和从右读都一样的数

def is_palindrome(n):

    n=str(n)

    return n==n[::-1]  # n[::-1]将list中的倒序
# 测试:
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('测试失败!')

sorted（）

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

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

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

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

字符串排序的例子

1. 按照ascii码大小进行排序

sorted([‘bob’, ‘about’, ‘Zoo’, ‘Credit’])
[‘Credit’, ‘Zoo’, ‘about’, ‘bob’]

2. 忽略大小写排序

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

4. dict排序

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

L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
def by_name(t):
    return(t[0])
def by_score(t):
    return(t[-1])#按照从低到高
    return -t[1]#按照从高到低


L2 = sorted(L, key=by_score)
print(L2)

注意：sorted()也是一个高阶函数。用sorted()排序的关键在于实现一个映射函数。