迭代器         參數(shù)         結(jié)果                                                例子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

迭代器          參數(shù)            結(jié)果                                        例子chain()     p, q, ...           p0, p1, ... plast, q0, q1, ...              chain('ABC', 'DEF') --> A B C D E FcomPRess()  data, selectors     (d[0] if s[0]), (d[1] if s[1]), ...         compress('ABCDEF', [1,0,1,0,1,1]) --> A C E Fdropwhile() pred, seq           seq[n], seq[n+1], starting when pred fails  dropwhile(lambda x: x<5, [1,4,6,4,1]) --> 6 4 1groupby()   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 9ifilterfalse()  pred, seq       elements of seq where pred(elem) is False   ifilterfalse(lambda x: x%2, range(10)) --> 0 2 4 6 8islice()    seq, [start,] stop [, step] elements from seq[start:stop:step]  islice('ABCDEFG', 2, None) --> C D E F Gimap()      func, p, q, ...     func(p0, q0), func(p1, q1), ...             imap(pow, (2,3,10), (5,2,3)) --> 32 9 1000starmap()   func, seq           func(*seq[0]), func(*seq[1]), ...           starmap(pow, [(2,5), (3,2), (10,3)]) --> 32 9 1000tee()       it, n               it1, it2 , ... itn splits one iterator into ntakewhile() pred, seq           seq[0], seq[1], until pred fails            takewhile(lambda x: x<5, [1,4,6,4,1]) --> 1 4izip()      p, q, ...           (p[0], q[0]), (p[1], q[1]), ...             izip('ABCD', 'xy') --> Ax Byizip_longest()  p, q, ...       (p[0], q[0]), (p[1], q[1]), ...             izip_longest('ABCD', 'xy', fillvalue='-') --> Ax By C- D-

迭代器          參數(shù)                        結(jié)果product()       p, q, ... [repeat=1]        cartesian product, equivalent to a nested for-looppermutations()  p[, r]                      r-length tuples, all possible orderings, no repeated elementscombinations()  p, r                        r-length tuples, in sorted order, no repeated elementscombinations_with_replacement() p, r        r-length tuples, in sorted order, with repeated elementsproduct('ABCD', repeat=2)                   AA AB AC AD BA BB BC BD CA CB CC CD DA DB DC DDpermutations('ABCD', 2)                     AB AC AD BA BC BD CA CB CD DA DB DCcombinations('ABCD', 2)                     AB AC AD BC BD CDcombinations_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 = start    while True:        yield n        n += 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 element        saved.append(element)    while saved:        for element in saved:            yield element

