python map zip_python迭代和解析(3)：range、map、zip、filter和reduce函数

python迭代和解析(3)：range、map、zip、filter和reduce函数

发布时间：2019-01-12 19:36,

浏览次数：392

, 标签：

python

range

map

zip

filter

reduce

解析、迭代和生成系列文章：https://www.cnblogs.com/f-ck-need-u/p/9832640.html

range

range()是一个内置函数，它返回一个数字序列，功能和Linux下的seq命令差不多。

>>> list(range(10)) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> list(range(5,10)) [5,

6, 7, 8, 9] >>> list(range(1,10,2)) [1, 3, 5, 7, 9]

range()返回的是一个可迭代对象(迭代器)，可以被迭代工具for/in/map/zip等操作。

>>> 1 in range(10) True >>> for i in range(10):print(i,end=" ") ... 0 1 2 3 4

5 6 7 8 9 >>> R = range(4) >>> I = iter(R) >>> next(I) 0 >>> I.__next__() 1 >>>

next(I) 2 >>> next(I) 3 >>> next(I) Traceback (most recent call last): File

"", line 1, in StopIteration

作为一个可迭代对象，它还支持len()操作和索引操作：

>>> R = range(5) >>> len(R) 5 >>> R[2] 2

如果想要实现其它功能，可以将其转换为list/tuple/set，然后使用这些类型的功能。

总归要记住，迭代器是惰性的，不会一次性生成所有数据，而是按需一个一个收集起来的。

正如上面的range()，它不会一次性将所有数字序列都生成出来再返回，而是生成一个返回一个，需要的时候再生成一个返回一个，这能够节约内存空间。

map

map无论在Perl还是在Python中都是非常强大的工具，Python中map的作用是对给定列表/元组/集合中的每个元素都应用一个函数操作。

比如，对一系列的数值全都乘2：

>>> def time2(x):return 2*x >>> M = map(time2, [1,2,3,4,5]) >>> M

at 0x000001AFDC2C57B8> >>> list(M) [2, 4, 6, 8, 10]

再比如将字符串中的字符全都转换成大写，这次直接将map的结构全部收集到一个列表中：

>>> list( map(str.upper,"abcd") ) ['A', 'B', 'C', 'D']

map支持多个元素集合，它会每次从这些元素集合中并行取出一个元素作为函数的参数：

>>> list( map(pow, [1,2,3], [2,3,4]) ) [1, 8, 81]

第一次取出1和2作为pow的参数，所以计算的是pow(1,2)得到1；第二次取出2和3作为pow的参数，所以计算的是pow(2,3)

得到8，第三次取出的是3和4，所以计算的是pow(3,4)得到81。

对于map，有几个注意点：

* map可以有多个参数，从第二个参数开始是元素集合，这些元素集合可以是任意可迭代对象，比如内置容器类型、range等

* map的第一个参数是想要对每个元素进行操作的函数，可以是已定义的函数，也可以是lambda。它是map的回调函数

* 如果是已定义的函数，则只需传递函数名称

* 如果是lambda，则需要指定正确数量的参数

* map自身返回的就是迭代器，也就是说它自己是自己的迭代器

* map是迭代操作，所以它的工作方式是惰性的，按需一次返回一个数据，而不是收集完所有数据后一次性返回

* 所有map操作都能替换成等价的for循环，但map的效率比for要高的多，基本能和解析操作的效率差不多

因为map返回的是自身的迭代器，所以可以被for/map/zip/in等迭代工具操作，例如手动迭代：

>>> 2 in map(time2,[1,2,3,4,5]) True >>> M = map(str.upper,"abcd") >>> M

object at 0x000001AFDC2C5748> >>> next(M) 'A' >>> next(M) 'B' >>> next(M) 'C'

>>> next(M) 'D' >>> next(M) Traceback (most recent call last): File "",

line 1, in StopIteration

例如，使用lambda作为map的第一个回调函数的参数：

>>> M = map(lambda x: x * 2, [2,3,4,5]) >>> list(M) [4, 6, 8, 10]

由于map操作的是迭代器中的每个元素，所以map一般都可以写成等价的列表解析操作。

>>> [ x * 2 for x in [1,2,3,4,5] ] [2, 4, 6, 8, 10] >>> list( map(lambda x: x

* 2, [1,2,3,4,5]) ) [2, 4, 6, 8, 10]

一般来说，

如果map中使用了lambda，则map效率要稍低于列表解析，如果没有使用lambda，则map效率要稍高于列表解析。虽然它们效率差不多，但是如果可以的话，强烈建议使用列表解析，因为列表解析是python中极简洁、极可读的编码方式

。

zip

zip()函数可以从一个或多个可迭代对象中并行取出元素进行并行的迭代。它也是返回自身的迭代器。

例如：

>>> L1 = ["one","two","three"] >>> L2 = [1,2,3] >>> zip(L1,L2)

0x000001AFDC2D9A08> >>> list(zip(L1,L2)) [('one', 1), ('two', 2), ('three', 3)]

之所以能并行迭代多个可迭代对象，是因为它同时标记多个可迭代对象的迭代位置。如果zip的多个可迭代对象的长度不同，则以最短的长度为标准，因为zip最多只能标记到最短长度的迭代位置。

