Python函数式编程中itertools模块详解

目录
  • 容器与可迭代对象
  • count() 函数
  • cycle 函数
  • repeat 函数
  • enumerate 函数,添加序号
  • accumulate 函数
  • chain 与 groupby 函数
  • zip_longest 与 zip
  • tee 函数
  • compress 函数
  • islice、dropwhile、takewhile、filterfalse、filter
  • 总结

容器与可迭代对象

在正式开始前先补充一些基本概念在 Python 中存在容器 与 可迭代对象

  • 容器:用来存储多个元素的数据结构,例如 列表,元组,字典,集合等内容;
  • 可迭代对象:实现了 __iter__ 方法的对象就叫做可迭代对象。

从可迭代对象中还衍生出 迭代器 与 生成器:

  • 迭代器:既实现了 __iter__,也实现了 __next__ 方法的对象叫做迭代器;
  • 生成器:具有 yield 关键字的函数都是生成器。

这样就比较清楚了,可迭代对象的范围要大于容器。而且可迭代对象只能使用一次,使用完毕再获取值就会提示 StopIteration 异常。

除此之外,可迭代对象还有一些限制:

  • 不能对可迭代对象使用 len 函数;
  • 可以使用 next 方法处理可迭代对象,容器也可以通过 iter 函数转换成迭代器;
  • for 语句会自动调用容器的 iter 函数,所以容器也能被循环迭代。

count() 函数

count 函数一般与 range 函数对比学习,例如 range 函数需要定义生成范围的下限,上限与步长可选,而 count 函数不同,指定下限与步长,上限值不用声明。

函数原型声明如下

count(start=0, step=1) --> count object

测试代码如下,其中必须添加跳出循环的判定条件,否则代码会一直运行下去。

from itertools import count
a = count(5, 10)
for i in a:
    print(i)
    if i > 100:
        break

除此之外,count 函数还接收非整数参数,所以下述代码中定义的也是正确的。

from itertools import count
a = count(0.5, 0.1)
for i in a:
    print(i)
    if i > 100:
        break

cycle 函数

用 cycle 函数可以循环一组值,测试代码如下所示:

from itertools import cycle
x = cycle('梦想橡皮擦abcdf')
for i in range(5):
    print(next(x), end=" ")
print("\n")
print("*" * 100)
for i in range(5):
    print(next(x), end=" ")

代码输出如下内容:

梦 想 橡 皮 擦

****************************************************************************************************
a b c d f

可以看到 cycle 函数与 for 循环非常类似。

repeat 函数

repeat 函数用于重复返回某个值,官方给出的函数描述如下所示:

