Protocolo de sequência
**********************

int PySequence_Check(PyObject *o)

   Return "1" if the object provides the sequence protocol, and "0"
   otherwise. Note that it returns "1" for Python classes with a
   "__getitem__()" method, unless they are "dict" subclasses, since in
   general it is impossible to determine what type of keys the class
   supports.  This function always succeeds.

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

   Retorna o número de objetos na sequência *o* em caso de sucesso, ou
   "-1" em caso de falha. Equivale à expressão Python "len(o)".

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

   Retorna a concatenação de *o1* e *o2* em caso de sucesso, e "NULL"
   em caso de falha. Equivale à expressão Python "o1 + o2".

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

   Retorna o resultado da repetição do objeto sequência *o* *count*
   vezes ou "NULL" em caso de falha. Equivale à expressão Python "o *
   count".

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

   Retorna a concatenação de *o1* e *o2* em caso de sucesso, e "NULL"
   em caso de falha. A operação é feita *localmente* se *o1* permitir.
   Equivale à expressão Python "o1 += o2".

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

   Retorna o resultado da repetição do objeto sequência *o* *count*
   vezes ou "NULL" em caso de falha. A operação é feita *localmente*
   se *o* permitir. Equivale à expressão Python "o *= count".

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

   Retorna o elemento *i* de *o* ou "NULL" em caso de falha. Equivale
   à expressão Python "o[i]".

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

   Retorna a fatia do objeto sequência *o* entre *i1* e *i2*, ou
   "NULL" em caso de falha. Equivale à expressão Python "o[i1:i2]".

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

   Atribui o objeto *v* ao elemento *i* de *o*. Levanta uma exceção e
   retorna "-1" em caso de falha; retorna "0" em caso de sucesso. Esta
   função *não* rouba uma referência a *v*. Equivale à instrução
   Python "o[i]=v".

   Se *v* for "NULL", o elemento será removido, mas este recurso foi
   descontinuado em favor do uso de "PySequence_DelItem()".

int PySequence_DelItem(PyObject *o, Py_ssize_t i)

   Exclui o elemento *i* do objeto *o*. Retorna "-1" em caso de falha.
   Equivale à instrução Python "del o[i]".

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

   Atribui o objeto sequência *v* à fatia no objeto sequência *o* de
   *i1* a *i2*. Equivale à instrução Python "o[i1:i2] = v".

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

   Exclui a fatia no objeto sequência *o* de *i1* a *i2*. Retorna "-1"
   em caso de falha. Equivale à instrução Python "del o[i1:i2]".

Py_ssize_t PySequence_Count(PyObject *o, PyObject *value)

   Retorna a quantidade de ocorrências de *value* em *o*, isto é,
   retorna a quantidade de chaves onde "o[key] == value". Em caso de
   falha, retorna "-1". Equivale à expressão Python "o.count(value)".

int PySequence_Contains(PyObject *o, PyObject *value)

   Determina se *o* contém *value*. Se um item em *o* for igual a
   *value*, retorna "1", senão, retorna "0". Em caso de erro, retorna
   "-1". Equivale à expressão Python "value in o".

Py_ssize_t PySequence_Index(PyObject *o, PyObject *value)

   Retorna o primeiro índice *i* tal que "o[i] == value". Em caso de
   erro, retorna "-1". Equivale à expressão Python "o.index(value)".

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

   Retorna um objeto lista com o mesmo conteúdo da sequência ou
   iterável *o*, ou "NULL" em caso de falha. Garante-se que a lista
   retornada será nova. Equivale à expressão Python "list(o)".

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

   Retorna o objeto tupla com o mesmo conteúdo da sequência ou
   iterável *o*, ou "NULL" em caso de falha. Se *o* for uma tupla,
   retorna uma nova referência. Senão, uma tupla será construída com o
   conteúdo apropriado. Equivale à expressão Python "tuple(o)".

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

   Retorna a sequência ou iterável *o* como um objeto usável por
   outras funções da família "PySequence_Fast*". Se o objeto não for
   uma sequência ou iterável, levanta "TypeError" com *m* sendo o
   texto da mensagem. Retorna "NULL" em caso de falha.

   As funções "PySequence_Fast*" têm esse nome porque presumem que *o*
   é um "PyTupleObject" ou um "PyListObject" e porque acessam os
   campos de dados de *o* diretamente.

   Como detalhe de implementação de CPython, se *o* já for uma
   sequência ou lista, ele será retornado.

Py_ssize_t PySequence_Fast_GET_SIZE(PyObject *o)

   Retorna o comprimento de *o*, presumindo que *o* foi retornado por
   "PySequence_Fast()" e que *o* não seja "NULL". O tamanho também
   pode ser obtido ao chamar "PySequence_Size()" em *o*, mas
   "PySequence_Fast_GET_SIZE()" é mais rápida, ao supor que *o* é uma
   lista ou tupla.

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

   Retorna o elemento *i* de *o*, presumindo que *o* foi retornado por
   "PySequence_Fast()", que *o* seja "NULL", e que *i* esteja nos
   limites.

PyObject** PySequence_Fast_ITEMS(PyObject *o)

   Retorna o vetor subjacente de ponteiros PyObject. Presume que *o*
   foi retornado por "PySequence_Fast()" e que *o* não seja "NULL".

   Note que, se uma lista for redimensionada, a realocação poderá
   reposicionar o vetor de itens. Portanto, só use o ponteiro de vetor
   subjacente em contextos onde a sequência não mudará.

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

   Retorna o elemento *i* de *o*, ou "NULL" em caso de falha. É uma
   forma mais rápida de "PySequence_GetItem()", mas sem verificar se
   "PySequence_Check()" em *o* é verdadeiro e sem ajustar índices
   negativos.
