cpython/Objects/enumobject.c

/* enumerate object */

#include "Python.h"
#include "pycore_call.h"          // _PyObject_CallNoArgs()
#include "pycore_long.h"          // _PyLong_GetOne()
#include "pycore_modsupport.h"    // _PyArg_NoKwnames()
#include "pycore_object.h"        // _PyObject_GC_TRACK()

#include "clinic/enumobject.c.h"

/*[clinic input]
class enumerate "enumobject *" "&PyEnum_Type"
class reversed "reversedobject *" "&PyReversed_Type"
[clinic start generated code]*/
/*[clinic end generated code: output=da39a3ee5e6b4b0d input=d2dfdf1a88c88975]*/

enumobject;


/*[clinic input]
@classmethod
enumerate.__new__ as enum_new

    iterable: object
        an object supporting iteration
    start: object = 0

Return an enumerate object.

The enumerate object yields pairs containing a count (from start, which
defaults to zero) and a value yielded by the iterable argument.

enumerate is useful for obtaining an indexed list:
    (0, seq[0]), (1, seq[1]), (2, seq[2]), ...
[clinic start generated code]*/

static PyObject *
enum_new_impl(PyTypeObject *type, PyObject *iterable, PyObject *start)
/*[clinic end generated code: output=e95e6e439f812c10 input=782e4911efcb8acf]*/
{ … }

static int check_keyword(PyObject *kwnames, int index,
                         const char *name)
{ … }

// TODO: Use AC when bpo-43447 is supported
static PyObject *
enumerate_vectorcall(PyObject *type, PyObject *const *args,
                     size_t nargsf, PyObject *kwnames)
{ … }

static void
enum_dealloc(enumobject *en)
{ … }

static int
enum_traverse(enumobject *en, visitproc visit, void *arg)
{ … }

static PyObject *
enum_next_long(enumobject *en, PyObject* next_item)
{ … }

static PyObject *
enum_next(enumobject *en)
{ … }

static PyObject *
enum_reduce(enumobject *en, PyObject *Py_UNUSED(ignored))
{ … }

PyDoc_STRVAR(reduce_doc, "Return state information for pickling.");

static PyMethodDef enum_methods[] = …;

PyTypeObject PyEnum_Type = …;

/* Reversed Object ***************************************************************/

reversedobject;

/*[clinic input]
@classmethod
reversed.__new__ as reversed_new

    sequence as seq: object
    /

Return a reverse iterator over the values of the given sequence.
[clinic start generated code]*/

static PyObject *
reversed_new_impl(PyTypeObject *type, PyObject *seq)
/*[clinic end generated code: output=f7854cc1df26f570 input=aeb720361e5e3f1d]*/
{ … }

static PyObject *
reversed_vectorcall(PyObject *type, PyObject * const*args,
                size_t nargsf, PyObject *kwnames)
{ … }

static void
reversed_dealloc(reversedobject *ro)
{ … }

static int
reversed_traverse(reversedobject *ro, visitproc visit, void *arg)
{ … }

static PyObject *
reversed_next(reversedobject *ro)
{ … }

static PyObject *
reversed_len(reversedobject *ro, PyObject *Py_UNUSED(ignored))
{ … }

PyDoc_STRVAR(length_hint_doc, "Private method returning an estimate of len(list(it)).");

static PyObject *
reversed_reduce(reversedobject *ro, PyObject *Py_UNUSED(ignored))
{ … }

static PyObject *
reversed_setstate(reversedobject *ro, PyObject *state)
{ … }

PyDoc_STRVAR(setstate_doc, "Set state information for unpickling.");

static PyMethodDef reversediter_methods[] = …;

PyTypeObject PyReversed_Type = …;