class repeat(object):
    """
    repeat(object [,times]) -> create an iterator which returns the object
    for the specified number of times.  If not specified, returns the object
    endlessly.

进行一下简单的测试,看一下效果:

from itertools import repeat
x = repeat('橡皮擦')
for i in range(5):
    print(next(x), end=" ")
print("\n")
print("*" * 100)
for i in range(5):
    print(next(x), end=" ")

怎么看这个函数,都好像没有太大用处。

enumerate 函数,添加序号

这个函数在前面的文章中,已经进行过简单介绍,并且该函数在 __builtins__ 包中,所以不再过多说明,基本格式如下所示:

enumerate(sequence, [start=0])

其中 start 参数是下标起始位置。

accumulate 函数

该函数基于给定的函数返回一个可迭代对象,默认是累加效果,即第二个参数为 operator.add,测试代码如下:

from itertools import accumulate
data = [1, 2, 3, 4, 5]
# 计算累积和
print(list(accumulate(data)))  # [1, 3, 6, 10, 15]

针对上述代码,修改为累积。

from itertools import accumulate
import operator
data = [1, 2, 3, 4, 5]
# 计算累积
print(list(accumulate(data, operator.mul)))

除此之外,第二个参数还可以为 max,min 等函数,例如下述代码:

from itertools import accumulate
data = [1, 4, 3, 2, 5]
print(list(accumulate(data, max)))

代码输出如下内容,其实是将 data 里面的任意两个值进行了比较,然后留下最大的值。

[1, 4, 4, 4, 5]

chain 与 groupby 函数

chain 函数用于将多个迭代器组合为单个迭代器,而 groupby 可以将一个迭代器且分为多个子迭代器。

首先展示一下 groupby 函数的应用:

from itertools import groupby
a = list(groupby('橡橡皮皮擦擦'))
print(a)

输出内容如下所示:

[('橡', <itertools._grouper object at 0x0000000001DD9438>),
('皮', <itertools._grouper object at 0x0000000001DD9278>),
('擦', <itertools._grouper object at 0x00000000021FF710>)]

为了使用 groupby 函数,建议先对原列表进行排序,因为它是有点像切片一样,发现不同的就分出一个迭代器。

chain 函数的用法如下,将多个迭代对象进行拼接:

from itertools import groupby, chain
a = list(chain('ABC', 'AAA', range(1,3)))
print(a)

zip_longest 与 zip

zip 函数在之前的博客中已经进行过说明,zip_longest 与 zip 的区别就是,zip 返回的结果以最短的序列为准,而 zip_longest 以最长的为准。

测试代码如下,自行比对结果即可。

from itertools import zip_longest
a = list(zip('ABC', range(5), [10, 20, 30, 40]))
print(a)
a = list(zip_longest('ABC', range(5), [10, 20, 30, 40]))
print(a)

zip_logest 如果碰到长度不一致的序列,缺少部分会填充 None。

tee 函数

tee 函数可以克隆可迭代对象,产出多个生成器,每个生成器都可以产出输入的各个元素。

from itertools import tee
a = list(tee('橡皮擦'))
print(a)

compress 函数

该函数通过**谓词(是否,True/False)**来确定对某个元素的取舍问题,最简单的代码如下所示:

from itertools import compress
a = list(compress('橡皮擦', (0, 1, 1)))
print(a)

islice、dropwhile、takewhile、filterfalse、filter

这几个函数都是从输入的可迭代对象中获取一个子集,而且不修改元素本身。

本部分只罗列各个函数的原型声明,具体用法直接参考使用即可。

islice(iterable, stop) --> islice object
islice(iterable, start, stop[, step]) --> islice object
dropwhile(predicate, iterable) --> dropwhile object
takewhile(predicate, iterable) --> takewhile object
filterfalse(function or None, sequence) --> filterfalse object

其中只有 filterfalse 中的参数是函数在前,序列在后。

测试代码如下,尤其注意第一个参数是 callable 即函数。

from itertools import islice, dropwhile, takewhile, filterfalse
a = list(filterfalse(lambda x: x in ["皮", "擦"], '橡皮擦'))
print(a)

总结

以上内容就是本文的全部内容,在使用无限迭代器函数 count,cycle,repeat 的时候,一定要注意即使停止。

本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注我们的更多内容!

时间: 2021-09-13

Python中itertools的用法详解

iterator 循环器(iterator)是对象的容器,包含有多个对象.通过调用循环器的next()方法 (next()方法,在Python 3.x中),循环器将依次返回一个对象.直到所有的对象遍历穷尽,循环器将举出StopIteration错误. 在for i in iterator结构中,循环器每次返回的对象将赋予给i,直到循环结束.使用iter()内置函数,我们可以将诸如表.字典等容器变为循环器.比如 for i in iter([2, 4, 5, 6]): print i 标准库中的i

Python itertools.product方法代码实例

itertools.product:类似于求多个可迭代对象的笛卡尔积. 使用的形式是: itertools.product(*iterables, repeat=1), product(X, repeat=3)等价于product(X, X, X). 1. 直接使用时:分别生成元组,然后合成一个list import itertools aa = itertools.product(['西藏','瀑布','湖水'], ['月色','星空']) bb = list(aa) #按照顺序生成笛卡尔积,

介绍Python中内置的itertools模块

Python的内建模块itertools提供了非常有用的用于操作迭代对象的函数. 首先,我们看看itertools提供的几个"无限"迭代器: >>> import itertools >>> natuals = itertools.count(1) >>> for n in natuals: ... print n ... 1 2 3 ... 因为count()会创建一个无限的迭代器,所以上述代码会打印出自然数序列,根本停不下来,只

Python itertools模块详解

这货很强大, 必须掌握 文档 链接 http://docs.python.org/2/library/itertools.html pymotw 链接 http://pymotw.com/2/itertools/ 基本是基于文档的翻译和补充,相当于翻译了 itertools用于高效循环的迭代函数集合 组成 总体,整体了解 无限迭代器 复制代码 代码如下: 迭代器         参数         结果                                              

关于Python中 循环器 itertools的介绍

目录 1.无穷循环器 2.函数式工具 3.组合工具 4.groupby() 5.其它工具 在for i in iterator结构中,循环器每次返回的对象将赋予给i,直到循环结束.使用iter()内置函数,我们可以将诸如表.字典等容器变为循环器.比如 for i in iter([2, 4, 5, 6]): print(i) 标准库中的itertools包提供了更加灵活的生成循环器的工具.这些工具的输入大都是已有的循环器.另一方面,这些工具完全可以自行使用Python实现,该包只是提供了一种比较

python中的itertools的使用详解

今天了解了下python中内置模块itertools的使用,熟悉下,看能不能以后少写几个for,嘿嘿

Python 中迭代器与生成器实例详解

Python 中迭代器与生成器实例详解 本文通过针对不同应用场景及其解决方案的方式,总结了Python中迭代器与生成器的一些相关知识,具体如下: 1.手动遍历迭代器 应用场景:想遍历一个可迭代对象中的所有元素,但是不想用for循环 解决方案:使用next()函数,并捕获StopIteration异常 def manual_iter(): with open('/etc/passwd') as f: try: while True: line=next(f) if line is None: br

对python中的高效迭代器函数详解

python中内置的库中有个itertools,可以满足我们在编程中绝大多数需要迭代的场合,当然也可以自己造轮子,但是有现成的好用的轮子不妨也学习一下,看哪个用的顺手~ 首先还是要先import一下: #import itertools from itertools import * #最好使用时用上面那个,不过下面的是为了演示比较 常用的,所以就直接全部导入了 一.无限迭代器: 由于这些都是无限迭代器,因此使用的时候都要设置终止条件,不然会一直运行下去,也就不是我们想要的结果了. 1.coun

基于python中的TCP及UDP(详解)

python中是通过套接字即socket来实现UDP及TCP通信的.有两种套接字面向连接的及无连接的,也就是TCP套接字及UDP套接字. TCP通信模型 创建TCP服务器 伪代码: ss = socket() # 创建服务器套接字 ss.bind() # 套接字与地址绑定 ss.listen() # 监听连接 inf_loop: # 服务器无限循环 cs = ss.accept() # 接受客户端连接 comm_loop: # 通信循环 cs.recv()/cs.send() # 对话(接收/发

python中模块的__all__属性详解

python模块中的__all__属性,可用于模块导入时限制,如: from module import * 此时被导入模块若定义了__all__属性,则只有__all__内指定的属性.方法.类可被导入. 若没定义,则导入模块内的所有公有属性,方法和类 # kk.py class A(): def __init__(self,name,age): self.name=name self.age=age class B(): def __init__(self,name,id): self.nam

Python中%r和%s的详解及区别

Python中%r和%s的详解 %r用rper()方法处理对象 %s用str()方法处理对象 有些情况下,两者处理的结果是一样的,比如说处理int型对象. 例一: print "I am %d years old." % 22 print "I am %s years old." % 22 print "I am %r years old." % 22 返回结果: I am 22 years old. I am 22 years old. I a

Python中的变量和作用域详解

作用域介绍 python中的作用域分4种情况: L:local,局部作用域,即函数中定义的变量: E:enclosing,嵌套的父级函数的局部作用域,即包含此函数的上级函数的局部作用域,但不是全局的: G:globa,全局变量,就是模块级别定义的变量: B:built-in,系统固定模块里面的变量,比如int, bytearray等. 搜索变量的优先级顺序依次是:作用域局部>外层作用域>当前模块中的全局>python内置作用域,也就是LEGB. x = int(2.9) # int bu

python中实现k-means聚类算法详解

算法优缺点: 优点:容易实现 缺点:可能收敛到局部最小值,在大规模数据集上收敛较慢 使用数据类型:数值型数据 算法思想 k-means算法实际上就是通过计算不同样本间的距离来判断他们的相近关系的,相近的就会放到同一个类别中去. 1.首先我们需要选择一个k值,也就是我们希望把数据分成多少类,这里k值的选择对结果的影响很大,Ng的课说的选择方法有两种一种是elbow method,简单的说就是根据聚类的结果和k的函数关系判断k为多少的时候效果最好.另一种则是根据具体的需求确定,比如说进行衬衫尺寸的聚

Python中协程用法代码详解

本文研究的主要是python中协程的相关问题,具体介绍如下. Num01–>协程的定义 协程,又称微线程,纤程.英文名Coroutine. 首先我们得知道协程是啥?协程其实可以认为是比线程更小的执行单元. 为啥说他是一个执行单元,因为他自带CPU上下文.这样只要在合适的时机, 我们可以把一个协程 切换到另一个协程. 只要这个过程中保存或恢复 CPU上下文那么程序还是可以运行的. Num02–>协程和线程的差异 那么这个过程看起来和线程差不多.其实不然, 线程切换从系统层面远不止保存和恢复 CP

Python中函数参数匹配模型详解

当我们的函数接收参数为任意个,或者不能确定参数个数时,我们,可以利用 * 来定义任意数目的参数,这个函数调用时,其所有不匹配的位置参数会被赋值为元组,我们可以在函数利用循环或索引进行使用 def f(*args): # 直接打印元组参数 print(args) print('-'*20) # 循环打印元组参数 [print(i) for i in args] ... # 传递一个参数 f(1) print('='*20) # 传递5个参数 f(1, 2, 3, 4, 5) 示例结果: (1,)