python高阶函数，map，filter，reduce，ord，以及lambda表达式

为什么我突然扯出这么几个函数，是因为我今天在看流畅的python这本书的时候，里面有一部分内容看的有点懵逼。

>>> symbols = '$¢£¥€¤'

>>> beyond_ascii = [ord(s) for s in symbols if ord(s) > 127]

>>> beyond_ascii

[162, 163, 165, 8364, 164]

>>> beyond_ascii = list(filter(lambda c: c > 127, map(ord, symbols)))

>>> beyond_ascii

[162, 163, 165, 8364, 164]

下面根据这里面的所有的函数展开整理一下

1.ord是将字符转换为10进制的数

2.而map是将列表内元素当做某个函数的参数得到的结果组成的新列表

3.filter是将一个列表按照一定的规则过滤生成的列表

1.lambda表达式

ambda表达式，通常是在需要一个函数，但是又不想费神去命名一个函数的场合下使用，也就是指匿名函数。

示例：

add = lambda x, y : x+y

add(,)  # 结果为3

1.1应用在函数式编程中

Python提供了很多函数式编程的特性，如：map、reduce、filter、sorted等这些函数都支持函数作为参数，lambda函数就可以应用在函数式编程中。如下：

# 需求：将列表中的元素按照绝对值大小进行升序排列

list1 = [3,5,-4,-1,0,-2,-6]

sorted(list1, key=lambda x: abs(x))

当然，也可以如下：

list1 = [3,5,-4,-1,0,-2,-6]

def get_abs(x):

    return abs(x)

sorted(list1,key=get_abs)

只不过这种方式的代码看起来不够Pythonic

1.2应用在闭包中

def get_y(a,b):

     return lambda x:ax+b

y1 = get_y(1,1)

y1(1) # 结果为2

当然，也可以用常规函数实现闭包，如下：

def get_y(a,b):

    def func(x):

        return ax+b

    return func

y1 = get_y(1,1)

y1(1) # 结果为2

只不过这种方式显得有点啰嗦。

那么是不是任何情况下lambda函数都要比常规函数更清晰明了呢？

肯定不是。

Python之禅中有这么一句话：Explicit is better than implicit（明了胜于晦涩），就是说那种方式更清晰就用哪一种方式，不要盲目的都使用lambda表达式。

2.Map函数

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

现在，我们用Python代码实现：

>>> def f(x):

...     return x * x

...

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

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

map()传入的第一个参数是f，即函数对象本身。
你可能会想，不需要map()函数，写一个循环，也可以计算出结果：

L = []

for n in [1, 2, 3, 4, 5, 6, 7, 8, 9]:

    L.append(f(n))print L

的确可以，但是，从上面的循环代码，能一眼看明白“把f(x)作用在list的每一个元素并把结果生成一个新的list”吗？
所以，map()作为高阶函数，事实上它把运算规则抽象了，因此，我们不但可以计算简单的f(x)=x2，还可以计算任意复杂的函数，比如，把这个list所有数字转为字符串：

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

['', '', '', '', '', '', '', '', '']

只需要一行代码。

3.Reduce函数

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

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

比方说对一个序列求和，就可以用reduce实现：

>>> def add(x, y):

...     return x + y

...

>>> reduce(add, [1, 3, 5, 7, 9])

25

当然求和运算可以直接用Python内建函数sum()，没必要动用reduce。
但是如果要把序列[1, 3, 5, 7, 9]变换成整数13579，reduce就可以派上用场：

>>> def fn(x, y):

...     return x * 10 + y

...

>>> reduce(fn, [1, 3, 5, 7, 9])

13579

这个例子本身没多大用处，但是，如果考虑到字符串str也是一个序列，对上面的例子稍加改动，配合map()，我们就可以写出把str转换为int的函数：

>>> def fn(x, y):

...     return x * 10 + y

...

>>> def char2num(s):

...     return {'': 0, '': 1, '': 2, '': 3, '': 4, '': 5, '': 6, '': 7, '': 8, '': 9}[s]

...

>>> reduce(fn, map(char2num, ''))

13579

整理成一个str2int的函数就是：

def str2int(s):

    def fn(x, y):

        return x * 10 + y

    def char2num(s):

        return {'': 0, '': 1, '': 2, '': 3, '': 4, '': 5, '': 6, '': 7, '': 8, '': 9}[s]

    return reduce(fn, map(char2num, s))

还可以用lambda函数进一步简化成：

def char2num(s):

    return {'': 0, '': 1, '': 2, '': 3, '': 4, '': 5, '': 6, '': 7, '': 8, '': 9}[s]

def str2int(s):

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

也就是说，假设Python没有提供int()函数，你完全可以自己写一个把字符串转化为整数的函数，而且只需要几行代码！

4.Filter函数

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

和map()类似，filter()也接收一个函数和一个序列。和map()不同的时，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。

True保留，False丢弃
例如，在一个list中，删掉偶数，只保留奇数，可以这么写：

def is_odd(n):

    return n % 2 == 1

filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15])

# 结果: [1, 5, 9, 15]

把一个序列中的空字符串删掉，可以这么写：

def not_empty(s):

    return s and s.strip()

filter(not_empty, ['A', '', 'B', None, 'C', '  '])

# 结果: ['A', 'B', 'C']

可见用filter()这个高阶函数，关键在于正确实现一个“筛选”函数。

5.ord函数

ord() 函数是 chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常。

描述

语法

以下是 ord() 方法的语法:

ord(c)

参数

c -- 字符。

返回值

返回值是对应的十进制整数

实例

以下展示了使用 ord() 方法的实例：

>>>ord('a')

97

>>> ord('b')

98

>>> ord('c')

99