• Python-进阶-itertools模块小结
  • 组成
  • 第一部分
    • itertools.count(start=0, step=1)
    • itertools.cycle(iterable)
    • itertools.repeat(object[, times])
  • 第二部分
    • itertools.chain(*iterables)
    • itertools.compress(data, selectors)
    • itertools.dropwhile(predicate, iterable)
    • itertools.groupby(iterable[, key])
    • itertools.ifilter(predicate, iterable)
    • itertools.ifilterfalse(predicate, iterable)
    • itertools.islice(iterable, stop)
    • itertools.imap(function, *iterables)
    • itertools.starmap(function, iterable)
    • itertools.tee(iterable[, n=2])
    • itertools.takewhile(predicate, iterable)
    • itertools.izip(*iterables)
    • itertools.izip_longest(*iterables[, fillvalue])
  • 第三部分
    • itertools.product(*iterables[, repeat])
    • itertools.permutations(iterable[, r])
    • itertools.combinations(iterable, r)
    • itertools.combinations_with_replacement(iterable, r)
  • 第四部分
    • 扩展
    • 自定义扩展
    • 补充

迭代器         参数         结果                                                例子
count()     start, [step]   start, start+step, start+2*step, ...                count(10) --> 10 11 12 13 14 ...
cycle()     p               p0, p1, ... plast, p0, p1, ...                      cycle('ABCD') --> A B C D A B C D ...
repeat()    elem [,n]       elem, elem, elem, ... endlessly or up to n times    repeat(10, 3) --> 10 10 10

迭代器          参数            结果                                        例子
chain()     p, q, ...           p0, p1, ... plast, q0, q1, ...              chain('ABC', 'DEF') --> A B C D E F
compress()  data, selectors     (d[0] if s[0]), (d[1] if s[1]), ...         compress('ABCDEF', [1,0,1,0,1,1]) --> A C E F
dropwhile() pred, seq           seq[n], seq[n+1], starting when pred fails  dropwhile(lambda x: x<5, [1,4,6,4,1]) --> 6 4 1
groupby()   iterable[, keyfunc] sub-iterators grouped by value of keyfunc(v)
ifilter()   pred, seq           elements of seq where pred(elem) is True    ifilter(lambda x: x%2, range(10)) --> 1 3 5 7 9
ifilterfalse()  pred, seq       elements of seq where pred(elem) is False   ifilterfalse(lambda x: x%2, range(10)) --> 0 2 4 6 8
islice()    seq, [start,] stop [, step] elements from seq[start:stop:step]  islice('ABCDEFG', 2, None) --> C D E F G
imap()      func, p, q, ...     func(p0, q0), func(p1, q1), ...             imap(pow, (2,3,10), (5,2,3)) --> 32 9 1000
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]        cartesian product, equivalent to a nested for-loop
permutations()  p[, r]                      r-length tuples, all possible orderings, no repeated elements
combinations()  p, r                        r-length tuples, in sorted order, no repeated elements
combinations_with_replacement() p, r        r-length tuples, in sorted order, with repeated elements
product('ABCD', repeat=2)                   AA AB AC AD BA BB BC BD CA CB CC CD DA DB DC DD
permutations('ABCD', 2)                     AB AC AD BA BC BD CA CB CD DA DB DC
combinations('ABCD', 2)                     AB AC AD BC BD CD
combinations_with_replacement('ABCD', 2)    AA AB AC AD BB BC BD CC CD DD

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 = startwhile True:yield nn += step等同于(start + step * i for i in count())

from itertools import *for i in izip(count(1), ['a', 'b', 'c']):print i(1, 'a')
(2, 'b')
(3, 'c')

def cycle(iterable):# cycle('ABCD') --> A B C D A B C D A B C D ...saved = []for element in iterable:yield elementsaved.append(element)while saved:for element in saved:yield element

from itertools import *i = 0
for item in cycle(['a', 'b', 'c']):i += 1if i == 10:breakprint (i, item)(1, 'a')
(2, 'b')
(3, 'c')
(4, 'a')
(5, 'b')
(6, 'c')
(7, 'a')
(8, 'b')
(9, 'c')

def repeat(object, times=None):# repeat(10, 3) --> 10 10 10if times is None:while True:yield objectelse:for i in xrange(times):yield object

