itertools模块详解

作者: 韦德国际1946手机版  发布:2019-05-28

多年来在看流畅的python,在看第二四章节的itertools模块,对其itertools中的相关函数达成的逻辑的兑现

itertools模块包蕴一组函数用于拍卖系列数据集。

介绍

itertools是python内置的模块,提供了诸多个用于操作迭代对象的函数,使用轻易且功效强大。方便以往采用,极其汇总整理。

其中在zip_longest(it_obj1, ..., it_objN, fillvalue=None)时,其函数完结的成效和停放zip函数差不离同样(完结一1对应),

统一和释疑迭代器

  • chain 用于合并七个迭代器, 利用chain能够轻易管理四个类别。
from itertools import chain

for i in chain([1,2,3], ['a', 'b', 'c'])
    print i

结果为:

1
2
3
a
b
c
  • izip 用于将三个迭代器中的元素构成到贰个元组中
from itertools import izip
for i in izip([1,2,3], ['a','b', 'c']):
    print i

结果为:

(1,'a')
(2,'b')
(3,'c')
  • islice 重临二个迭代器,它按索引再次回到由输入迭代器所选的因素。
from itertools import *

print "Stop at 5“
for i in islice(count(), 5):
    print i

print "Start at 5, stop at 10"
for i in islice(count(), 5,10):
    print i

print "By tens to 100"
for i in islice(count(), 0, 100, 10):
    print i

count()用于转移Infiniti一而再整数,前面会讲到。

  • tee 依照二个原输入迭代器重临四个单身的迭代器, 暗许为两个。
from itertools import *
r = islice(count(), 5)
i1, i2 = tee(r)

tee()创设的迭代器共享其输入迭代器,所以若是创制了新迭代器,就不应有再选取远迭代器。

倘诺原迭代器的值已经运用,新迭代器不会再生成那一个值。

运用格局

import itertools

只是内置的zip函数是已成分最少对象为尺度,而zip_longest函数是已成分最多指标为准绳,使用fillvalue的值来填充

改造输入

  • imap 再次来到3个迭代器,它对输入迭代器中的值调用3个函数并回到结果。imap函数的办事格局临近于内置函数map,只可是只要有些输入迭代器中的成分采取完,imap函数就能够告一段落。
from itertools import *

print "Doubles:"
for i in imap(lambda x:2*x, xrange(5)):
    print i

print "Multiples:"
for i in imap(lambda x, y:(x,y, x*y), xrange(5), xrange(5, 10)):
    print '%d * %d = %d' % i

结果如下:

Doubles:
0
2
4
6
8
Multiples:
0 * 5 = 0
1 * 6 = 6
2 * 7 = 14
3 * 8 = 24
4 * 9 = 36
  • starmap starmap类似于imap函数,可是它并不是行使多少个迭代器来创设1个tuple, 而是使用*语法来解说3个迭代器中的成分来作为映射函数的参数。
from itertools import *

values = [[0,5], [1,6], [2,7], [3,8]]

for i in starmap(lambda x, y:(x, y, x*y), values):
    print '%d * %d = %d' % i

输出结果如下:

0 * 5 = 0
1 * 6 = 6
2 * 7 = 14
3 * 8 = 24

imap的函数映射名称叫f(i一, i贰), 而传入starmap()的映射函数名字为f(*i)。

重在措施

  • accumulate(iterable[, func])

接收3个可迭代对象,和1个2元运算函数名 [可选]
接受1个参数,暗中认可对可迭代对象中的成分举行增添运算,重回结果仍为可迭代对象
收下七个参数,可迭代对象中的元素遵照itertools模块详解。2元运算函数打开累计运算

import operator
cc = itertools.accumulate([1, 2, 3])
cs = itertools.accumulate([1, 2, 3], operator.mul)
print(list(cc), list(cs))
>>[1, 3, 6] [1, 2, 6]
  • chain(*iterables)

能够把多少个迭代对象(此地能够是字符串、列表、字典、会集等1切迭代对象)串联起来,造成叁个更加大的迭代器

it_a = ['a', 'b']
it_b = range(3)
merge = itertools.chain(it_a, it_b, 'sss')
print(merge, list(merge))
>>
<itertools.chain object at 0x014573B0> ['a', 'b', 0, 1, 2, 's', 's', 's']
  • combinations(iterabe, r)

