Objetos Tuplas
**************

PyTupleObject

   Este subtipo de "PyObject" representa un objeto tupla de Python.

PyTypeObject PyTuple_Type

   Esta instancia de "PyTypeObject" representa el tipo tupla de
   Python; es el mismo objeto que "tuple" en la capa de Python.

int PyTuple_Check(PyObject *p)

   Retorna verdadero si *p* es un objeto tupla o una instancia de un
   subtipo del tipo tupla.

int PyTuple_CheckExact(PyObject *p)

   Retorna verdadero si *p* es un objeto tupla pero no una instancia
   de un subtipo del tipo tupla.

PyObject* PyTuple_New(Py_ssize_t len)
    *Return value: New reference.*

   Retorna un nuevo objeto tupla de tamaño *len* o "NULL" en caso de
   falla.

PyObject* PyTuple_Pack(Py_ssize_t n, ...)
    *Return value: New reference.*

   Retorna un nuevo objeto tupla de tamaño *n*, o "NULL" en caso de
   falla. Los valores de tupla se inicializan en los argumentos C
   posteriores *n* que apuntan a objetos de Python. "PyTuple_Pack (2,
   a, b)" es equivalente a "Py_BuildValue("(OO)", a, b)".

Py_ssize_t PyTuple_Size(PyObject *p)

   Toma un puntero a un objeto de tupla y retorna el tamaño de esa
   tupla.

Py_ssize_t PyTuple_GET_SIZE(PyObject *p)

   Retorna el tamaño de la tupla *p*, que no debe ser "NULL" y apunta
   a una tupla; No se realiza ninguna comprobación de errores.

PyObject* PyTuple_GetItem(PyObject *p, Py_ssize_t pos)
    *Return value: Borrowed reference.*

   Retorna el objeto en la posición *pos* en la tupla señalada por
   *p*. Si *pos* está fuera de los límites, retorna "NULL" y establece
   una excepción "IndexError".

PyObject* PyTuple_GET_ITEM(PyObject *p, Py_ssize_t pos)
    *Return value: Borrowed reference.*

   Como "PyTuple_GetItem()", pero no verifica sus argumentos.

PyObject* PyTuple_GetSlice(PyObject *p, Py_ssize_t low, Py_ssize_t high)
    *Return value: New reference.*

   Retorna la porción de la tupla señalada por *p* entre *low* y
   *high*, o "NULL" en caso de falla. Este es el equivalente de la
   expresión de Python "p[bajo:alto]". La indexación desde el final de
   la lista no es compatible.

int PyTuple_SetItem(PyObject *p, Py_ssize_t pos, PyObject *o)

   Inserta una referencia al objeto *o* en la posición *pos* de la
   tupla señalada por *p*. Retorna "0" en caso de éxito. Si *pos* está
   fuera de límites, retorna "-1" y establece una excepción
   "IndexError".

   Nota:

     Esta función "roba" una referencia a *o* y descarta una
     referencia a un elemento que ya está en la tupla en la posición
     afectada.

void PyTuple_SET_ITEM(PyObject *p, Py_ssize_t pos, PyObject *o)

   Al igual que "PyTuple_SetItem()", pero no realiza ninguna
   comprobación de errores, y debe *solo* usarse para completar tuplas
   nuevas.

   Nota:

     Este macro "roba" una referencia a *o* y, a diferencia de
     "PyTuple_SetItem()", *no* descarta una referencia a ningún
     elemento que se está reemplazando; cualquier referencia en la
     tupla en la posición *pos* se filtrará.

int _PyTuple_Resize(PyObject **p, Py_ssize_t newsize)

   Se puede usar para cambiar el tamaño de una tupla. *newsize* será
   el nuevo tamaño de la tupla. Debido a que se *supone* que las
   tuplas son inmutables, esto solo debe usarse si solo hay una
   referencia al objeto. *No* use esto si la tupla ya puede ser
   conocida por alguna otra parte del código. La tupla siempre crecerá
   o disminuirá al final. Piense en esto como destruir la antigua
   tupla y crear una nueva, solo que de manera más eficiente. Retorna
   "0" en caso de éxito. El código del cliente nunca debe suponer que
   el valor resultante de "*p" será el mismo que antes de llamar a
   esta función. Si se reemplaza el objeto referenciado por "*p", se
   destruye el original "*p". En caso de fallo, retorna "-1" y
   establece "*p" en "NULL", y lanza "MemoryError" o "SystemError".

