data when and where needed instead of consuming memory with the
computer equivalent of ``inventory''.
-Some tools were omitted from the module because they offered no
-advantage over their pure python counterparts or because their behavior
-was too surprising.
-
-For instance, SML provides a tool: \code{cycle(\var{seq})} which
-loops over the sequence elements and then starts again when the
-sequence is exhausted. The surprising behavior is the need for
-significant auxiliary storage (which is unusual for an iterator).
-If needed, the tool is readily constructible using pure Python.
-
-Other tools are being considered for inclusion in future versions of the
-module. For instance, the function
-\function{chain(\var{it0}, \var{it1}, ...)} would return elements from
-the first iterator until it was exhausted and then move on to each
-successive iterator. The module author welcomes suggestions for other
-basic building blocks.
+The module author welcomes suggestions for other basic building blocks
+to be added to future versions of the module.
\begin{seealso}
\seetext{The Standard ML Basis Library,
Some provide streams of infinite length, so they should only be accessed
by functions or loops that truncate the stream.
+\begin{funcdesc}{chain}{*iterables}
+ Make an iterator that returns elements from the first iterable until
+ it is exhausted, then proceeds to the next iterable, until all of the
+ iterables are exhausted. Used for treating consecutive sequences as
+ a single sequence. Equivalent to:
+
+ \begin{verbatim}
+ def chain(*iterables):
+ for it in iterables:
+ for element in it:
+ yield element
+ \end{verbatim}
+\end{funcdesc}
+
\begin{funcdesc}{count}{\optional{n}}
Make an iterator that returns consecutive integers starting with \var{n}.
Does not currently support python long integers. Often used as an
may change in the future.
\end{funcdesc}
+\begin{funcdesc}{cycle}{iterable}
+ Make an iterator returning elements from the iterable and saving a
+ copy of each. When the iterable is exhausted, return elements from
+ the saved copy. Repeats indefinitely. Equivalent to:
+
+ \begin{verbatim}
+ def cycle(iterable):
+ saved = []
+ for element in iterable:
+ yield element
+ saved.append(element)
+ if len(saved) == 0:
+ return
+ while True:
+ for element in saved:
+ yield element
+ \end{verbatim}
+
+ Note, this is the only member of the toolkit that may require
+ significant auxiliary storage (depending on the length of the
+ iterable.
+\end{funcdesc}
+
\begin{funcdesc}{dropwhile}{predicate, iterable}
Make an iterator that drops elements from the iterable as long as
the predicate is true; afterwards, returns every element. Note,
\end{verbatim}
\end{funcdesc}
-\begin{funcdesc}{repeat}{object}
+\begin{funcdesc}{repeat}{object\optional{, times}}
Make an iterator that returns \var{object} over and over again.
+ Runs indefinitely unless the \var{times} argument is specified.
Used as argument to \function{imap()} for invariant parameters
to the called function. Also used with \function{izip()} to create
an invariant part of a tuple record. Equivalent to:
\begin{verbatim}
- def repeat(object):
- while True:
- yield object
+ def repeat(object, times=None):
+ if times is None:
+ while True:
+ yield object
+ else:
+ for i in xrange(times):
+ yield object
\end{verbatim}
\end{funcdesc}
\end{verbatim}
\end{funcdesc}
-\begin{funcdesc}{times}{n, \optional{object}}
- Make an iterator that returns \var{object} \var{n} times.
- \var{object} defaults to \code{None}. Used for looping a specific
- number of times without creating a number object on each pass.
- Equivalent to:
-
- \begin{verbatim}
- def times(n, object=None):
- if n<0 : raise ValueError
- for i in xrange(n):
- yield object
- \end{verbatim}
-\end{funcdesc}
-
\subsection{Examples \label{itertools-example}}
demonstrate ways they can be combined.
\begin{verbatim}
->>> for i in times(3):
-... print "Hello"
-...
-Hello
-Hello
-Hello
>>> amounts = [120.15, 764.05, 823.14]
>>> for checknum, amount in izip(count(1200), amounts):
... "Returns True if pred(x) is False for every element in the iterable"
... return not nth(ifilter(pred, seq), 0)
+>>> def pairwise(seq):
+... "s -> (s0,s1), (s1,s2), (s2, s3), ..."
+... return izip(seq, islice(seq,1,len(seq)))
+
\end{verbatim}
import sys
class TestBasicOps(unittest.TestCase):
+ def test_chain(self):
+ self.assertEqual(list(chain('abc', 'def')), list('abcdef'))
+
def test_count(self):
self.assertEqual(zip('abc',count()), [('a', 0), ('b', 1), ('c', 2)])
self.assertEqual(zip('abc',count(3)), [('a', 3), ('b', 4), ('c', 5)])
self.assertRaises(TypeError, count, 2, 3)
+ def test_cycle(self):
+ self.assertEqual(list(islice(cycle('abc'),10)), list('abcabcabca'))
+ self.assertEqual(list(cycle('')), [])
+
def test_ifilter(self):
def isEven(x):
return x%2==0
def test_repeat(self):
self.assertEqual(zip(xrange(3),repeat('a')),
[(0, 'a'), (1, 'a'), (2, 'a')])
+ self.assertEqual(list(repeat('a', 3)), ['a', 'a', 'a'])
self.assertRaises(TypeError, repeat)
- def test_times(self):
- self.assertEqual(list(times(3)), [None]*3)
- self.assertEqual(list(times(3, True)), [True]*3)
- self.assertRaises(ValueError, times, -1)
-
def test_imap(self):
import operator
self.assertEqual(list(imap(operator.pow, range(3), range(1,7))),
libreftest = """ Doctest for examples in the library reference, libitertools.tex
->>> for i in times(3):
-... print "Hello"
-...
-Hello
-Hello
-Hello
>>> amounts = [120.15, 764.05, 823.14]
>>> for checknum, amount in izip(count(1200), amounts):
... "Returns True if pred(x) is False for every element in the iterable"
... return not nth(ifilter(pred, seq), 0)
+>>> def pairwise(seq):
+... "s -> (s0,s1), (s1,s2), (s2, s3), ..."
+... return izip(seq, islice(seq,1,len(seq)))
+
"""
__test__ = {'libreftest' : libreftest}
All rights reserved.
*/
+/* cycle object **********************************************************/
+
+typedef struct {
+ PyObject_HEAD
+ PyObject *it;
+ PyObject *saved;
+ int firstpass;
+} cycleobject;
+
+PyTypeObject cycle_type;
+
+static PyObject *
+cycle_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+ PyObject *it;
+ PyObject *iterable;
+ PyObject *saved;
+ cycleobject *lz;
+
+ if (!PyArg_UnpackTuple(args, "cycle", 1, 1, &iterable))
+ return NULL;
+
+ /* Get iterator. */
+ it = PyObject_GetIter(iterable);
+ if (it == NULL)
+ return NULL;
+
+ saved = PyList_New(0);
+ if (saved == NULL) {
+ Py_DECREF(it);
+ return NULL;
+ }
+
+ /* create cycleobject structure */
+ lz = (cycleobject *)type->tp_alloc(type, 0);
+ if (lz == NULL) {
+ Py_DECREF(it);
+ Py_DECREF(saved);
+ return NULL;
+ }
+ lz->it = it;
+ lz->saved = saved;
+ lz->firstpass = 0;
+
+ return (PyObject *)lz;
+}
+
+static void
+cycle_dealloc(cycleobject *lz)
+{
+ PyObject_GC_UnTrack(lz);
+ Py_XDECREF(lz->saved);
+ Py_XDECREF(lz->it);
+ lz->ob_type->tp_free(lz);
+}
+
+static int
+cycle_traverse(cycleobject *lz, visitproc visit, void *arg)
+{
+ int err;
+
+ if (lz->it) {
+ err = visit(lz->it, arg);
+ if (err)
+ return err;
+ }
+ if (lz->saved) {
+ err = visit(lz->saved, arg);
+ if (err)
+ return err;
+ }
+ return 0;
+}
+
+static PyObject *
+cycle_next(cycleobject *lz)
+{
+ PyObject *item;
+ PyObject *it;
+
+ while (1) {
+ item = PyIter_Next(lz->it);
+ if (item != NULL) {
+ if (!lz->firstpass)
+ PyList_Append(lz->saved, item);
+ return item;
+ }
+ if (PyList_Size(lz->saved) == 0)
+ return NULL;
+ it = PyObject_GetIter(lz->saved);
+ if (it == NULL)
+ return NULL;
+ Py_DECREF(lz->it);
+ lz->it = it;
+ lz->firstpass = 1;
+ }
+}
+
+static PyObject *
+cycle_getiter(PyObject *lz)
+{
+ Py_INCREF(lz);
+ return lz;
+}
+
+PyDoc_STRVAR(cycle_doc,
+"cycle(iterable) --> cycle object\n\
+\n\
+Return elements from the iterable until it is exhausted.\n\
+Then repeat the sequence indefinitely.");
+
+PyTypeObject cycle_type = {
+ PyObject_HEAD_INIT(NULL)
+ 0, /* ob_size */
+ "itertools.cycle", /* tp_name */
+ sizeof(cycleobject), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ /* methods */
+ (destructor)cycle_dealloc, /* tp_dealloc */
+ 0, /* tp_print */
+ 0, /* tp_getattr */
+ 0, /* tp_setattr */
+ 0, /* tp_compare */
+ 0, /* tp_repr */
+ 0, /* tp_as_number */
+ 0, /* tp_as_sequence */
+ 0, /* tp_as_mapping */
+ 0, /* tp_hash */
+ 0, /* tp_call */
+ 0, /* tp_str */
+ PyObject_GenericGetAttr, /* tp_getattro */
+ 0, /* tp_setattro */
+ 0, /* tp_as_buffer */
+ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
+ Py_TPFLAGS_BASETYPE, /* tp_flags */
+ cycle_doc, /* tp_doc */
+ (traverseproc)cycle_traverse, /* tp_traverse */
+ 0, /* tp_clear */
+ 0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ (getiterfunc)cycle_getiter, /* tp_iter */
+ (iternextfunc)cycle_next, /* tp_iternext */
+ 0, /* tp_methods */
+ 0, /* tp_members */
+ 0, /* tp_getset */
+ 0, /* tp_base */
+ 0, /* tp_dict */
+ 0, /* tp_descr_get */
+ 0, /* tp_descr_set */
+ 0, /* tp_dictoffset */
+ 0, /* tp_init */
+ PyType_GenericAlloc, /* tp_alloc */
+ cycle_new, /* tp_new */
+ PyObject_GC_Del, /* tp_free */
+};
+
+
/* dropwhile object **********************************************************/
typedef struct {
};
-/* times object ************************************************************/
+/* chain object ************************************************************/
typedef struct {
PyObject_HEAD
- PyObject *obj;
- long cnt;
-} timesobject;
+ long tuplesize;
+ long iternum; /* which iterator is active */
+ PyObject *ittuple; /* tuple of iterators */
+} chainobject;
-PyTypeObject times_type;
+PyTypeObject chain_type;
static PyObject *
-times_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+chain_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
- timesobject *lz;
- PyObject *obj = Py_None;
- long cnt;
-
- if (!PyArg_ParseTuple(args, "l|O:times", &cnt, &obj))
- return NULL;
+ chainobject *lz;
+ int tuplesize = PySequence_Length(args);
+ int i;
+ PyObject *ittuple;
- if (cnt < 0) {
- PyErr_SetString(PyExc_ValueError,
- "count for times() cannot be negative.");
+ /* obtain iterators */
+ assert(PyTuple_Check(args));
+ ittuple = PyTuple_New(tuplesize);
+ if(ittuple == NULL)
return NULL;
+ for (i=0; i < tuplesize; ++i) {
+ PyObject *item = PyTuple_GET_ITEM(args, i);
+ PyObject *it = PyObject_GetIter(item);
+ if (it == NULL) {
+ if (PyErr_ExceptionMatches(PyExc_TypeError))
+ PyErr_Format(PyExc_TypeError,
+ "chain argument #%d must support iteration",
+ i+1);
+ Py_DECREF(ittuple);
+ return NULL;
+ }
+ PyTuple_SET_ITEM(ittuple, i, it);
}
- /* create timesobject structure */
- lz = (timesobject *)type->tp_alloc(type, 0);
+ /* create chainobject structure */
+ lz = (chainobject *)type->tp_alloc(type, 0);
if (lz == NULL)
return NULL;
- lz->cnt = cnt;
- Py_INCREF(obj);
- lz->obj = obj;
+
+ lz->ittuple = ittuple;
+ lz->iternum = 0;
+ lz->tuplesize = tuplesize;
return (PyObject *)lz;
}
static void
-times_dealloc(timesobject *lz)
+chain_dealloc(chainobject *lz)
{
PyObject_GC_UnTrack(lz);
- Py_XDECREF(lz->obj);
+ Py_XDECREF(lz->ittuple);
lz->ob_type->tp_free(lz);
}
static int
-times_traverse(timesobject *lz, visitproc visit, void *arg)
+chain_traverse(chainobject *lz, visitproc visit, void *arg)
{
- if (lz->obj)
- return visit(lz->obj, arg);
+ if (lz->ittuple)
+ return visit(lz->ittuple, arg);
return 0;
}
static PyObject *
-times_next(timesobject *lz)
+chain_next(chainobject *lz)
{
- PyObject *obj = lz->obj;
+ PyObject *it;
+ PyObject *item;
- if (lz->cnt > 0) {
- lz->cnt--;
- Py_INCREF(obj);
- return obj;
+ while (lz->iternum < lz->tuplesize) {
+ it = PyTuple_GET_ITEM(lz->ittuple, lz->iternum);
+ item = PyIter_Next(it);
+ if (item != NULL)
+ return item;
+ lz->iternum++;
}
return NULL;
}
static PyObject *
-times_getiter(PyObject *lz)
+chain_getiter(PyObject *lz)
{
Py_INCREF(lz);
return lz;
}
-PyDoc_STRVAR(times_doc,
-"times(n [,obj]) --> times object\n\
+PyDoc_STRVAR(chain_doc,
+"chain(*iterables) --> chain object\n\
\n\
-Return a times object whose .next() method returns n consecutive\n\
-instances of obj (default is None).");
+Return a chain object whose .next() method returns elements from the\n\
+first iterable until it is exhausted, then elements from the next\n\
+iterable, until all of the iterables are exhausted.");
-PyTypeObject times_type = {
+PyTypeObject chain_type = {
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
- "itertools.times", /* tp_name */
- sizeof(timesobject), /* tp_basicsize */
+ "itertools.chain", /* tp_name */
+ sizeof(chainobject), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
- (destructor)times_dealloc, /* tp_dealloc */
+ (destructor)chain_dealloc, /* tp_dealloc */
0, /* tp_print */
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
Py_TPFLAGS_BASETYPE, /* tp_flags */
- times_doc, /* tp_doc */
- (traverseproc)times_traverse, /* tp_traverse */
+ chain_doc, /* tp_doc */
+ (traverseproc)chain_traverse, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
- (getiterfunc)times_getiter, /* tp_iter */
- (iternextfunc)times_next, /* tp_iternext */
+ (getiterfunc)chain_getiter, /* tp_iter */
+ (iternextfunc)chain_next, /* tp_iternext */
0, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_dictoffset */
0, /* tp_init */
PyType_GenericAlloc, /* tp_alloc */
- times_new, /* tp_new */
+ chain_new, /* tp_new */
PyObject_GC_Del, /* tp_free */
};
typedef struct {
PyObject_HEAD
PyObject *element;
+ long cnt;
} repeatobject;
PyTypeObject repeat_type;
{
repeatobject *ro;
PyObject *element;
+ long cnt = -1;
- if (!PyArg_UnpackTuple(args, "repeat", 1, 1, &element))
+ if (!PyArg_ParseTuple(args, "O|l:repeat", &element, &cnt))
return NULL;
ro = (repeatobject *)type->tp_alloc(type, 0);
return NULL;
Py_INCREF(element);
ro->element = element;
+ ro->cnt = cnt;
return (PyObject *)ro;
}
static PyObject *
repeat_next(repeatobject *ro)
{
+ if (ro->cnt == 0)
+ return NULL;
+ if (ro->cnt > 0)
+ ro->cnt--;
Py_INCREF(ro->element);
return ro->element;
}
}
PyDoc_STRVAR(repeat_doc,
-"repeat(element) -> create an iterator which returns the element endlessly.");
+"repeat(element [,times]) -> create an iterator which returns the element\n\
+for the specified number of times. If not specified, returns the element\n\
+endlessly.");
PyTypeObject repeat_type = {
PyObject_HEAD_INIT(NULL)
\n\
Infinite iterators:\n\
count([n]) --> n, n+1, n+2, ...\n\
-repeat(elem) --> elem, elem, elem, ...\n\
+cycle(p) --> p0, p1, ... plast, p0, p1, ...\n\
+repeat(elem [,n]) --> elem, elem, elem, ... endlessly or upto n times\n\
\n\
Iterators terminating on the shortest input sequence:\n\
izip(p, q, ...) --> (p[0], q[0]), (p[1], q[1]), ... \n\
seq[start:stop:step]\n\
imap(fun, p, q, ...) --> fun(p0, q0), fun(p1, q1), ...\n\
starmap(fun, seq) --> fun(*seq[0]), fun(*seq[1]), ...\n\
-times(n, [obj]) --> obj, obj, ... for n times. obj defaults to None\n\
+chain(p, q, ...) --> p0, p1, ... plast, q0, q1, ... \n\
takewhile(pred, seq) --> seq[0], seq[1], until pred fails\n\
dropwhile(pred, seq) --> seq[n], seq[n+1], starting when pred fails\n\
");
PyObject *m;
char *name;
PyTypeObject *typelist[] = {
+ &cycle_type,
&dropwhile_type,
&takewhile_type,
&islice_type,
&starmap_type,
&imap_type,
- ×_type,
+ &chain_type,
&ifilter_type,
&ifilterfalse_type,
&count_type,
if (PyType_Ready(typelist[i]) < 0)
return;
name = strchr(typelist[i]->tp_name, '.') + 1;
- if (name == NULL)
- return;
+ assert (name != NULL);
Py_INCREF(typelist[i]);
PyModule_AddObject(m, name, (PyObject *)typelist[i]);
}
projects / python / commitdiff