python迭代和解析(3):range、map、zip、filter和reduce函数
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 "<stdin>", line 1, in <module> 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 <map object at 0x000001afdc2c57b8> >>> list(m) [2, 4, 6, 8, 10]
再比如将字符串中的字符全都转换成大写,这次直接将map的结构全部收集到一个列表中:
>>> list( map(str.upper,"abcd") ) ['a', 'b', 'c', 'd']
对于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 <map object at 0x000001afdc2c5748> >>> next(m) 'a' >>> next(m) 'b' >>> next(m) 'c' >>> next(m) 'd' >>> next(m) traceback (most recent call last): file "<stdin>", line 1, in <module> 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) <zip object at 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
上一篇: Python语言程序设计之一--for循环中累加变量是否要清零
下一篇: dbutils工具类使用
推荐阅读
-
python入门语法(函数参数、迭代器、生成器、装饰器、函数式变成、map/reduce、filter、sorted、继承和多态)
-
python迭代和解析(3):range、map、zip、filter和reduce函数
-
Python中map,reduce,filter和sorted函数的使用方法
-
python入门语法(函数参数、迭代器、生成器、装饰器、函数式变成、map/reduce、filter、sorted、继承和多态)
-
python迭代和解析(3):range、map、zip、filter和reduce函数
-
Python中map,reduce,filter和sorted函数的使用方法
-
python 内置函数-range()+zip()+sorted()+map()+reduce()+filter()