Objetos Bytes
*************

Estas funções geram  "TypeError" quando chamadas sem o parâmetro do
tupo bytes esperado.

PyBytesObject

   Esta é uma instância de "PyObject" representando o tipo Python:
   bytes

PyTypeObject PyBytes_Type

   Esta instância de: c: tipo: *PyTypeObject* representa o tipo de
   bytes Python; é o mesmo objeto que: classe: *bytes* na camada de
   Python.

int PyBytes_Check(PyObject *o)

   Retorna verdadeiro se o objeto *o* for um objeto do tipo byte ou
   uma instância de um subtipo do tipo bytes.

int PyBytes_CheckExact(PyObject *o)

   Retorna verdadeiro se o objeto *o* for um objeto de bytes, mas não
   uma instância de um subtipo do tipo de bytes.

PyObject* PyBytes_FromString(const char *v)

   Retorna um novo objeto bytes com uma cópia da string *v* como valor
   no sucesso e *NULL* no caso de falha. O parâmetro *v* não deve ser
   *NULL*; ou ele não será verificado.

PyObject* PyBytes_FromStringAndSize(const char *v, Py_ssize_t len)

   Devolver um novo objeto de bytes com uma cópia da string *v* como
   valor e comprimento *len* no sucesso e *NULL* no caso de falha. Se
   *v* for *NULL*, o conteúdo do objeto bytes não está inicializado.

PyObject* PyBytes_FromFormat(const char *format, ...)

   Tome uma seqüência C "printf()"-style *format* variáveis de números
   e caracteres são os argumentos, calcule o tamanho do objeto de
   bytes Python resultante e devolva um objeto bytes com os valores
   formatados nela. Os argumentos da variável devem ser tipos C e
   devem corresponder exatamente aos caracteres de formato na
   seqüência * format >>*<<. Os seguintes formatos são permitidos:

   +---------------------+-----------------+----------------------------------+
   | Caracteres          | Tipo            | Comentário                       |
   | Formatados          |                 |                                  |
   |=====================|=================|==================================|
   | "%%"                | *n/a*           | O caracter literal %.            |
   +---------------------+-----------------+----------------------------------+
   | "%c"                | int             | Um único byte, representado como |
   |                     |                 | um C int.                        |
   +---------------------+-----------------+----------------------------------+
   | "%d"                | int             | Equivale exatamente ao           |
   |                     |                 | "printf("%d")".                  |
   +---------------------+-----------------+----------------------------------+
   | "%u"                | unsigned int    | Equivale exatamente ao           |
   |                     |                 | "printf("%u")".                  |
   +---------------------+-----------------+----------------------------------+
   | "%ld"               | extenso,        | Equivale exatamente ao           |
   |                     | comprido        | "printf("%ld")".                 |
   +---------------------+-----------------+----------------------------------+
   | "%lu"               | unsigned long   | Equivale exatamente ao           |
   |                     |                 | "printf("%ld")"                  |
   +---------------------+-----------------+----------------------------------+
   | "%zd"               | Py_stamanho_t   | Equivale exatamente ao           |
   |                     |                 | "printf("%zd")".                 |
   +---------------------+-----------------+----------------------------------+
   | "%zu"               | tamanho_t       | Equivale exatamente ao           |
   |                     |                 | "printf("%zu")".                 |
   +---------------------+-----------------+----------------------------------+
   | "%i"                | int             | Equivale exatamente ao           |
   |                     |                 | "printf("%i")".                  |
   +---------------------+-----------------+----------------------------------+
   | "%x"                | int             | Equivale exatamente ao           |
   |                     |                 | "printf("%x")".                  |
   +---------------------+-----------------+----------------------------------+
   | "%s"                | caracter*       | Uma matriz de caracteres C com   |
   |                     |                 | terminação nula.                 |
   +---------------------+-----------------+----------------------------------+
   | "%p"                | vazio*          | A representação hexadecimal de   |
   |                     |                 | um ponteiro C. Principalmente    |
   |                     |                 | equivalente a "printf("%p")"     |
   |                     |                 | exceto que é garantido que       |
   |                     |                 | comece com o literal "0x"        |
   |                     |                 | independentemente do que o       |
   |                     |                 | "printf" da plataforma ceda.     |
   +---------------------+-----------------+----------------------------------+

   Um caractere de formato não reconhecido faz com que todo o resto da
   sequência de formato seja copiado como é para o objeto resultante e
   todos os argumentos extras sejam descartados.

