python高阶函数

        高阶函数引文叫Higher-order function。高阶函数就是把函数当成参数传递的一种函数。

  1. 变量可以指向函数

        以python内置的求绝对值的函数abs()为例，调用该函数

1
2
abs(-10)
10

        如果只写abs

1
2
abs
<built-in function abs>

        可见，abs(-10)是函数调用，而abs是函数本身。

        要获得函数调用结果，可以把结果赋值给变量

1
2
3
x = abs(-10)
x
10

        函数本身也可以复制给变量，即：变量可以指向函数。

1
2
3
f = abs
f
<built-in function abs>

        如果一个变量指向了一个函数，那么，可以通过该变量来调用这个函数

1
2
3
f = abs
f(-10)
10

        变量f已经指向了abs函数本身

  1. 函数名也是变量

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

        如果把abs指向其他对象

1
2
3
4
5
>>> abs = 10
>>> abs(-10)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not callable

        把abs指向10后，就无法通过abs(-10)调用该函数了！因为abs这个变量已经不指向求绝对值函数了！

        当然实际代码绝对不能这么些，这里是为了说明函数名也是变量。要恢复abs函数，需要重启python交互环境。

        注意：由于abs函数实际上是定义在_builtin_模块中的，所以要让修改abs变量的指向在其它模块也生效，要用_builtin_.abs = 10。

  1. 传入函数

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

        一个简单的高阶函数

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

        当调用add(-5, 6, abs)时，参数x，y和f分别接收-5，6和abs，根据函数定义，可以推导计算过程为

1
2
3
4
x ==> -5
y ==> 6
f ==> abs
f(x) + f(y) ==>abs(-5) + abs(6) ==> 11

        编写高阶函数，就是让函数的参数能够接收别的函数。

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

map()函数

        python内建了map()函数。

        map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数一次作用到序列的每个元素，并把结果作为新的list返回。

1
2
3
4
>>> 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()函数，写一个循环，也可以计算出结果

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

        但是，从上面循环代码，不能一下看明白“把f(x)作用在list的每一个元素并把结果生成一个新的list”。

        所以，map()作为高阶函数，事实上它把运算规则抽象了，因此，不但可以计算简单的 

1
f(x)=x^2

        还可以计算任意复杂的函数

        例：把这个list所有数字转为字符串

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

        只需要一行代码。

reduce()函数

        python也内建了reduce()函数。

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

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

        对一个序列求和，就可以用reduce实现

1
2
3
4
>>> 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就可以派上用场了

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

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

1
2
3
4
5
6
7
8
>>> def fn(x, y):
...     return x * 10 + y
...
>>> def char2num(s):
...     return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
...
>>> reduce(fn, map(char2num, '13579'))
13579

        整理成一个str2int的函数就是

1
2
3
4
5
6
def str2int(s):
    def fn(x, y):
        return x * 10 + y
    def char2num(s):
        return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
    return reduce(fn, map(char2num, s))

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

filter()函数

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

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

        例：在一个list中，删掉偶数，只保留奇数

1
2
3
4
5
def is_odd(n):
    return n % 2 == 1
filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15])
# 结果: [1, 5, 9, 15]

        把一个序列中的空字符串删掉

1
2
3
4
5
def not_empty(s):
    return s and s.strip()
filter(not_empty, ['A', '', 'B', None, 'C', '  '])
# 结果: ['A', 'B', 'C']

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

sorted()函数

        排序也是在程序中经常用到的算法。无论使用冒泡排序还是快速排序，排序的核心是比较两个元素的大小。如果是数字，可以直接比较，但如果是字符串或者两个dict，直接比较数学上的大小就没有意义了，因此，比较的过程必须通过函数抽象出来。通常规定，对于两个元素x和y，如果认为x < y，则返回-1，如果认为x == y，则返回0，如果认为x > y，则返回1，这样，排序算法就不用关心具体的比较过程，而是根据比较结果直接排序。

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

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

        此外，sorted()函数也是一个高阶函数，它还可以接收一个比较函数来实现自定义的排序。比如倒序排序，就可以自定义一个reversed_cmp函数

1
2
3
4
5
6
7
def reversed_cmp(x, y):
    if x > y:
        return -1
    if x < y:
        return 1
    return 0
传入自定义的比较函

        传入自定义的比较函数reversed_cmp，就可以实现倒序排序

1
2
>>> sorted([36, 5, 12, 9, 21], reversed_cmp)
[36, 21, 12, 9, 5]

        再看一个字符串排序

1
2
>>> sorted(['bob', 'about', 'Zoo', 'Credit'])
['Credit', 'Zoo', 'about', 'bob']

        默认情况下，对字符串排序，是按照ASCII的大小比较的，由于'z' < 'a'，结果，大写字母Z会排在小写字母a的前面。

        现在提出排序应该忽略大小写，按照字母序排序。要实现这个算法，不必对现有代码大加改动，只要能定义出忽略大小写的比较算法就可以

1
2
3
4
5
6
7
8
def cmp_ignore_case(s1, s2):
    u1 = s1.upper()
    u2 = s2.upper()
    if u1 < u2:
        return -1
    if u1 > u2:
        return 1
    return 0

        忽略大小写来比较两个字符串，实际上就是把字符串都变成大写或者都变成小写，再比较

        这样给sorted传入比较函数，即可实现忽略大小写的排序

1
2
>>> sorted(['bob', 'about', 'Zoo', 'Credit'], cmp_ignore_case)
['about', 'bob', 'Credit', 'Zoo']

        高阶函数的抽象能力是非常强大的，而且，核心代码可以保持得非常简洁。