from itertools import *for i in repeat('over-and-over', 5):print iover-and-over
over-and-over
over-and-over
over-and-over
over-and-over

def chain(*iterables):# chain('ABC', 'DEF') --> A B C D E Ffor it in iterables:for element in it:yield element

from itertools import *for i in chain([1, 2, 3], ['a', 'b', 'c']):print i
1
2
3
a
b
cfrom itertools import chain, imap
def flatmap(f, items):return chain.from_iterable(imap(f, items))
>>> list(flatmap(os.listdir, dirs))
>>> ['settings.py', 'wsgi.py', 'templates', 'app.py','templates', 'index.html, 'config.json']

def compress(data, selectors):# compress('ABCDEF', [1,0,1,0,1,1]) --> A C E Freturn (d for d, s in izip(data, selectors) if s)

def dropwhile(predicate, iterable):# dropwhile(lambda x: x<5, [1,4,6,4,1]) --> 6 4 1iterable = iter(iterable)for x in iterable:if not predicate(x):yield xbreakfor x in iterable:yield x

from itertools import *def should_drop(x):print 'Testing:', xreturn (x<1)for i in dropwhile(should_drop, [ -1, 0, 1, 2, 3, 4, 1, -2 ]):print 'Yielding:', iTesting: -1
Testing: 0
Testing: 1
Yielding: 1
Yielding: 2
Yielding: 3
Yielding: 4
Yielding: 1
Yielding: -2

class groupby(object):# [k for k, g in groupby('AAAABBBCCDAABBB')] --> A B C D A B# [list(g) for k, g in groupby('AAAABBBCCD')] --> AAAA BBB CC Ddef __init__(self, iterable, key=None):if key is None:key = lambda x: xself.keyfunc = keyself.it = iter(iterable)self.tgtkey = self.currkey = self.currvalue = object()def __iter__(self):return selfdef next(self):while self.currkey == self.tgtkey:self.currvalue = next(self.it)    # Exit on StopIterationself.currkey = self.keyfunc(self.currvalue)self.tgtkey = self.currkeyreturn (self.currkey, self._grouper(self.tgtkey))def _grouper(self, tgtkey):while self.currkey == tgtkey:yield self.currvalueself.currvalue = next(self.it)    # Exit on StopIterationself.currkey = self.keyfunc(self.currvalue)

from itertools import groupby
qs = [{'date' : 1},{'date' : 2}]
[(name, list(group)) for name, group in itertools.groupby(qs, lambda p:p['date'])]Out[77]: [(1, [{'date': 1}]), (2, [{'date': 2}])]>>> from itertools import *
>>> a = ['aa', 'ab', 'abc', 'bcd', 'abcde']
>>> for i, k in groupby(a, len):
...     print i, list(k)
...
2 ['aa', 'ab']
3 ['abc', 'bcd']
5 ['abcde']

from itertools import *
from operator import itemgetterd = dict(a=1, b=2, c=1, d=2, e=1, f=2, g=3)
di = sorted(d.iteritems(), key=itemgetter(1))
for k, g in groupby(di, key=itemgetter(1)):print k, map(itemgetter(0), g)1 ['a', 'c', 'e']
2 ['b', 'd', 'f']
3 ['g']

def ifilter(predicate, iterable):# ifilter(lambda x: x%2, range(10)) --> 1 3 5 7 9if predicate is None:predicate = boolfor x in iterable:if predicate(x):yield x

from itertools import *def check_item(x):print 'Testing:', xreturn (x<1)for i in ifilter(check_item, [ -1, 0, 1, 2, 3, 4, 1, -2 ]):print 'Yielding:', iTesting: -1
Yielding: -1
Testing: 0
Yielding: 0
Testing: 1
Testing: 2
Testing: 3
Testing: 4
Testing: 1
Testing: -2
Yielding: -2

def ifilterfalse(predicate, iterable):# ifilterfalse(lambda x: x%2, range(10)) --> 0 2 4 6 8if predicate is None:predicate = boolfor x in iterable:if not predicate(x):yield x

from itertools import *def check_item(x):print 'Testing:', xreturn (x<1)for i in ifilterfalse(check_item, [ -1, 0, 1, 2, 3, 4, 1, -2 ]):print 'Yielding:', iTesting: -1
Testing: 0
Testing: 1
Yielding: 1
Testing: 2
Yielding: 2
Testing: 3
Yielding: 3
Testing: 4
Yielding: 4
Testing: 1
Yielding: 1
Testing: -2

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 Gs = 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 elementnexti = next(it)

from itertools import *print 'Stop at 5:'
for i in islice(count(), 5):print iprint 'Start at 5, Stop at 10:'
for i in islice(count(), 5, 10):print iprint 'By tens to 100:'
for i in islice(count(), 0, 100, 10):print iStop at 5:
0
1
2
3
4
Start at 5, Stop at 10:
5
6
7
8
9
By tens to 100:
0
10
20
30
40
50
60
70
80
90

def imap(function, *iterables):# imap(pow, (2,3,10), (5,2,3)) --> 32 9 1000iterables = map(iter, iterables)while True:args = [next(it) for it in iterables]if function is None:yield tuple(args)else:yield function(*args)

from itertools import *print 'Doubles:'
for i in imap(lambda x:2*x, xrange(5)):print iprint 'Multiples:'
for i in imap(lambda x,y:(x, y, x*y), xrange(5), xrange(5,10)):print '%d * %d = %d' % iDoubles:
0
2
4
6
8
Multiples:
0 * 5 = 0
1 * 6 = 6
2 * 7 = 14
3 * 8 = 24
4 * 9 = 36

def starmap(function, iterable):# starmap(pow, [(2,5), (3,2), (10,3)]) --> 32 9 1000for args in iterable:yield function(*args)

from itertools import *values = [(0, 5), (1, 6), (2, 7), (3, 8), (4, 9)]
for i in starmap(lambda x,y:(x, y, x*y), values):print '%d * %d = %d' % i0 * 5 = 0
1 * 6 = 6
2 * 7 = 14
3 * 8 = 24
4 * 9 = 36

def tee(iterable, n=2):it = iter(iterable)deques = [collections.deque() for i in range(n)]def gen(mydeque):while True:if not mydeque:             # when the local deque is emptynewval = next(it)       # fetch a new value andfor d in deques:        # load it to all the dequesd.append(newval)yield mydeque.popleft()return tuple(gen(d) for d in deques)

from itertools import *r = islice(count(), 5)
i1, i2 = tee(r)for i in i1:print 'i1:', i
for i in i2:print 'i2:', ii1: 0
i1: 1
i1: 2
i1: 3
i1: 4
i2: 0
i2: 1
i2: 2
i2: 3
i2: 4

def takewhile(predicate, iterable):# takewhile(lambda x: x<5, [1,4,6,4,1]) --> 1 4for x in iterable:if predicate(x):yield xelse:break

from itertools import *def should_take(x):print 'Testing:', xreturn (x<2)for i in takewhile(should_take, [ -1, 0, 1, 2, 3, 4, 1, -2 ]):print 'Yielding:', iTesting: -1
Yielding: -1
Testing: 0
Yielding: 0
Testing: 1
Yielding: 1
Testing: 2

izip(iter1, iter2, ... iterN):
返回:(it1[0],it2 [0], it3[0], ..), (it1[1], it2[1], it3[1], ..)...def izip(*iterables):# izip('ABCD', 'xy') --> Ax Byiterators = map(iter, iterables)while iterators:yield tuple(map(next, iterators))

from itertools import *for i in izip([1, 2, 3], ['a', 'b', 'c']):print i
(1, 'a')
(2, 'b')
(3, 'c')

class ZipExhausted(Exception):passdef izip_longest(*args, **kwds):# izip_longest('ABCD', 'xy', fillvalue='-') --> Ax By C- D-fillvalue = kwds.get('fillvalue')counter = [len(args) - 1]def sentinel():if not counter[0]:raise ZipExhaustedcounter[0] -= 1yield fillvaluefillers = repeat(fillvalue)iterators = [chain(it, sentinel(), fillers) for it in args]try:while iterators:yield tuple(map(next, iterators))except ZipExhausted:pass

def product(*args, **kwds):# product('ABCD', 'xy') --> Ax Ay Bx By Cx Cy Dx Dy# product(range(2), repeat=3) --> 000 001 010 011 100 101 110 111pools = map(tuple, args) * kwds.get('repeat', 1)result = [[]]for pool in pools:result = [x+[y] for x in result for y in pool]for prod in result:yield tuple(prod)

import itertools
a = (1, 2, 3)
b = ('A', 'B', 'C')
c = itertools.product(a,b)
for elem in c:print elem(1, 'A')
(1, 'B')
(1, 'C')
(2, 'A')
(2, 'B')
(2, 'C')
(3, 'A')
(3, 'B')
(3, 'C')

def permutations(iterable, r=None):# permutations('ABCD', 2) --> AB AC AD BA BC BD CA CB CD DA DB DC# permutations(range(3)) --> 012 021 102 120 201 210pool = tuple(iterable)n = len(pool)r = n if r is None else rif r > n:returnindices = range(n)cycles = range(n, n-r, -1)yield tuple(pool[i] for i in indices[:r])while n:for i in reversed(range(r)):cycles[i] -= 1if cycles[i] == 0:indices[i:] = indices[i+1:] + indices[i:i+1]cycles[i] = n - ielse:j = cycles[i]indices[i], indices[-j] = indices[-j], indices[i]yield tuple(pool[i] for i in indices[:r])breakelse:return
也可以用product实现def permutations(iterable, r=None):pool = tuple(iterable)n = len(pool)r = n if r is None else rfor indices in product(range(n), repeat=r):if len(set(indices)) == r:yield tuple(pool[i] for i in indices)

def combinations(iterable, r):# combinations('ABCD', 2) --> AB AC AD BC BD CD# combinations(range(4), 3) --> 012 013 023 123pool = tuple(iterable)n = len(pool)if r > n:returnindices = range(r)yield tuple(pool[i] for i in indices)while True:for i in reversed(range(r)):if indices[i] != i + n - r:breakelse:returnindices[i] += 1for j in range(i+1, r):indices[j] = indices[j-1] + 1yield tuple(pool[i] for i in indices)#或者
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)

