Protocolo de secuencia
**********************

int PySequence_Check(PyObject *o)

   Retorna "1" si el objeto proporciona el protocolo de secuencia y
   "0" en caso contrario. Tenga en cuenta que retorna "1" para las
   clases de Python con un método "__getitem__()" a menos que sean:
   subclases "dict" ya que en general es imposible determinar qué tipo
   de claves admite. Esta función siempre tiene éxito.

Py_ssize_t PySequence_Size(PyObject *o)
Py_ssize_t PySequence_Length(PyObject *o)

   Retorna el número de objetos en secuencia *o* en caso de éxito y
   "-1" en caso de error. Esto es equivalente a la expresión de Python
   "len(o)".

PyObject* PySequence_Concat(PyObject *o1, PyObject *o2)
    *Return value: New reference.*

   Retorna la concatenación de *o1* y *o2* en caso de éxito, y "NULL"
   en caso de error. Este es el equivalente de la expresión de Python
   "o1+o2".

PyObject* PySequence_Repeat(PyObject *o, Py_ssize_t count)
    *Return value: New reference.*

   Retorna el resultado de repetir el objeto de secuencia *o* *count*
   veces, o "NULL" en caso de falla. Este es el equivalente de la
   expresión de Python "o*count".

PyObject* PySequence_InPlaceConcat(PyObject *o1, PyObject *o2)
    *Return value: New reference.*

   Retorna la concatenación de *o1* y *o2* en caso de éxito, y "NULL"
   en caso de error. La operación se realiza en su lugar *in-place*
   cuando *o1* lo admite. Este es el equivalente de la expresión de
   Python "o1+=o2".

PyObject* PySequence_InPlaceRepeat(PyObject *o, Py_ssize_t count)
    *Return value: New reference.*

   Retorna el resultado de repetir el objeto de secuencia *o* *count*
   veces, o "NULL" en caso de falla. La operación se realiza en su
   lugar (*in-place*) cuando *o* lo admite. Este es el equivalente de
   la expresión de Python "o*=count".

PyObject* PySequence_GetItem(PyObject *o, Py_ssize_t i)
    *Return value: New reference.*

   Retorna el elemento *i*-ésimo de *o* o "NULL" en caso de error.
   Este es el equivalente de la expresión de Python "o[i]".

PyObject* PySequence_GetSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2)
    *Return value: New reference.*

   Retorna la rebanada del objeto secuencia *o* entre *i1* y *i2*, o
   "NULL" en caso de error. Este es el equivalente de la expresión de
   Python "o[i1:i2]".

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

   Asigna el objeto *v* al elemento *i*-ésimo de *o*. Lanza una
   excepción y retorna "-1" en caso de falla; retorna "0" en caso de
   éxito. Este es el equivalente de la declaración de Python "o[i]=v".
   Esta función *no* roba una referencia a *v*.

   Si *v* es "NULL", el elemento se elimina, sin embargo, esta
   característica está en desuso a favor del uso de
   "PySequence_DelItem()".

int PySequence_DelItem(PyObject *o, Py_ssize_t i)

   Elimina el elemento *i*-ésimo del objeto *o*. Retorna "-1" en caso
   de falla. Este es el equivalente de la declaración de Python "del
   o[i]".

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

   Asigna el objeto secuencia *v* al segmento en el objeto secuencia
   *o* de *i1* a *i2*. Este es el equivalente de la declaración de
   Python "o[i1:i2]=v".

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

   Elimina el segmento en el objeto secuencia *o* de *i1* a *i2*.
   Retorna "-1" en caso de falla. Este es el equivalente de la
   declaración de Python "del o[i1:i2]".

Py_ssize_t PySequence_Count(PyObject *o, PyObject *value)

   Retorna el número de apariciones de *value* en *o*, es decir,
   retorna el número de claves para las que "o[clave]==value". En caso
   de fallo, retorna "-1". Esto es equivalente a la expresión de
   Python "o.count(value)".

int PySequence_Contains(PyObject *o, PyObject *value)

   Determine si *o* contiene *valor*. Si un elemento en *o* es igual a
   *value*, retorna "1"; de lo contrario, retorna "0". En caso de
   error, retorna "-1". Esto es equivalente a la expresión de Python
   "value in o".

Py_ssize_t PySequence_Index(PyObject *o, PyObject *value)

   Retorna el primer índice *i* para el que "o[i]==value". En caso de
   error, retorna "-1". Esto es equivalente a la expresión de Python
   "o.index(value)".

PyObject* PySequence_List(PyObject *o)
    *Return value: New reference.*

   Retorna un objeto lista con el mismo contenido que la secuencia o
   iterable *o*, o "NULL" en caso de error. La lista retornada está
   garantizada como nueva. Esto es equivalente a la expresión de
   Python "list(o)".

PyObject* PySequence_Tuple(PyObject *o)
    *Return value: New reference.*

   Retorna un objeto tupla con el mismo contenido que la secuencia o
   iterable *o*, o "NULL" en caso de error. Si *o* es una tupla, se
   retornará una nueva referencia; de lo contrario, se construirá una
   tupla con el contenido apropiado. Esto es equivalente a la
   expresión de Python "tupla(o)".

PyObject* PySequence_Fast(PyObject *o, const char *m)
    *Return value: New reference.*

   Retorna la secuencia o iterable *o* como un objeto utilizable por
   la otra familia de funciones "PySequence_Fast*". Si el objeto no es
   una secuencia o no es iterable, lanza "TypeError" con *m* como
   texto del mensaje. Retorna "NULL" en caso de falla.

   Las funciones "PySequence_Fast*" se denominan así porque suponen
   que *o* es un "PyTupleObject" o un "PyListObject" y acceden a los
   campos de datos de *o* directamente.

   Como detalle de implementación de CPython, si *o* ya es una
   secuencia o lista, se retornará.

Py_ssize_t PySequence_Fast_GET_SIZE(PyObject *o)

   Retorna la longitud de *o*, suponiendo que *o* fue retornado por
   "PySequence_Fast()" y que *o* no es "NULL". El tamaño también se
   puede obtener llamando a "PySequence_Size()" en *o*, pero
   "PySequence_Fast_GET_SIZE()" es más rápido porque puede suponer que
   *o* es una lista o tupla.

PyObject* PySequence_Fast_GET_ITEM(PyObject *o, Py_ssize_t i)
    *Return value: Borrowed reference.*

   Retorna el elemento *i*-ésimo de *o*, suponiendo que *o* haya sido
   retornado por "PySequence_Fast()", *o* no es "NULL" y que *i* está
   dentro de los límites.

PyObject** PySequence_Fast_ITEMS(PyObject *o)

   Retorna el arreglo subyacente de punteros *PyObject*. Asume que *o*
   fue retornado por "PySequence_Fast()" y *o* no es "NULL".

   Tenga en cuenta que si una lista cambia de tamaño, la reasignación
   puede reubicar el arreglo de elementos. Por lo tanto, solo use el
   puntero de arreglo subyacente en contextos donde la secuencia no
   puede cambiar.

PyObject* PySequence_ITEM(PyObject *o, Py_ssize_t i)
    *Return value: New reference.*

   Retorna el elemento *i*-ésimo de *o* o "NULL" en caso de error. Es
   la forma más rápida de "PySequence_GetItem()" pero sin verificar
   que "PySequence_Check()" en *o* es verdadero y sin ajuste para
   índices negativos.