将可迭代对象(体系)中的任性r个要素构成2个元组,最终将具有的咬合意况以迭代器再次来到

cm = itertools.combinations('abc', 2)
print(list(cm))
>>[('a', 'b'), ('a', 'c'), ('b', 'c')]
  • combinations_with_replacement(iterable, r)

能够以为是对combinations的强大,它会额外再次来到单个成分重复r次的景况

cm = itertools.combinations_with_replacement('abc', 2)
print(list(cm))
>>[('a', 'a'), ('a', 'b'), ('a', 'c'), ('b', 'b'), ('b', 'c'), ('c', 'c')]
  • compress(data, selectors)

接受七个可迭代对象
透过推断选取器中的元素的bool值,假如为True,则保留数据的照拂成分,不然删除

# 如果是一个由5个空值组成的列表,则空值被视为False
# 注意!!!
# 列表中的第一个元素是空格,并不是什么也没有,特别需要注意
cm = itertools.compress([1, 2, 3, 4, 5], [' ', '', '', '', ''])
print(list(cm))
>>[1]
  • count(start=0, step=1)

创办2个极端迭代器(系列)
暗许创制多个以0初阶,步长为一的自然数种类:0,1,2,3,4...

要留意在程序中设置退出规范,可能ctrl c强制打断

odd = itertools.count(1, 2)
for i in odd:
    if i < 10:
        print(i, end=' ')
    else:
        break
>>1 3 5 7 9 
  • cycle(iterable)

把二个队列无限重复下去

cs = itertools.cycle([1, 2, 3])
i = 0
for c in cs:
    if i != 7:
        print(c, end=' ')
        i  = 1
    else:
        break
>>1 2 3 1 2 3 1 
  • dropwhile(predicate, iterable)

率先个参数(能够是函数)只要能回来迭代对象相月素的bool值就能够
遍历iterable中的元素,若有些元素判别predicate为True,则抛弃该因素,不然结束判别,并以迭代器的方式重回该因素以及背后的持有因素

cm = itertools.dropwhile(lambda x: x.isupper(), 'aAbc')
for c in cm:
    print(c, end='')
>>aAbc
  • filterfalse(function_or_None, sequence)

第一个参数为函数名,也许 None
假若为函数,则保留连串中使得函数为False的成分,并回到迭代器
如果为None,则判定体系中的成分,并重临为False的因素

# 列表中只有0 == False,因此结果必定只有0
cm = itertools.filterfalse(None, [1, 0, 2, 3])
for c in cm:
    print(c)
>>0
  • groupby(iterable, key=None)

从传播的可迭代对象中回到一连的键和组

vehicles = [('Ford', 'Taurus'), ('Dodge', 'Durango'),
            ('Chevrolet', 'Cobalt'), ('Ford', 'F150'),
            ('Dodge', 'Charger'), ('Ford', 'GT')]
sorted_vehicles = sorted(vehicles)
for key, group in itertools.groupby(sorted_vehicles, lambda make: make[0]):
    for make, model in group:
        print('{model} is made by {make}'.format(model=model, make=make))
    print("**** END OF GROUP ***n")
>>
Cobalt is made by Chevrolet
**** END OF GROUP ***

Charger is made by Dodge
Durango is made by Dodge
**** END OF GROUP ***

F150 is made by Ford
GT is made by Ford
Taurus is made by Ford
**** END OF GROUP ***
  • islice(iterable, stop)
    islice(iterable, start, stop[, step])

做事规律完全类似列表的切成条成效,重返的是三个迭代器

s = 'abcdefghijklmnopqrstuvwxyz'
cm = itertools.islice(s, 16)
print(list(cm) == list(s[:16]))
>>True

cm = itertools.islice(s, 16, 18)
print(list(cm) == list(s[16:18]))
>>True

cm = itertools.islice(s, 16, 18, 1)
print(list(cm) == list(s[16:18:1]))
>>True

cm = itertools.islice(s, 16, 18, 3)
print(list(cm) == list(s[16:18:3]))
>>True

cm = itertools.islice(s, 16, None)
print(list(cm) == list(s[16:]))
>>True
  • permutations(iterable, r=None)

