0
点赞
收藏
分享

微信扫一扫

python知识点-高阶函数map、reduce和filter(3)


1、只要是可迭代对象,无论有无下标,都可以迭代,比如dict就可以迭代:

>>> d = {'a': 1, 'b': 2, 'c': 3}
>>> for key in d:
... print

因为dict的存储不是按照list的方式顺序排列,所以,迭代出的结果顺序很可能不一样。

默认情况下,dict迭代的是key。如果要迭代value,可以用​​for value in d.itervalues()​​,如果要同时迭代 key 和 value,可以用​​for k, v in d.iteritems()​​。


由于字符串也是可迭代对象,因此,也可以作用于​​for​​循环:

>>> for ch in 'ABC':
... print

2、for循环后面还可以加上if判断,这样我们就可以筛选出仅偶数的平方(注意:if条件是x的筛选条件,而不是x*x的筛选条件。)

>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]

列表生成式也可以使用两个变量来生成list:

>>> d = {'x': 'A', 'y': 'B', 'z': 'C' }
>>> [k + '=' + v for k, v in d.iteritems()]
['y=B', 'x=A', 'z=C']


3、函数名也是变量

以Python内置的求绝对值的函数​​abs()​​为例,调用该函数用以下代码:

>>> abs(-10)
10

但是,如果只写​​abs​​呢?

>>> abs
<built-in function abs>

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

要获得函数调用结果,我们可以把结果赋值给变量:

>>> x = abs(-10)
>>> x
10

但是,如果把函数本身赋值给变量呢?

>>> f = abs
>>> f
<built-in function abs>

结论:函数本身也可以赋值给变量,即:变量可以指向函数。

如果一个变量指向了一个函数,那么,可否通过该变量来调用这个函数?用代码验证一下:

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

成功!说明变量​​f​​现在已经指向了​​abs​​函数本身。


4、高阶函数

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

一个最简单的高阶函数:

def add(x, y, f):
return

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

x ==> -5
y ==> 6
f ==> abs
f(x) + f(y) ==> abs(-5) + abs(6) ==> 11

用代码验证一下:

>>> add(-5, 6, abs)
11

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

5、Python内建了​​map()​​和​​reduce()​​函数。高阶函数

现在,我们用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

的确可以,但是,从上面的循环代码,能一眼看明白“把f(x)作用在list的每一个元素并把结果生成一个新的list”吗?

所以,​map()作为高阶函数,事实上它把运算规则抽象了​,因此,我们不但可以计算简单的f(x)=x2,还可以计算任意复杂的函数,比如,把这个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)

比方说对一个序列求和,就可以用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': 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​​的函数就是:

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

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

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]

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

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

lambda函数的用法在后面介绍。


​map()​

类似, ​​filter()​

也接收一个函数和一个序列。和 ​​map()​

不同的时, ​filter()把传入的函数依次作用于每个元素,然后根据返回值是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()​​这个高阶函数,关键在于正确实现一个“筛选”函数。

排序算法

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

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

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

def reversed_cmp(x, y):
if x > y:
return -1
if x < y:
return 1
return 0

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

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

我们再看一个字符串排序的例子:

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

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

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

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​​传入上述比较函数,即可实现忽略大小写的排序:

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

从上述例子可以看出,高阶函数的抽象能力是非常强大的,而且,核心代码可以保持得非常简洁。


举报

相关推荐

0 条评论