itertools
index
/usr/local/lib/python2.4/lib-dynload/itertools.so
Module Docs

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:
izip(p, q, ...) --> (p[0], q[0]), (p[1], q[1]), ... 
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
chain(p, q, ...) --> p0, p1, ... plast, q0, q1, ... 
takewhile(pred, seq) --> seq[0], seq[1], until pred fails
dropwhile(pred, seq) --> seq[n], seq[n+1], starting when pred fails
groupby(iterable[, keyfunc]) --> sub-iterators grouped by value of keyfunc(v)

 
Classes
       
__builtin__.object
chain
count
cycle
dropwhile
groupby
ifilter
ifilterfalse
imap
islice
izip
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)
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([firstval]) --> count object
 
Return a count object whose .next() method returns consecutive
integers starting from zero or, if specified, from firstval.
 
  Methods defined here:
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__iter__(...)
x.__iter__() <==> iter(x)
__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 repeat(__builtin__.object)
    repeat(element [,times]) -> create an iterator which returns the element
for the specified number of times.  If not specified, returns the element
endlessly.
 
  Methods defined here:
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__iter__(...)
x.__iter__() <==> iter(x)
__len__(...)
x.__len__() <==> len(x)
__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.