python的itertools库受到了来自APL, Haskell和SML的灵感,并且用最适合python语言特性的形式重构。它差不多可以说是定义了一套高效、节省内存的方法使用纯python来构建开发者所需要的各种不同迭代器。

概览

根据itertools中方法的返回类型不同,可以将这些方法分为三类:
无穷迭代∞

迭代器 参数 返回值 示例
count() start,[step] start,start+step,start+2*step,… count(10) –> 10,11,12,13,14,…
cycle() p p0,p1,p2,…,plast,p0,p1,p2…. cycle([1,2,3,4]) –> 1,2,3,4,1,2,3,4,…
repeat() p,[n] p,p,p,…,p 或者重复n次p repeat(10,2) –> 10,10

处理输入迭代器⌨️

迭代器 参数 返回值 示例
chain() p,q,.. p0,p1,..,plast,q0,q1,…,qlast,…. chain(‘abc’,[1,2,3]) –> a b c 1 2 3
compress() data,selectors (d[0] if s[0]),(d[1] if s[1])… compress(‘abcd’,[0,1,0,0]) –> b
dropwhile() pred,seq seq[n],seq[n+1]… while pred(seq[n-1]) == False dropwhile(lambda x:x<3,[1,2,4,0,1]) --=""> 4,0,1
groupby() iterable,[keyfunc] 根据keyfunc(iterable item)值返回的迭代器
ifilter() pred,seq 返回seq中pred(seq[n])为真值的一部分元素 ifilter(lambda x:x>3,[1,2,3,4,5,6]) –> 4,5,6
ifilterfalse() pred,seq 返回seq中pred(seq[n])为假的一部分元素 ifilterfalse(lambda x:x>3,[1,2,3,4,5,6]) –> 1,2,3
islice() seq, [start,] stop [, step] 返回seq[start:stop:step]的切片 islice(count(10),1,3) -> 11,12
imap() func, p, q, … func(p0, q0), func(p1, q1), … imap(lambda x,y:x+y,count(0),count(10)) –> 10,11,12,…
starmap() func, seq func(seq[0]), func(seq[1]), … starmap(pow, [(2,5), (3,2), (10,3)]) –> 32 9 1000
tee() it, n it1, it2, … itn splits one iterator into n
takewhile() pred,seq seq[0], seq[1], until pred fails takewhile(lambda x: x<5, [1,4,6,4,1])="" --=""> 1 4
izip() p, q, … (p[0], q[0]), (p[1], q[1]), … 返回迭代器的长度和参数中长度最短迭代器相同 izip(‘ABCD’, ‘xy’) –> Ax By
izip_longest() p, q, … (p[0], q[0]), (p[1], q[1]), … izip_longest(‘ABCD’, ‘xy’, fillvalue=’-‘) –> Ax By C- D-

组合生成器🎈

迭代器 参数 返回值 示例
product() p, q, … [repeat=1] 返回输入参数的笛卡尔积
permutations() p[, r] 返回由长度为r的p中元素的组合,
每个元素不会重复出现
permutations([1,2],2) –>
(1, 2), (2, 1)
combinations() p, r 按照p中元素的顺序来进行排列组合,
每个元素不会重复出现
combinations([2,1],1) –>
(2,), (1,)
combinations_with_replacement() p, r 按照p中元素的顺序来进行排列组合,
每个元素可以重复出现
combinationswith
replacement([1,2],2)
–> (1, 1), (1, 2), (2, 2)

详解

如下的一些方法都是用来创建或者返回迭代器的,其中一些会返回无限长度的迭代器,如果要将他们用在另外的函数或者循环中的时候需要进行切片操作。

  • itertools.chain(*iterables)
    输入参数是一个或者多个迭代器对象,返回的内容是将这些迭代器中的所有元素拼接成为一个大的迭代器,需要注意的是,当作参数输入的若干个迭代器可以是不同的类型(区别于同种类型的序列相加的操作,如两个list相加或者两个string相加).
    itertools.chain(*iterables)类似于:

    1
    2
    3
    4
    5
    def chain(*iterables):
    # chain('ABC', 'DEF') --> A B C D E F
    for iterable in iterables:
    for element in iterable:
    yield element
  • classmethod chain.from_iterable(iterable)
    将输入参数iterable中的每个可迭代对象中的元素合并成为一个大的迭代器,类似于以下代码:

    1
    2
    3
    4
    5
    def from_iterable(iterable):
    # chain.from_iterable(['ABC', 'DEF']) --> A B C D E F
    for item in iterable:
    for element in item:
    yield element
  • itertools.combinations(iterable, r) 😢
    返回一个由r个iterable元素组合而成的迭代器,如果iterable中的元素是经过排序的,那么返回的每个对象也都是经过排序的。iterbale中的每个元素都是按照它在iterable中所在的位置进行处理。itertools.combinations(iterable, r)类似于如下代码过程:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    def combinations(iterable, r):
    # combinations('ABCD', 2) --> AB AC AD BC BD CD
    # combinations(range(4), 3) --> 012 013 023 123
    pool = tuple(iterable)
    n = len(pool)
    if r > n:
    return
    indices = range(r)
    yield tuple(pool[i] for i in indices)
    while True:
    for i in reversed(range(r)):
    if indices[i] != i + n - r:
    break
    else:
    return
    indices[i] += 1
    for j in range(i+1, r):
    indices[j] = indices[j-1] + 1
    yield tuple(pool[i] for i in indices)