def combinations_with_replacement(iterable, r):# combinations_with_replacement('ABC', 2) --> AA AB AC BB BC CCpool = tuple(iterable)n = len(pool)if not n and r:returnindices = [0] * ryield tuple(pool[i] for i in indices)while True:for i in reversed(range(r)):if indices[i] != n - 1:breakelse:returnindices[i:] = [indices[i] + 1] * (r - i)yield tuple(pool[i] for i in indices)
或者
def combinations_with_replacement(iterable, r):pool = tuple(iterable)n = len(pool)for indices in product(range(n), repeat=r):if sorted(indices) == list(indices):yield tuple(pool[i] for i in indices)

def take(n, iterable):"Return first n items of the iterable as a list"return list(islice(iterable, n))def tabulate(function, start=0):"Return function(0), function(1), ..."return imap(function, count(start))def consume(iterator, n):"Advance the iterator n-steps ahead. If n is none, consume entirely."# Use functions that consume iterators at C speed.if n is None:# feed the entire iterator into a zero-length dequecollections.deque(iterator, maxlen=0)else:# advance to the empty slice starting at position nnext(islice(iterator, n, n), None)def nth(iterable, n, default=None):"Returns the nth item or a default value"return next(islice(iterable, n, None), default)def quantify(iterable, pred=bool):"Count how many times the predicate is true"return sum(imap(pred, iterable))def padnone(iterable):"""Returns the sequence elements and then returns None indefinitely.Useful for emulating the behavior of the built-in map() function."""return chain(iterable, repeat(None))def ncycles(iterable, n):"Returns the sequence elements n times"return chain.from_iterable(repeat(tuple(iterable), n))def dotproduct(vec1, vec2):return sum(imap(operator.mul, vec1, vec2))def flatten(listOfLists):"Flatten one level of nesting"return chain.from_iterable(listOfLists)def repeatfunc(func, times=None, *args):"""Repeat calls to func with specified arguments.Example:  repeatfunc(random.random)"""if times is None:return starmap(func, repeat(args))return starmap(func, repeat(args, times))def pairwise(iterable):"s -> (s0,s1), (s1,s2), (s2, s3), ..."a, b = tee(iterable)next(b, None)return izip(a, b)def grouper(iterable, n, fillvalue=None):"Collect data into fixed-length chunks or blocks"# grouper('ABCDEFG', 3, 'x') --> ABC DEF Gxxargs = [iter(iterable)] * nreturn izip_longest(fillvalue=fillvalue, *args)def roundrobin(*iterables):"roundrobin('ABC', 'D', 'EF') --> A D E B F C"# Recipe credited to George Sakkispending = len(iterables)nexts = cycle(iter(it).next for it in iterables)while pending:try:for next in nexts:yield next()except StopIteration:pending -= 1nexts = cycle(islice(nexts, pending))def powerset(iterable):"powerset([1,2,3]) --> () (1,) (2,) (3,) (1,2) (1,3) (2,3) (1,2,3)"s = list(iterable)return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))def unique_everseen(iterable, key=None):"List unique elements, preserving order. Remember all elements ever seen."# unique_everseen('AAAABBBCCDAABBB') --> A B C D# unique_everseen('ABBCcAD', str.lower) --> A B C Dseen = set()seen_add = seen.addif key is None:for element in ifilterfalse(seen.__contains__, iterable):seen_add(element)yield elementelse:for element in iterable:k = key(element)if k not in seen:seen_add(k)yield elementdef unique_justseen(iterable, key=None):"List unique elements, preserving order. Remember only the element just seen."# unique_justseen('AAAABBBCCDAABBB') --> A B C D A B# unique_justseen('ABBCcAD', str.lower) --> A B C A Dreturn imap(next, imap(itemgetter(1), groupby(iterable, key)))def iter_except(func, exception, first=None):""" Call a function repeatedly until an exception is raised.Converts a call-until-exception interface to an iterator interface.Like __builtin__.iter(func, sentinel) but uses an exception insteadof a sentinel to end the loop.Examples:bsddbiter = iter_except(db.next, bsddb.error, db.first)heapiter = iter_except(functools.partial(heappop, h), IndexError)dictiter = iter_except(d.popitem, KeyError)dequeiter = iter_except(d.popleft, IndexError)queueiter = iter_except(q.get_nowait, Queue.Empty)setiter = iter_except(s.pop, KeyError)"""try:if first is not None:yield first()while 1:yield func()except exception:passdef random_product(*args, **kwds):"Random selection from itertools.product(*args, **kwds)"pools = map(tuple, args) * kwds.get('repeat', 1)return tuple(random.choice(pool) for pool in pools)def random_permutation(iterable, r=None):"Random selection from itertools.permutations(iterable, r)"pool = tuple(iterable)r = len(pool) if r is None else rreturn tuple(random.sample(pool, r))def random_combination(iterable, r):"Random selection from itertools.combinations(iterable, r)"pool = tuple(iterable)n = len(pool)indices = sorted(random.sample(xrange(n), r))return tuple(pool[i] for i in indices)def random_combination_with_replacement(iterable, r):"Random selection from itertools.combinations_with_replacement(iterable, r)"pool = tuple(iterable)n = len(pool)indices = sorted(random.randrange(n) for i in xrange(r))return tuple(pool[i] for i in indices)def tee_lookahead(t, i):"""Inspect the i-th upcomping value from a tee objectwhile leaving the tee object at its current position.Raise an IndexError if the underlying iterator doesn'thave enough values."""for value in islice(t.__copy__(), i, None):return valueraise IndexError(i)

