Functional tools for creating and using iterators.
 
Infinite iterators:
count([n]) --> n, n+1, n+2, ...
cycle(p) --> p0, p1, ... plast, p0, p1, ...
repeat(elem [,n]) --> elem, elem, elem, ... endlessly or up to n times
 
Iterators terminating on the shortest input sequence:
chain(p, q, ...) --> p0, p1, ... plast, q0, q1, ... 
compress(data, selectors) --> (d[0] if s[0]), (d[1] if s[1]), ...
dropwhile(pred, seq) --> seq[n], seq[n+1], starting when pred fails
groupby(iterable[, keyfunc]) --> sub-iterators grouped by value of keyfunc(v)
ifilter(pred, seq) --> elements of seq where pred(elem) is True
ifilterfalse(pred, seq) --> elements of seq where pred(elem) is False
islice(seq, [start,] stop [, step]) --> elements from
       seq[start:stop:step]
imap(fun, p, q, ...) --> fun(p0, q0), fun(p1, q1), ...
starmap(fun, seq) --> fun(*seq[0]), fun(*seq[1]), ...
tee(it, n=2) --> (it1, it2 , ... itn) splits one iterator into n
takewhile(pred, seq) --> seq[0], seq[1], until pred fails
izip(p, q, ...) --> (p[0], q[0]), (p[1], q[1]), ... 
izip_longest(p, q, ...) --> (p[0], q[0]), (p[1], q[1]), ... 
 
Combinatoric generators:
product(p, q, ... [repeat=1]) --> cartesian product
permutations(p[, r])
combinations(p, r)
combinations_with_replacement(p, r)

