Objeto Tuple
************

PyTupleObject

   Este subtipo de "PyObject" representa um objeto tupla em Python.

PyTypeObject PyTuple_Type

   Esta instância de "PyTypeObject"  representa o tipo tupla de
   Python; é o mesmo objeto que "tuple" na camada Python.

int PyTuple_Check(PyObject *p)

   Devolve verdadeiro se *p* é um objeto tupla ou uma instância de um
   subtipo do tipo tupla.

int PyTuple_CheckExact(PyObject *p)

   Devolve verdadeiro se *p* é um objeto tupla, mas não uma instância
   de um subtipo do tipo tupla.

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

   Return a new tuple object of size *len*, or *NULL* on failure.

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

   Return a new tuple object of size *n*, or *NULL* on failure. The
   tuple values are initialized to the subsequent *n* C arguments
   pointing to Python objects. "PyTuple_Pack(2, a, b)" is equivalent
   to "Py_BuildValue("(OO)", a, b)".

Py_ssize_t PyTuple_Size(PyObject *p)

   Pega um ponteiro para um objeto tupla e retorna o tamanho dessa
   tupla.

Py_ssize_t PyTuple_GET_SIZE(PyObject *p)

   Return the size of the tuple *p*, which must be non-*NULL* and
   point to a tuple; no error checking is performed.

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

   Return the object at position *pos* in the tuple pointed to by *p*.
   If *pos* is out of bounds, return *NULL* and sets an "IndexError"
   exception.

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

   Como "PyTuple_GetItem()", mas faz nenhuma verificação de seus
   argumentos.

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

   Take a slice of the tuple pointed to by *p* from *low* to *high*
   and return it as a new tuple.

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

   Insert a reference to object *o* at position *pos* of the tuple
   pointed to by *p*. Return "0" on success.

   Nota:

     Esta função "rouba" uma referência a *o*.

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

   Como "PyTuple_SetItem()", mas não verifica erros e deve *apenas*
   ser usado para preencher novas tuplas.

   Nota:

     Esta função "rouba" uma referência a *o*.

int _PyTuple_Resize(PyObject **p, Py_ssize_t newsize)

   Can be used to resize a tuple.  *newsize* will be the new length of
   the tuple. Because tuples are *supposed* to be immutable, this
   should only be used if there is only one reference to the object.
   Do *not* use this if the tuple may already be known to some other
   part of the code.  The tuple will always grow or shrink at the end.
   Think of this as destroying the old tuple and creating a new one,
   only more efficiently.  Returns "0" on success. Client code should
   never assume that the resulting value of "*p" will be the same as
   before calling this function. If the object referenced by "*p" is
   replaced, the original "*p" is destroyed.  On failure, returns "-1"
   and sets "*p" to *NULL*, and raises "MemoryError" or "SystemError".

int PyTuple_ClearFreeList()

   Limpe a lista livre. Retorna o número total de itens liberados.


Objetos sequência de estrutura
******************************

Objetos sequência de estrutura são o equivalente em C dos objetos
"namedtuple()", ou seja, uma sequência cujos itens também podem ser
acessados por meio de atributos. Para criar uma sequência de
estrutura, você primeiro precisa criar um tipo de sequência de
estrutura específico.

PyTypeObject* PyStructSequence_NewType(PyStructSequence_Desc *desc)

   Cria um novo tipo de sequência de estrutura a partir dos dados em
   *desc*, descrito abaixo. Instâncias do tipo resultante podem ser
   criadas com "PyStructSequence_New()".

void PyStructSequence_InitType(PyTypeObject *type, PyStructSequence_Desc *desc)

   Inicializa um tipo de sequência de estrutura *type* de *desc* no
   lugar.

int PyStructSequence_InitType2(PyTypeObject *type, PyStructSequence_Desc *desc)

   O mesmo que "PyStructSequence_InitType", mas retorna "0" em caso de
   sucesso e "-1" em caso de falha.

   Novo na versão 3.4.

PyStructSequence_Desc

   Contém as metainformações de um tipo de sequência de estrutura a
   ser criado.

   +---------------------+--------------------------------+--------------------------------------+
   | Campo               | Tipo em C                      | Significado                          |
   |=====================|================================|======================================|
   | "name"              | "char *"                       | nome do tipo sequência de estrutura  |
   +---------------------+--------------------------------+--------------------------------------+
   | "doc"               | "char *"                       | pointer to docstring for the type or |
   |                     |                                | NULL to omit                         |
   +---------------------+--------------------------------+--------------------------------------+
   | "fields"            | "PyStructSequence_Field *"     | pointer to *NULL*-terminated array   |
   |                     |                                | with field names of the new type     |
   +---------------------+--------------------------------+--------------------------------------+
   | "n_in_sequence"     | "int"                          | número de campos visíveis para o     |
   |                     |                                | lado Python (se usado 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 em C       | Significado                            |
   |=============|=================|========================================|
   | "name"      | "char *"        | name for the field or *NULL* to end    |
   |             |                 | the list of named fields, set to       |
   |             |                 | PyStructSequence_UnnamedField to leave |
   |             |                 | unnamed                                |
   +-------------+-----------------+----------------------------------------+
   | "doc"       | "char *"        | field docstring or *NULL* to omit      |
   +-------------+-----------------+----------------------------------------+

char* PyStructSequence_UnnamedField

   Valor especial para um nome de campo para deixá-lo sem nome.

PyObject* PyStructSequence_New(PyTypeObject *type)

   Cria um instância de *type*, que deve ser criada com
   "PyStructSequence_NewType()".

PyObject* PyStructSequence_GetItem(PyObject *p, Py_ssize_t pos)

   Retorna o objeto na posição *pos* na sequência de estrutura
   apontada por *p*. Nenhuma verificação de limites é executada.

PyObject* PyStructSequence_GET_ITEM(PyObject *p, Py_ssize_t pos)

   Macro equivalente de "PyStructSequence_GetItem()".

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

   Define o campo no índice *pos* da sequência de estrutura *p* para o
   valor *o*. Como "PyTuple_SET_ITEM()", isto só deve ser usado para
   preencher novas instâncias.

   Nota:

     Esta função "rouba" uma referência a *o*.

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

   Macro equivalente de "PyStructSequence_SetItem()".

   Nota:

     Esta função "rouba" uma referência a *o*.