from itertools import chain, islice
def chunks(iterable, size, format=iter):it = iter(iterable)while True:yield format(chain((it.next(),), islice(it, size - 1)))>>> l = ["a", "b", "c", "d", "e", "f", "g"]
>>> for chunk in chunks(l, 3, tuple):...print chunk...
("a", "b", "c")
("d", "e", "f")
("g",)

>>> horses = [1, 2, 3, 4]
>>> races = itertools.permutations(horses)
>>> print(races)
<itertools.permutations object at 0xb754f1dc]]>
>>> print(list(itertools.permutations(horses)))
[(1, 2, 3, 4),(1, 2, 4, 3),(1, 3, 2, 4),(1, 3, 4, 2),(1, 4, 2, 3),(1, 4, 3, 2),(2, 1, 3, 4),(2, 1, 4, 3),(2, 3, 1, 4),(2, 3, 4, 1),(2, 4, 1, 3),(2, 4, 3, 1),(3, 1, 2, 4),(3, 1, 4, 2),(3, 2, 1, 4),(3, 2, 4, 1),(3, 4, 1, 2),(3, 4, 2, 1),(4, 1, 2, 3),(4, 1, 3, 2),(4, 2, 1, 3),(4, 2, 3, 1),(4, 3, 1, 2),(4, 3, 2, 1)]