int PyTuple_ClearFreeList()

   Borra la lista libre. Retorna el número total de artículos
   liberados.


Objetos de secuencia de estructura
**********************************

Los objetos de secuencia de estructura son el equivalente en C de los
objetos "namedtuple()", es decir, una secuencia a cuyos elementos
también se puede acceder a través de atributos. Para crear una
secuencia de estructura, primero debe crear un tipo de secuencia de
estructura específico.

PyTypeObject* PyStructSequence_NewType(PyStructSequence_Desc *desc)
    *Return value: New reference.*

   Crea un nuevo tipo de secuencia de estructura a partir de los datos
   en *desc*, que se describen a continuación. Las instancias del tipo
   resultante se pueden crear con "PyStructSequence_New()".

void PyStructSequence_InitType(PyTypeObject *type, PyStructSequence_Desc *desc)

   Inicializa una secuencia de estructura tipo *type* desde *desc* en
   su lugar.

int PyStructSequence_InitType2(PyTypeObject *type, PyStructSequence_Desc *desc)

   Lo mismo que "PyStructSequence_InitType", pero retorna "0" en caso
   de éxito y "-1" en caso de error.

   Nuevo en la versión 3.4.

PyStructSequence_Desc

   Contiene la meta información de un tipo de secuencia de estructura
   para crear.

   +---------------------+--------------------------------+----------------------------------------+
   | Campo               | Tipo C                         | Significado                            |
   |=====================|================================|========================================|
   | "name"              | "const char *"                 | nombre del tipo de secuencia de        |
   |                     |                                | estructura                             |
   +---------------------+--------------------------------+----------------------------------------+
   | "doc"               | "const char *"                 | puntero al *docstring* para el tipo o  |
   |                     |                                | "NULL" para omitir                     |
   +---------------------+--------------------------------+----------------------------------------+
   | "fields"            | "PyStructSequence_Field *"     | puntero al arreglo terminado en "NULL" |
   |                     |                                | con nombres de campo del nuevo tipo    |
   +---------------------+--------------------------------+----------------------------------------+
   | "n_in_sequence"     | "int"                          | cantidad de campos visibles para el    |
   |                     |                                | lado de Python (si se usa como tupla)  |
   +---------------------+--------------------------------+----------------------------------------+

PyStructSequence_Field

   Describes a field of a struct sequence. As a struct sequence is
   modeled as a tuple, all fields are typed as "PyObject*".  The index
   in the "fields" array of the "PyStructSequence_Desc" determines
   which field of the struct sequence is described.

   +-------------+--------------------+-------------------------------------------+
   | Campo       | Tipo C             | Significado                               |
   |=============|====================|===========================================|
   | "name"      | "const char *"     | nombre para el campo o "NULL" para        |
   |             |                    | finalizar la lista de campos con nombre,  |
   |             |                    | establece en                              |
   |             |                    | "PyStructSequence_UnnamedField" para      |
   |             |                    | dejar sin nombre                          |
   +-------------+--------------------+-------------------------------------------+
   | "doc"       | "const char *"     | campo *docstring* o "NULL" para omitir    |
   +-------------+--------------------+-------------------------------------------+

char* PyStructSequence_UnnamedField

   Valor especial para un nombre de campo para dejarlo sin nombre.

PyObject* PyStructSequence_New(PyTypeObject *type)
    *Return value: New reference.*

   Crea una instancia de *type*, que debe haberse creado con
   "PyStructSequence_NewType()".

PyObject* PyStructSequence_GetItem(PyObject *p, Py_ssize_t pos)
    *Return value: Borrowed reference.*

   Retorna el objeto en la posición *pos* en la secuencia de
   estructura apuntada por *p*. No se realiza la comprobación de
   límites.

PyObject* PyStructSequence_GET_ITEM(PyObject *p, Py_ssize_t pos)
    *Return value: Borrowed reference.*

   Macro equivalente de "PyStructSequence_GetItem()".

void PyStructSequence_SetItem(PyObject *p, Py_ssize_t pos, PyObject *o)

   Establece el campo en el índice *pos* de la secuencia de estructura
   *p* en el valor *o*. Como "PyTuple_SET_ITEM()", esto solo debe
   usarse para completar instancias nuevas.

   Nota:

     Esta función "roba" una referencia a *o*.

void PyStructSequence_SET_ITEM(PyObject *p, Py_ssize_t *pos, PyObject *o)

   Macro equivalente de "PyStructSequence_SetItem()".

   Nota:

     Esta función "roba" una referencia a *o*.