以迭代器的款式重回可迭代对象的富有的长短为 r 的排列
私下认可重返全排列

cm = itertools.permutations('abc', 2)
for c in cm:
    print(''.join(c), end=' ')
>>ab ac ba bc ca cb 
  • product(*iterable, repeat=1)

计量五个可迭代对象的笛Carl积

arrays = [(-1, 1), (-3, 3)]
cm = itertools.product(*arrays)
print(list(cm))
>>[(-1, -3), (-1, 3), (1, -3), (1, 3)]
  • repeat(p_object, times=None)

以迭代器的方式按次数重返传入的目的
暗许则等价于Infiniti迭代器

cm = itertools.repeat('a', 3)
print(list(cm))
>>['a', 'a', 'a']

# 不传入times参数值时,为无限迭代,要设置退出循环的条件
cm = itertools.repeat('a')
i = 0
for c in cm:
    if i > 10:
        break
    else:
        print(c, end=' ')
    i  = 1
>>a a a a a a a a a a a 
  • starmap(function, sequence)

队列是由迭代目的(涵盖的要素个数与传播的函数供给的参数一样)构成的

cm = itertools.starmap(lambda x, y: x   y, ['ab', [2, 3], (1, 1)])
print(list(cm))
>>['ab', 5, 2]
  • takewhile(predicate, iterable)

遍历迭代器中的成分,若该因素推断predicate为True,则保留该因素,不然放任该因素及其背后的全部因素,并以迭代器情势重回全部的保留成分

cm = itertools.takewhile(lambda x: x.isupper(), 'BCCCaAbc')
for c in cm:
    print(c, end='')
>>BCCC

# 由于第一个为小写字母,匿名函数判断为False,则放弃所有的元素,cm中没有元素,因此输出为空
cm = itertools.takewhile(lambda x: x.isupper(), 'aBCCCaAbc')
for c in cm:
    print(c, end='')
>>
  • tee(iterable, n=2)

回来n个单身的迭代器,暗许重回五个

data = 'ABCDE'
iter1, iter2 = itertools.tee(data)
for item in iter1:
    print(item, end='')
print()
for item in iter2:
    print(item, end='')
>>ABCDE
ABCDE
  • zip_longest(iter1, iter2=None, *some, **kwargs)

  • zip_longest(*iterable[,fillvalue=None])

重临四个由元组构成的迭代器
总结地说,就是将四个迭代器对应元素重新结合多个元组,直到最长的元组全体配对成就。相当的短的迭代器成分不足,会由传入的命名第2字参数fillvalue进行填空(代替)

cm = itertools.zip_longest([1, 2, 3], 'abc', (1, 2, 3, 4), fillvalue='_')
print(list(cm))
>>[(1, 'a', 1), (2, 'b', 2), (3, 'c', 3), ('_', '_', 4)]

如有错误,招待指正!
最后修改时间:201捌-0一-二三 2二:33:3肆

以下是自身计算此函数的大概完毕格局,和法定方法不相同:

转移新值

  • count 重回多少个迭代器,能够Infiniti的变动再而三整数,第一个数能够看成参数传入,默以为0,这里未有上界参数。
from itertools import *

for i in izip(count(1), ['a', 'b', 'c']):
    print i

输出结果如下:

(1, 'a')
(2, 'b')
(3, 'c')
  • cycle 重回四个迭代器,它会非常的再一次给定参数的内容。由于必须记住输入迭代器的全体内容,由此1旦那些迭代器比较长,大概会比较消耗内部存款和储蓄器。
from itertools import *

for i in izip(xrange(7), cycle(['a', 'b', 'c'])):
    print i

出口结果如下:

(0, 'a')
(1, 'b')
(2, 'c')
(3, 'a')
(4, 'b')
(5, 'c')
(6, 'a')
  • repeat 重返3个迭代器,每一趟访问都会转移一样的值。
from itertools import *

for i in repeat("over and over ", 5):
    print i

输出结果如下:

over and over 
over and over 
over and over 
over and over 
over and over 

repeat重临的迭代器会一贯重返数据,除非提供了可选的times参数来限制次数。

本文由韦德国际1946发布于韦德国际1946手机版,转载请注明出处:itertools模块详解

关键词: python进阶 python 伟德体育在线