from itertools import *i = 0for item in cycle(['a', 'b', 'c']):    i += 1    if i == 10:        break    print (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 10    if times is None:        while True:            yield object    else:        for i in xrange(times):            yield object

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

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

from itertools import *for i in chain([1, 2, 3], ['a', 'b', 'c']):    print i123abcfrom itertools import chain, imapdef 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 F    return (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 1    iterable = iter(iterable)    for x in iterable:        if not predicate(x):            yield x            break    for x in iterable:        yield x

from itertools import *def should_drop(x):    print 'Testing:', x    return (x<1)for i in dropwhile(should_drop, [ -1, 0, 1, 2, 3, 4, 1, -2 ]):    print 'Yielding:', iTesting: -1Testing: 0Testing: 1Yielding: 1Yielding: 2Yielding: 3Yielding: 4Yielding: 1Yielding: -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 D    def __init__(self, iterable, key=None):        if key is None:            key = lambda x: x        self.keyfunc = key        self.it = iter(iterable)        self.tgtkey = self.currkey = self.currvalue = object()    def __iter__(self):        return self    def next(self):        while self.currkey == self.tgtkey:            self.currvalue = next(self.it)    # Exit on StopIteration            self.currkey = self.keyfunc(self.currvalue)        self.tgtkey = self.currkey        return (self.currkey, self._grouper(self.tgtkey))    def _grouper(self, tgtkey):        while self.currkey == tgtkey:            yield self.currvalue            self.currvalue = next(self.it)    # Exit on StopIteration            self.currkey = self.keyfunc(self.currvalue)

from itertools import groupbyqs = [{'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 9    if predicate is None:        predicate = bool    for x in iterable:        if predicate(x):            yield x

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

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

from itertools import *def check_item(x):    print 'Testing:', x    return (x<1)for i in ifilterfalse(check_item, [ -1, 0, 1, 2, 3, 4, 1, -2 ]):    print 'Yielding:', iTesting: -1Testing: 0Testing: 1Yielding: 1Testing: 2Yielding: 2Testing: 3Yielding: 3Testing: 4Yielding: 4Testing: 1Yielding: 1Testing: -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 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)

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:01234Start at 5, Stop at 10:56789By tens to 100:0102030405060708090

def imap(function, *iterables):    # imap(pow, (2,3,10), (5,2,3)) --> 32 9 1000    iterables = 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:02468Multiples:0 * 5 = 01 * 6 = 62 * 7 = 143 * 8 = 244 * 9 = 36

def starmap(function, iterable):    # starmap(pow, [(2,5), (3,2), (10,3)]) --> 32 9 1000    for 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 = 01 * 6 = 62 * 7 = 143 * 8 = 244 * 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 empty                newval = next(it)       # fetch a new value and                for d in deques:        # load it to all the deques                    d.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:', ifor i in i2:    print 'i2:', ii1: 0i1: 1i1: 2i1: 3i1: 4i2: 0i2: 1i2: 2i2: 3i2: 4

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

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

izip(iter1, iter2, ... iterN):返回:(it1[0],it2 [0], it3[0], ..), (it1[1], it2[1], it3[1], ..)...def izip(*iterables):    # izip('ABCD', 'xy') --> Ax By    iterators = 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 ZipExhausted        counter[0] -= 1        yield fillvalue    fillers = 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 111    pools = 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 itertoolsa = (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 210    pool = tuple(iterable)    n = len(pool)    r = n if r is None else r    if r > n:        return    indices = 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] -= 1            if cycles[i] == 0:                indices[i:] = indices[i+1:] + indices[i:i+1]                cycles[i] = n - i            else:                j = cycles[i]                indices[i], indices[-j] = indices[-j], indices[i]                yield tuple(pool[i] for i in indices[:r])                break        else:            return也可以用product實現(xiàn)def permutations(iterable, r=None):    pool = tuple(iterable)    n = len(pool)    r = n if r is None else r    for 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 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)#或者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 CC    pool = tuple(iterable)    n = len(pool)    if not n and r:        return    indices = [0] * r    yield tuple(pool[i] for i in indices)    while True:        for i in reversed(range(r)):            if indices[i] != n - 1:                break        else:            return        indices[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 deque        collections.deque(iterator, maxlen=0)    else:        # advance to the empty slice starting at position n        next(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 Gxx    args = [iter(iterable)] * n    return izip_longest(fillvalue=fillvalue, *args)def roundrobin(*iterables):    "roundrobin('ABC', 'D', 'EF') --> A D E B F C"    # Recipe credited to George Sakkis    pending = len(iterables)    nexts = cycle(iter(it).next for it in iterables)    while pending:        try:            for next in nexts:                yield next()        except StopIteration:            pending -= 1            nexts = 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 D    seen = set()    seen_add = seen.add    if key is None:        for element in ifilterfalse(seen.__contains__, iterable):            seen_add(element)            yield element    else:        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 D    return 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 instead    of 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 r    return 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 object    while leaving the tee object at its current position.    Raise an IndexError if the underlying iterator doesn't    have enough values.    """    for value in islice(t.__copy__(), i, None):        return value    raise IndexError(i)

from itertools import chain, islicedef 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)]