(sequence protocol)

int PySequence_Check(PyObject *o)

Return 1 if the object provides sequence protocol, and 0 otherwise. This function always succeeds.

Py_ssize_t PySequence_Size(PyObject *o)

Py_ssize_t PySequence_Length(PyObject *o)

o -1 Python len(o)

PyObject* PySequence_Concat(PyObject *o1, PyObject *o2)

Return value: New reference.

o1 o2 (concatenation) NULL Python o1 + o2

PyObject* PySequence_Repeat(PyObject *o, Py_ssize_t count)

Return value: New reference.

o count NULL Python o * count

PyObject* PySequence_InPlaceConcat(PyObject *o1, PyObject *o2)

Return value: New reference.

o1 o2 (concatenation) NULL o1 in-place in-place Python o1 += o2

PyObject* PySequence_InPlaceRepeat(PyObject *o, Py_ssize_t count)

Return value: New reference.

o count NULL o in-place in-place Python o *= count

PyObject* PySequence_GetItem(PyObject *o, Py_ssize_t i)

Return value: New reference.

o i NULL Python o[i]

PyObject* PySequence_GetSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2)

Return value: New reference.

o i1 i2 NULL Python o[i1:i2]

int PySequence_SetItem(PyObject *o, Py_ssize_t i, PyObject *v)

o i v -1 ; 0 Python o[i] = v v

v NULL PyObject_DelAttr()

int PySequence_DelItem(PyObject *o, Py_ssize_t i)

o i -1 Python del o[i]

int PySequence_SetSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2, PyObject *v)

o i1 i2 v Python o[i1:i2] = v

int PySequence_DelSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2)

o i1 i2 -1 Python del o[i1:i2]

Py_ssize_t PySequence_Count(PyObject *o, PyObject *value)

o value o[key] == value key -1 Python o.count(value)

int PySequence_Contains(PyObject *o, PyObject *value)

o value o value (equal) 1 0 -1 Python value in o

Py_ssize_t PySequence_Index(PyObject *o, PyObject *value)

o[i] == value i -1 Python o.index(value)

PyObject* PySequence_List(PyObject *o)

Return value: New reference.

o NULL Python list(o)

PyObject* PySequence_Tuple(PyObject *o)

Return value: New reference.

Return a tuple object with the same contents as the arbitrary sequence o or NULL on failure. If o is a tuple, a new reference will be returned, otherwise a tuple will be constructed with the appropriate contents. This is equivalent to the Python expression tuple(o).

PyObject* PySequence_Fast(PyObject *o, const char *m)

Return value: New reference.

Return the sequence o as a list, unless it is already a tuple or list, in which case o is returned. Use PySequence_Fast_GET_ITEM() to access the members of the result. Returns NULL on failure. If the object is not a sequence, raises TypeError with m as the message text.

PyObject* PySequence_Fast_GET_ITEM(PyObject *o, Py_ssize_t i)

Return value: Borrowed reference.

o NULL PySequence_Fast() i o i

PyObject** PySequence_Fast_ITEMS(PyObject *o)

PyObject o PySequence_Fast() NULL

PyObject* PySequence_ITEM(PyObject *o, Py_ssize_t i)

Return value: New reference.

o i NULL PySequence_GetItem() o PySequence_Check()

Py_ssize_t PySequence_Fast_GET_SIZE(PyObject *o)

o NULL PySequence_Fast() o o PySequence_Size() PySequence_Fast_GET_SIZE() o