Protocolo de Seqüência
**********************

int PySequence_Check(PyObject *o)

   Retorna "1" se o objeto fornecer protocolo de sequência e "0" caso
   contrário. Note que ele retorna "1" para classes Python com um
   método "__getitem__()" a menos que sejam subclasses de "dict" já
   que no caso geral é impossível determinar que tipo de chaves ela
   suporta. Esta função sempre tem sucesso.

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

   Retorna o número de objetos em sequência *o* em caso de sucesso e
   "-1" em caso de falha. Isso é equivalente à 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. Este é o equivalente da 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. Este é o equivalente da 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 *no local* quando *o1*
   suportar. Este é o equivalente da 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 *no local*
   quando *o* suportar. Este é o equivalente da 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. Este é o
   equivalente da 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. Este é o equivalente da 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. Isso
   é equivalente à instrução Python "o[i]=v". Esta função *não* rouba
   uma referência a *v*.

   Se *v* for "NULL", o elemento é excluído, no entanto, 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.
   Isso é equivalente à 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*. Isso é equivalente à 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. Isso é equivalente à instrução Python "del
   o[i1:i2]".

Py_ssize_t PySequence_Count(PyObject *o, PyObject *value)

   Return the number of occurrences of *value* in *o*, that is, return
   the number of keys for which "o[key] == value".  On failure, return
   "-1".  This is equivalent to the Python expression
   "o.count(value)".

int PySequence_Contains(PyObject *o, PyObject *value)

   Determine if *o* contains *value*.  If an item in *o* is equal to
   *value*, return "1", otherwise return "0". On error, return "-1".
   This is equivalent to the Python expression "value in o".

Py_ssize_t PySequence_Index(PyObject *o, PyObject *value)

   Return the first index *i* for which "o[i] == value".  On error,
   return "-1".    This is equivalent to the Python expression
   "o.index(value)".

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

   Return a list object with the same contents as the sequence or
   iterable *o*, or "NULL" on failure.  The returned list is
   guaranteed to be new.  This is equivalent to the Python expression
   "list(o)".

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

   Return a tuple object with the same contents as the sequence or
   iterable *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 or iterable *o* as an object usable by the
   other "PySequence_Fast*" family of functions. If the object is not
   a sequence or iterable, raises "TypeError" with *m* as the message
   text. Returns "NULL" on failure.

   The "PySequence_Fast*" functions are thus named because they assume
   *o* is a "PyTupleObject" or a "PyListObject" and access the data
   fields of *o* directly.

   As a CPython implementation detail, if *o* is already a sequence or
   list, it will be returned.

Py_ssize_t PySequence_Fast_GET_SIZE(PyObject *o)

   Returns the length of *o*, assuming that *o* was returned by
   "PySequence_Fast()" and that *o* is not "NULL".  The size can also
   be gotten by calling "PySequence_Size()" on *o*, but
   "PySequence_Fast_GET_SIZE()" is faster because it can assume *o* is
   a list or tuple.

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

   Return the *i*th element of *o*, assuming that *o* was returned by
   "PySequence_Fast()", *o* is not "NULL", and that *i* is within
   bounds.

PyObject** PySequence_Fast_ITEMS(PyObject *o)

   Return the underlying array of PyObject pointers.  Assumes that *o*
   was returned by "PySequence_Fast()" and *o* is not "NULL".

   Note, if a list gets resized, the reallocation may relocate the
   items array. So, only use the underlying array pointer in contexts
   where the sequence cannot change.

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

   Return the *i*th element of *o* or "NULL" on failure. Faster form
   of "PySequence_GetItem()" but without checking that
   "PySequence_Check()" on *o* is true and without adjustment for
   negative indices.