或者

1
2
3
4
5
6
def combinations(iterable, r):
pool = tuple(iterable)
n = len(pool)
for indices in permutations(range(n), r):
if sorted(indices) == list(indices):
yield tuple(pool[i] for i in indices)

  • itertools.compress(data, selectors)
    输入参数data和selectors均为迭代器对象,如果selector中某一元素返回真值,则返回对应位置data中的元素。类似于代码:

    1
    2
    3
    def compress(data,selectors):
    # compress('ABCDEF', [1,0,1,0,1,1]) --> A C E F
    return (d for d,s in izip(data,selectors) if s)
  • itertools.count(start=0, step=1)
    用于返回一个数值连续的迭代器,常作为imap()或者izip()的参数。等价于代码:

    1
    2
    3
    4
    5
    6
    7
    def count(start=0,step=1):
    # count(10) --> 10 11 12 13 14 ...
    # count(2.5, 0.5) -> 2.5 3.0 3.5 ...
    n = start
    while True:
    yield n
    n += step
  • itertools.cycle(iterable)
    逐个返回iterable中的元素,并将每个元素备份,在iterable中元素耗尽的时候,重复的返回iterable对象的备份。等价于:

    1
    2
    3
    4
    5
    6
    7
    8
    def cycle(iterable):
    container = []
    for item in iterable:
    yield item
    container.append(item)
    while container:
    for element in container:
    yield element
  • itertools.dropwhile(predicate, iterable)
    如果predicate返回值为True,就将iterable中的元素抛弃,直到predicate返回False,返回iterable中剩下的元素。类似于代码实现:

    1
    2
    3
    4
    5
    6
    7
    8
    def dropwhile(pred,iteration):
    iterable = iter(iteration)
    for x in iterable:
    if not pred(x):
    yield x
    break
    for x in iterable:
    yield x
  • itertools.ifilter(predicate, iterable)
    如果iterable中的元素element,在执行predicate(element)返回True,则将这个element返回。如果predicate为None,则返回iterable中的真值。类似于:

    1
    2
    3
    4
    5
    6
    def ifilter(pred,iterable):
    if pred is None:
    pred = bool
    for item in iterable:
    if pred(item):
    yield item
  • itertools.ifilterfalse(predicate, iterable)
    itertools.ifilter相反,类似于代码:

    1
    2
    3
    4
    5
    6
    def ifileterfalse(pred,iterable):
    if pred is None:
    pred = bool
    for item in iterable:
    if not pred(item):
    yield item
  • itertools.imap(function, *iterables)
    将来自于iterables中多个迭代器中的每次各选取一个元素作为function的参数,返回function执行后的结果.如果function为空,缺省值为tuple。区别于map,imap中的迭代器可以是无穷序列,并且imap中当最短的迭代器中没有元素的时候会结束,而不是使用None来代替。执行代码类似于:

    1
    2
    3
    4
    5
    6
    7
    def imap(func,*iterables):
    its = map(iter,iterables)
    if func is None:
    func = tuple
    while True:
    args = [next(it) for it in its]
    yield func(*args)
  • itertools.islice(iterable, stop) itertools.islice(iterable, start, stop[, step])
    与普通的slice方法不同,islice的参数start,stop或者step不能为负值,类似于代码:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    def islice(iterable, *args):
    # islice('ABCDEFG', 2) --> A B
    # islice('ABCDEFG', 2, 4) --> C D
    # islice('ABCDEFG', 2, None) --> C D E F G
    # islice('ABCDEFG', 0, None, 2) --> A C E G
    s = slice(*args)
    it = iter(xrange(s.start or 0, s.stop or sys.maxint, s.step or 1))
    nexti = next(it)
    for i, element in enumerate(iterable):
    if i == nexti:
    yield element
    nexti = next(it)
  • itertools.izip(*iterables)
    与zip不同,izip的返回值是一个迭代器而不是list对象。运行代码类似于:

    1
    2
    3
    4
    def izip(*iterables):
    iters = map(iter,iterables)
    while iters:
    yield tuple(map(next,iters))
  • itertools.repeat(object[, times])
    生成一个重复出现object times次的迭代器,类似代码:

    1
    2
    3
    4
    5
    6
    7
    def repeat(object,times):
    if times is None:
    while True:
    yield object
    else:
    for x in rang(times):
    yield object
  • itertools.starmap(function, iterable)
    实现类似代码:

    1
    2
    3
    def starmap(func,iterable):
    for item in iterable:
    yield func(*item)