因为zip返回的是迭代器，所以可以使用迭代工具去操作zip的结果：

>>> L1 = ["one","two","three"] >>> L2 = [1,2,3] >>> ("one",1) in zip(L1,L2)

True >>> for (x,y) in zip(L1,L2):print(x,"-->",y) ... one --> 1 two --> 2 three

--> 3

zip常用于构建dict，因为它并行从多个迭代对象中取数据：

>>> L1 = ["one","two","three"] >>> L2 = [1,2,3] >>> dict(zip(L1,L2)) {'one':

1, 'two': 2, 'three': 3}

需要注意的是，zip可以从任意可迭代对象中取元素，而集合/字典中的元素顺序是不定的，所以并行取出来的顺序可能不像想象中在位置上那般一一对应。

>>> L1={"one","two","three"} >>> L2=[1,2,3] >>> list(zip(L1,L2)) [('one', 1),

('three', 2), ('two', 3)]

filter

Python中的filter函数类似于Perl中的grep，用于从可迭代对象中筛选出元素被函数操作后为True的元素。

filter(function or None, iterable) --> filter object

例如，筛选出列表中字符串元素长度大于2的字符串：

>>> L = ["a","ab","abc","abcd"] >>> L1 = filter( (lambda x: len(x) > 2), L )

>>> print(list(L1)) ['abc', 'abcd']

上面的工作过程是迭代列表L，每取一个元素都放进函数中操作一番，如果这个元素放进函数中使得函数返回真，则保留这个元素，否则丢弃这个元素。

如果filter的函数部分为None，则表示直接从可迭代对象中取出元素为True的元素：

>>> list(filter(None,["a","ab",0,"","c"])) ['a', 'ab', 'c']

filter的返回结果是一个可迭代对象，可以进行迭代操作：

>>> for i in filter( (lambda x: len(x) > 2), L ): print(i) ... abc abcd

reduce

reduce的功能非常好用，看下面的示例：

>>> import functools >>> functools.reduce(lambda x, y: x+y, [1,2,3,4,5]) 15

它的语法为：

reduce(func, sequence[, initial]) -> value

reduce有两个过程：

* 先从sequence中取两个元素作为func的参数，该函数返回一个结果A。这是初始化的过程

*

将结果A与sequence的下一个元素作为func的参数，继续返回一个结果B，将结果B与下一个元素作为func参数，依次类推，直到迭代完sequence中所有元素

如果给reduce设置了initial参数，则跳过初始化的过程，直接将Initial与sequence的第一个元素作为func的参数。如果没有给定sequence，而给了Initial，则initial作为直接返回的默认值。

例如，从序列中取出最大值：

>>> reduce( lambda x, y: x if x > y else y, [1,2,3,4,5] ) 5 >>> reduce( lambda

x, y: x if x>y else y, [1,2,3,4,5],10 ) 10

<>

多迭代和单迭代

range()和zip()、map()、filter()稍有不同。range()支持多迭代、而后三者只支持单迭代。

何为单迭代、何为多迭代？多迭代的意思是同一个对象上可以有多个互不影响的独立迭代器，各迭代器自己记住自己的迭代位置(状态信息)。单迭代的意思是同一个对象上只能有一个迭代器，即使创建了多个迭代器，它们也是串联起来互相影响的。

下面是range()的多迭代特性：

>>> R = range(3) # 一个range对象R >>> I1 = iter(R) # range对象的一个迭代器 >>> I2 =

iter(R) # range对象的第二个迭代器 >>> next(I1) 0 >>> next(I1) 1 >>> next(I2) # 和I1互不影响 0

>>> next(I2) 1 >>> next(I1) 2

下面的zip、map、filter单迭代的特性：

# zip的单迭代 >>> Z = zip([1,2,3],[10,11,12]) # 自身是迭代器 >>> I1 = iter(Z) #

从自身获取可迭代对象I1 >>> I2 = iter(Z) # 从自身获取可迭代对象I2 >>> next(I1) (1, 10) >>> next(I2)

# I1和I2迭代的是同一个对象：自身 (2, 11) >>> next(I1) (3, 12)

之所以range()支持多迭代，而zip/map/filter都只支持单迭代，是因为：

* zip/map/filter返回的是自身的迭代器，它们的返回结果自身同时都实现了__iter__()和__next__()

两个方法，所以无论从它们的返回结果上产生多少个可迭代对象，操作的都是它们的对象自身，从而只支持单迭代

* range返回的不是自身迭代器，它的返回结果只实现了__iter__而没有实现__next__，所以需要通过iter()

来生成可迭代对象(迭代器)。无论使用iter()从该返回结果产生多少个可迭代对象，都是互相独立的可迭代对象，从而支持多迭代

所以一般来说，不是自身迭代器的对象支持多个迭代器，而自身是自身迭代器的对象只支持单个迭代器。

常见的多迭代有range()和那些支持迭代的内置类型，比如字符串、列表、元组等。例如字符串的多迭代：

>>> S = "abc" >>> for x in S: ... for y in S: ... print(x + y, end=" ") aa ab

ac ba bb bc ca cb cc