PyObject* PyBytes_FromFormatV(const char *format, va_list vargs)

   Idêntico a "PyBytes_FromFormat()" exceto que é preciso exatamente
   dois argumentos.

PyObject* PyBytes_FromObject(PyObject *o)

   Retorna a representação de bytes do objeto *o* que implementa o
   protocolo de buffer.

Py_ssize_t PyBytes_Size(PyObject *o)

   Retornar o comprimento dos bytes em bytes objeto *o*.

Py_ssize_t PyBytes_GET_SIZE(PyObject *o)

   Forma macro de "PyBytes_Size()" mas sem verificação de erro.

char* PyBytes_AsString(PyObject *o)

   Retorna um ponteiro para o conteúdo de *o*. O ponteiro refere-se ao
   buffer interno de *o*, que consiste em "len(o) + 1" bytes. O último
   byte no buffer é sempre nulo, independentemente de haver outros
   bytes nulos. Os dados não devem ser modificados de forma alguma, a
   menos que o objeto tenha sido criado apenas usando
   "PyBytes_FromStringAndSize(NULL, size)". Não deve ser desalinhado.
   Se *o* não for um objeto de bytes, "PyBytes_AsString()" retorna
   *NULL* e eleva: exc:` TypeError`.

char* PyBytes_AS_STRING(PyObject *string)

   Forma macro de: c: func: *PyBytes_AsString* mas sem verificação de
   erro.

int PyBytes_AsStringAndSize(PyObject *obj, char **buffer, Py_ssize_t *length)

   Retornar os conteúdos terminados nulos do objeto *obj* através das
   variáveis de saída * buffer* e *length*.

   Se *length* for *NULL*, o objeto bytes pode não conter bytes nulos
   incorporados; se o fizer, a função retorna "-1" e a: exc:
   *ValueError* é gerado.

   O buffer refere-se a um buffer interno de *obj *, que inclui um
   byte nulo adicional no final (não contado em *comprimento*). Os
   dados não devem ser modificados de forma alguma, a menos que o
   objeto tenha sido criado apenas usando
   "PyBytes_FromStringAndSize(NULL, size)". Não deve ser desalinhado.
   Se *obj* não é um objeto bytes, c: func: *PyBytes_AsStringAndSize*
   retorna "-1" e eleva: exc:` TypeError`.

   Alterado na versão 3.5: Anteriormente: exc: *TypeError* foi criado
   quando os bytes nulos incorporados foram encontrados no objeto
   bytes.

void PyBytes_Concat(PyObject **bytes, PyObject *newpart)

   Crie um novo objeto bytes em **bytes* contendo o conteúdo de
   *newpart* anexado a *bytes*; o chamador terá a nova referência. A
   referência ao valor antigo de *bytes* será roubada. Se o novo
   objeto não puder ser criado, a referência antiga para *bytes* ainda
   será descartada e o valor de **bytes* será definido como *NULL*; a
   exceção apropriada será definida.

void PyBytes_ConcatAndDel(PyObject **bytes, PyObject *newpart)

   Crie um novo objeto bytes em **bytes* contendo o conteúdo de
   *newpart* anexado a *bytes*. Esta versão diminui a contagem de
   *newpart*.

int _PyBytes_Resize(PyObject **bytes, Py_ssize_t newsize)

   Uma maneira de redimensionar um objeto bytes mesmo que seja
   "imutável". Use apenas isso para criar um novo objeto de bytes; não
   use isso se os bytes já podem ser conhecidos em outras partes do
   código. É um erro ao chamar essa função se o preenchimento no
   objeto bytes de entrada não for um. Passe o endereço de um objeto
   de bytes existente como um lvalue (pode ser escrito em) e o novo
   tamanho desejado. Em êxito, **bytes* contém o objeto de bytes
   redimensionados e "0" é retornado; o endereço em **bytes* pode
   diferir do seu valor de entrada. Se a reatribuição falhar, o objeto
   bytes original em **bytes* é desalocado, **bytes* é definido como
   *NULL*, "MemoryError" está definido e "-1" é retornado.
