Python——高阶函数

一. 函数的本质

函数本身也可以赋值给变量,即:变量可以指向函数，函数名其实就是指向函数的变量

>>> abs( -10 )
10
>>>
>>> abs( -10 )                  # 调用求绝对值函数
10
>>>
>>>
>>> abs                         # abs(-10)是函数调用，而abs是函数本身
<built-in function abs>
>>>
>>>
>>> f = abs                     #函数本身也可以赋值给变量，即：变量可以指向函数。
>>> f
<built-in function abs>
>>>
>>>
>>> f(-10)                      # 变量f现在已经指向了abs函数本身
10
>>>
>>> abs = 10
>>>
>>>
>>> abs(-10)                    #函数名也是变量
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not callable

 

二. 高阶函数

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

 

>>> def add(x,y,f):
...     "定义高阶函数"
...     return f(x) + f(y)
...
>>>
>>> add( -4, 4,abs)     # 调用高阶函数
8
>>>

 

三. 内置高阶函数

 

1. map()

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

>>> def f(x):
...     return x*x
...
>>>
>>> li = [1,2,3,4,5]
>>>
>>> r = map(f, li)
>>> list(r)
[1, 4, 9, 16, 25]

map()传入的第一个参数是f，即函数对象本身。由于结果r是一个Iterator，Iterator是惰性序列，因此通过list()函数让它把整个序列都计算出来并返回一个list。

 

2. reduce()

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

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

【例】用 reduce 实现对一个序列求和：

>>> from functools import reduce
>>>
>>>
>>> def add(x,y):
...     return x+y
...
>>>
>>> reduce(add,range(0,6))
15
>>>
>>> sum(range(0,6))
15

【例】用  reduce 实现序列  [1, 3, 5, 7, 9] 变换成整数 13579

>>> from functools import reduce
>>> def fn(x,y):
...     return x*10 + y
...
>>> li = [1, 2, 3, 4, 5]
>>>
>>> reduce(fn, li)
12345
>>> type(reduce(fn, li))
<class 'int'>

【例】把 str 转换为 int 

>>> def fn(x,y):
...     return x*10 + y
...
>>>
>>> def char_num(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(char_num, '13579'))
13579

 

3. filter()

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

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

【例】在一个list中，删掉偶数，只保留奇数。

>>> def is_odd(n):
...     return  n %2 ==1
...
>>>
>>> list(filter(is_odd,[1, 2, 4, 5, 6, 9, 10, 15]))
[1, 5, 9, 15]

【例】删除序列中的空字符串

>>> def not_empty(s):
...     return s
...
>>>
>>> list(filter(not_empty, ['A', '', 'B', None, 'C', '  ']))
['A', 'B', 'C', '  ']

有结果可看出，只能删除一个空格符的空字符串。做如下改进：

>>> def not_empty(s):
...     return s and s.strip()
...
>>>
>>>
>>> list(filter(not_empty, ['A', '', 'B', None, 'C', '  ']))
['A', 'B', 'C']

 

【例】用 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, ...

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

# 可以先构造一个从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) # 构造新序列
        
# 由于primes()也是一个无限序列，所以调用时需要设置一个退出循环的条件

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

 

4. sorted()

如果是数字，我们可以直接比较，但如果是字符串或者两个dict呢？直接比较数学上的大小是没有意义的，因此，比较的过程必须通过函数抽象出来。

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]

sorted  也可以对字符串排序的例子：

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

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

现在，我们提出排序应该忽略大小写，按照字母序排序。要实现这个算法，不必对现有代码大加改动，只要我们能用一个key函数把字符串映射为忽略大小写排序即可。忽略大小写来比较两个字符串，实际上就是先把字符串都变成大写（或者都变成小写），再比较。

这样，我们给sorted传入key函数，即可实现忽略大小写的排序：

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

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

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

 

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