Classes
		__builtin__.object chain combinations combinations_with_replacement compress count cycle dropwhile groupby ifilter ifilterfalse imap islice izip izip_longest permutations product repeat starmap takewhile   class chain(__builtin__.object)     chain(*iterables) --> chain object   Return a chain object whose .next() method returns elements from the first iterable until it is exhausted, then elements from the next iterable, until all of the iterables are exhausted.     Methods defined here: __getattribute__(...) x.__getattribute__('name') <==> x.name __iter__(...) x.__iter__() <==> iter(x) from_iterable(...) chain.from_iterable(iterable) --> chain object   Alternate chain() contructor taking a single iterable argument that evaluates lazily. next(...) x.next() -> the next value, or raise StopIteration Data and other attributes defined here: __new__ = <built-in method __new__ of type object> T.__new__(S, ...) -> a new object with type S, a subtype of T   class combinations(__builtin__.object)     combinations(iterable, r) --> combinations object   Return successive r-length combinations of elements in the iterable.   combinations(range(4), 3) --> (0,1,2), (0,1,3), (0,2,3), (1,2,3)     Methods defined here: __getattribute__(...) x.__getattribute__('name') <==> x.name __iter__(...) x.__iter__() <==> iter(x) next(...) x.next() -> the next value, or raise StopIteration Data and other attributes defined here: __new__ = <built-in method __new__ of type object> T.__new__(S, ...) -> a new object with type S, a subtype of T   class combinations_with_replacement(__builtin__.object)     combinations_with_replacement(iterable, r) --> combinations_with_replacement object   Return successive r-length combinations of elements in the iterable allowing individual elements to have successive repeats. combinations_with_replacement('ABC', 2) --> AA AB AC BB BC CC     Methods defined here: __getattribute__(...) x.__getattribute__('name') <==> x.name __iter__(...) x.__iter__() <==> iter(x) next(...) x.next() -> the next value, or raise StopIteration Data and other attributes defined here: __new__ = <built-in method __new__ of type object> T.__new__(S, ...) -> a new object with type S, a subtype of T   class compress(__builtin__.object)     compress(data, selectors) --> iterator over selected data   Return data elements corresponding to true selector elements. Forms a shorter iterator from selected data elements using the selectors to choose the data elements.     Methods defined here: __getattribute__(...) x.__getattribute__('name') <==> x.name __iter__(...) x.__iter__() <==> iter(x) next(...) x.next() -> the next value, or raise StopIteration Data and other attributes defined here: __new__ = <built-in method __new__ of type object> T.__new__(S, ...) -> a new object with type S, a subtype of T   class count(__builtin__.object)     count(start=0, step=1) --> count object   Return a count object whose .next() method returns consecutive values. Equivalent to:       def count(firstval=0, step=1):         x = firstval         while 1:             yield x             x += step     Methods defined here: __getattribute__(...) x.__getattribute__('name') <==> x.name __iter__(...) x.__iter__() <==> iter(x) __reduce__(...) Return state information for pickling. __repr__(...) x.__repr__() <==> repr(x) next(...) x.next() -> the next value, or raise StopIteration Data and other attributes defined here: __new__ = <built-in method __new__ of type object> T.__new__(S, ...) -> a new object with type S, a subtype of T   class cycle(__builtin__.object)     cycle(iterable) --> cycle object   Return elements from the iterable until it is exhausted. Then repeat the sequence indefinitely.     Methods defined here: __getattribute__(...) x.__getattribute__('name') <==> x.name __iter__(...) x.__iter__() <==> iter(x) next(...) x.next() -> the next value, or raise StopIteration Data and other attributes defined here: __new__ = <built-in method __new__ of type object> T.__new__(S, ...) -> a new object with type S, a subtype of T   class dropwhile(__builtin__.object)     dropwhile(predicate, iterable) --> dropwhile object   Drop items from the iterable while predicate(item) is true. Afterwards, return every element until the iterable is exhausted.     Methods defined here: __getattribute__(...) x.__getattribute__('name') <==> x.name __iter__(...) x.__iter__() <==> iter(x) next(...) x.next() -> the next value, or raise StopIteration Data and other attributes defined here: __new__ = <built-in method __new__ of type object> T.__new__(S, ...) -> a new object with type S, a subtype of T   class groupby(__builtin__.object)     groupby(iterable[, keyfunc]) -> create an iterator which returns (key, sub-iterator) grouped by each value of key(value).     Methods defined here: __getattribute__(...) x.__getattribute__('name') <==> x.name __iter__(...) x.__iter__() <==> iter(x) next(...) x.next() -> the next value, or raise StopIteration Data and other attributes defined here: __new__ = <built-in method __new__ of type object> T.__new__(S, ...) -> a new object with type S, a subtype of T   class ifilter(__builtin__.object)     ifilter(function or None, sequence) --> ifilter object   Return those items of sequence for which function(item) is true. If function is None, return the items that are true.     Methods defined here: __getattribute__(...) x.__getattribute__('name') <==> x.name __iter__(...) x.__iter__() <==> iter(x) next(...) x.next() -> the next value, or raise StopIteration Data and other attributes defined here: __new__ = <built-in method __new__ of type object> T.__new__(S, ...) -> a new object with type S, a subtype of T   class ifilterfalse(__builtin__.object)     ifilterfalse(function or None, sequence) --> ifilterfalse object   Return those items of sequence for which function(item) is false. If function is None, return the items that are false.     Methods defined here: __getattribute__(...) x.__getattribute__('name') <==> x.name __iter__(...) x.__iter__() <==> iter(x) next(...) x.next() -> the next value, or raise StopIteration Data and other attributes defined here: __new__ = <built-in method __new__ of type object> T.__new__(S, ...) -> a new object with type S, a subtype of T   class imap(__builtin__.object)     imap(func, *iterables) --> imap object   Make an iterator that computes the function using arguments from each of the iterables.  Like map() except that it returns an iterator instead of a list and that it stops when the shortest iterable is exhausted instead of filling in None for shorter iterables.     Methods defined here: __getattribute__(...) x.__getattribute__('name') <==> x.name __iter__(...) x.__iter__() <==> iter(x) next(...) x.next() -> the next value, or raise StopIteration Data and other attributes defined here: __new__ = <built-in method __new__ of type object> T.__new__(S, ...) -> a new object with type S, a subtype of T   class islice(__builtin__.object)     islice(iterable, [start,] stop [, step]) --> islice object   Return an iterator whose next() method returns selected values from an iterable.  If start is specified, will skip all preceding elements; otherwise, start defaults to zero.  Step defaults to one.  If specified as another value, step determines how many values are  skipped between successive calls.  Works like a slice() on a list but returns an iterator.     Methods defined here: __getattribute__(...) x.__getattribute__('name') <==> x.name __iter__(...) x.__iter__() <==> iter(x) next(...) x.next() -> the next value, or raise StopIteration Data and other attributes defined here: __new__ = <built-in method __new__ of type object> T.__new__(S, ...) -> a new object with type S, a subtype of T   class izip(__builtin__.object)     izip(iter1 [,iter2 [...]]) --> izip object   Return a izip object whose .next() method returns a tuple where the i-th element comes from the i-th iterable argument.  The .next() method continues until the shortest iterable in the argument sequence is exhausted and then it raises StopIteration.  Works like the zip() function but consumes less memory by returning an iterator instead of a list.     Methods defined here: __getattribute__(...) x.__getattribute__('name') <==> x.name __iter__(...) x.__iter__() <==> iter(x) next(...) x.next() -> the next value, or raise StopIteration Data and other attributes defined here: __new__ = <built-in method __new__ of type object> T.__new__(S, ...) -> a new object with type S, a subtype of T   class izip_longest(__builtin__.object)     izip_longest(iter1 [,iter2 [...]], [fillvalue=None]) --> izip_longest object   Return an izip_longest object whose .next() method returns a tuple where the i-th element comes from the i-th iterable argument.  The .next() method continues until the longest iterable in the argument sequence is exhausted and then it raises StopIteration.  When the shorter iterables are exhausted, the fillvalue is substituted in their place.  The fillvalue defaults to None or can be specified by a keyword argument.     Methods defined here: __getattribute__(...) x.__getattribute__('name') <==> x.name __iter__(...) x.__iter__() <==> iter(x) next(...) x.next() -> the next value, or raise StopIteration Data and other attributes defined here: __new__ = <built-in method __new__ of type object> T.__new__(S, ...) -> a new object with type S, a subtype of T   class permutations(__builtin__.object)     permutations(iterable[, r]) --> permutations object   Return successive r-length permutations of elements in the iterable.   permutations(range(3), 2) --> (0,1), (0,2), (1,0), (1,2), (2,0), (2,1)     Methods defined here: __getattribute__(...) x.__getattribute__('name') <==> x.name __iter__(...) x.__iter__() <==> iter(x) next(...) x.next() -> the next value, or raise StopIteration Data and other attributes defined here: __new__ = <built-in method __new__ of type object> T.__new__(S, ...) -> a new object with type S, a subtype of T   class product(__builtin__.object)     product(*iterables) --> product object   Cartesian product of input iterables.  Equivalent to nested for-loops.   For example, product(A, B) returns the same as:  ((x,y) for x in A for y in B). The leftmost iterators are in the outermost for-loop, so the output tuples cycle in a manner similar to an odometer (with the rightmost element changing on every iteration).   To compute the product of an iterable with itself, specify the number of repetitions with the optional repeat keyword argument. For example, product(A, repeat=4) means the same as product(A, A, A, A).   product('ab', range(3)) --> ('a',0) ('a',1) ('a',2) ('b',0) ('b',1) ('b',2) product((0,1), (0,1), (0,1)) --> (0,0,0) (0,0,1) (0,1,0) (0,1,1) (1,0,0) ...     Methods defined here: __getattribute__(...) x.__getattribute__('name') <==> x.name __iter__(...) x.__iter__() <==> iter(x) next(...) x.next() -> the next value, or raise StopIteration Data and other attributes defined here: __new__ = <built-in method __new__ of type object> T.__new__(S, ...) -> a new object with type S, a subtype of T   class repeat(__builtin__.object)     repeat(object [,times]) -> create an iterator which returns the object for the specified number of times.  If not specified, returns the object endlessly.     Methods defined here: __getattribute__(...) x.__getattribute__('name') <==> x.name __iter__(...) x.__iter__() <==> iter(x) __length_hint__(...) Private method returning an estimate of len(list(it)). __repr__(...) x.__repr__() <==> repr(x) next(...) x.next() -> the next value, or raise StopIteration Data and other attributes defined here: __new__ = <built-in method __new__ of type object> T.__new__(S, ...) -> a new object with type S, a subtype of T   class starmap(__builtin__.object)     starmap(function, sequence) --> starmap object   Return an iterator whose values are returned from the function evaluated with a argument tuple taken from the given sequence.     Methods defined here: __getattribute__(...) x.__getattribute__('name') <==> x.name __iter__(...) x.__iter__() <==> iter(x) next(...) x.next() -> the next value, or raise StopIteration Data and other attributes defined here: __new__ = <built-in method __new__ of type object> T.__new__(S, ...) -> a new object with type S, a subtype of T   class takewhile(__builtin__.object)     takewhile(predicate, iterable) --> takewhile object   Return successive entries from an iterable as long as the  predicate evaluates to true for each entry.     Methods defined here: __getattribute__(...) x.__getattribute__('name') <==> x.name __iter__(...) x.__iter__() <==> iter(x) next(...) x.next() -> the next value, or raise StopIteration Data and other attributes defined here: __new__ = <built-in method __new__ of type object> T.__new__(S, ...) -> a new object with type S, a subtype of T

Functions
		tee(...) tee(iterable, n=2) --> tuple of n independent iterators.