Objetos bytes
*************

Estas funciones lanzan "TypeError" cuando se espera un parámetro de
bytes y se llama con un parámetro que no es bytes.

type PyBytesObject

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

PyTypeObject PyBytes_Type
    * Part of the Stable ABI.*

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

int PyBytes_Check(PyObject *o)

   Retorna verdadero si el objeto *o* es un objeto bytes o una
   instancia de un subtipo del tipo bytes. Esta función siempre
   finaliza con éxito.

int PyBytes_CheckExact(PyObject *o)

   Retorna verdadero si el objeto *o* es un objeto bytes, pero no una
   instancia de un subtipo del tipo bytes. Esta función siempre
   finaliza con éxito.

PyObject *PyBytes_FromString(const char *v)
    *Return value: New reference.** Part of the Stable ABI.*

   Retorna un nuevo objeto bytes con una copia de la cadena de
   caracteres *v* como valor en caso de éxito y "NULL" en caso de
   error. El parámetro *v* no debe ser "NULL"; no se comprobará.

PyObject *PyBytes_FromStringAndSize(const char *v, Py_ssize_t len)
    *Return value: New reference.** Part of the Stable ABI.*

   Retorna un nuevo objeto bytes con una copia de la cadena de
   caracteres *v* como valor y longitud *len* en caso de éxito y
   "NULL" en caso de error. Si *v* es "NULL", el contenido del objeto
   bytes no se inicializa.

PyObject *PyBytes_FromFormat(const char *format, ...)
    *Return value: New reference.** Part of the Stable ABI.*

   Toma una cadena de caracteres *format* del estilo C "printf()" y un
   número variable de argumentos, calcula el tamaño del objeto bytes
   Python resultante y retorna un objeto bytes con los valores
   formateados. Los argumentos variables deben ser tipos C y deben
   corresponder exactamente a los caracteres de formato en la cadena
   de caracteres *format*. Se permiten los siguientes caracteres de
   formato:

   +---------------------+-----------------+----------------------------------+
   | Caracteres de       | Tipo            | Comentario                       |
   | formato             |                 |                                  |
   |=====================|=================|==================================|
   | "%%"                | *n/a*           | El carácter literal *%*.         |
   +---------------------+-----------------+----------------------------------+
   | "%c"                | int             | Un solo byte, representado como  |
   |                     |                 | un C int.                        |
   +---------------------+-----------------+----------------------------------+
   | "%d"                | int             | Equivalente a "printf("%d")".    |
   |                     |                 | [1]                              |
   +---------------------+-----------------+----------------------------------+
   | "%u"                | unsigned int    | Equivalente a "printf("%u")".    |
   |                     |                 | [1]                              |
   +---------------------+-----------------+----------------------------------+
   | "%ld"               | long            | Equivalente a "printf("%ld")".   |
   |                     |                 | [1]                              |
   +---------------------+-----------------+----------------------------------+
   | "%lu"               | unsigned long   | Equivalente a "printf("%lu")".   |
   |                     |                 | [1]                              |
   +---------------------+-----------------+----------------------------------+
   | "%zd"               | "Py_ssize_t"    | Equivalente a "printf("%zd")".   |
   |                     |                 | [1]                              |
   +---------------------+-----------------+----------------------------------+
   | "%zu"               | size_t          | Equivalente a "printf("%zu")".   |
   |                     |                 | [1]                              |
   +---------------------+-----------------+----------------------------------+
   | "%i"                | int             | Equivalente a "printf("%i")".    |
   |                     |                 | [1]                              |
   +---------------------+-----------------+----------------------------------+
   | "%x"                | int             | Equivalente a "printf("%x")".    |
   |                     |                 | [1]                              |
   +---------------------+-----------------+----------------------------------+
   | "%s"                | const char*     | Un arreglo de caracteres C       |
   |                     |                 | terminados en nulo.              |
   +---------------------+-----------------+----------------------------------+
   | "%p"                | const void*     | La representación hexadecimal de |
   |                     |                 | un puntero en C. Principalmente  |
   |                     |                 | equivalente a "printf("%p")"     |
   |                     |                 | excepto que se garantiza que     |
   |                     |                 | comience con el literal "0x",    |
   |                     |                 | independientemente de lo que     |
   |                     |                 | produzca el "printf" de la       |
   |                     |                 | plataforma.                      |
   +---------------------+-----------------+----------------------------------+

   Un carácter de formato no reconocido hace que todo el resto de la
   cadena de caracteres de formato se copie como está en el objeto de
   resultado y se descartan los argumentos adicionales.

   [1] Para especificadores de enteros *(d, u, ld, lu, zd, zu, i, x)*:
       el indicador de conversión 0 tiene efecto incluso cuando se
       proporciona una precisión.

PyObject *PyBytes_FromFormatV(const char *format, va_list vargs)
    *Return value: New reference.** Part of the Stable ABI.*

   Idéntica a "PyBytes_FromFormat()" excepto que toma exactamente dos
   argumentos.

PyObject *PyBytes_FromObject(PyObject *o)
    *Return value: New reference.** Part of the Stable ABI.*

   Retorna la representación en bytes del objeto *o* que implementa el
   protocolo de búfer.

Py_ssize_t PyBytes_Size(PyObject *o)
    * Part of the Stable ABI.*

   Retorna la longitud de los bytes en el objeto bytes *o*.

Py_ssize_t PyBytes_GET_SIZE(PyObject *o)

   Forma macro de "PyBytes_Size()" pero sin verificación de errores.

char *PyBytes_AsString(PyObject *o)
    * Part of the Stable ABI.*

   Retorna un puntero al contenido de *o*. El puntero se refiere al
   búfer interno de *o*, que consiste en "len(o) + 1" bytes. El último
   byte en el búfer siempre es nulo, independientemente de si hay
   otros bytes nulos. Los datos no deben modificarse de ninguna
   manera, a menos que el objeto se haya creado usando
   "PyBytes_FromStringAndSize(NULL, size)". No debe ser desasignado.
   Si *o* no es un objeto de bytes en absoluto, "PyBytes_AsString()"
   retorna "NULL" y lanza un "TypeError".

char *PyBytes_AS_STRING(PyObject *string)

   Forma macro de "PyBytes_AsString()" pero sin verificación de
   errores.

int PyBytes_AsStringAndSize(PyObject *obj, char **buffer, Py_ssize_t *length)
    * Part of the Stable ABI.*

   Return the null-terminated contents of the object *obj* through the
   output variables *buffer* and *length*. Returns "0" on success.

   Si *length* es "NULL", el objeto bytes no puede contener bytes
   nulos incrustados; en caso contrario, la función retorna "-1" y se
   lanza un "ValueError".

   El búfer se refiere a un búfer interno de *obj*, que incluye un
   byte nulo adicional al final (no está considerado en *length*). Los
   datos no deben modificarse de ninguna manera, a menos que el objeto
   se haya creado usando "PyBytes_FromStringAndSize(NULL, size)". No
   debe ser desasignado. Si *obj* no es un objeto bytes en absoluto,
   "PyBytes_AsStringAndSize()" retorna "-1" y lanza "TypeError".

   Distinto en la versión 3.5: Anteriormente, "TypeError" se lanzaba
   cuando se encontraban bytes nulos incrustados en el objeto bytes.

void PyBytes_Concat(PyObject **bytes, PyObject *newpart)
    * Part of the Stable ABI.*

   Crea un nuevo objeto de bytes en **bytes* que contiene el contenido
   de *newpart* agregado a *bytes*; la persona que llama poseerá la
   nueva referencia. La referencia al valor anterior de *bytes* será
   robada. Si no se puede crear el nuevo objeto, la referencia
   anterior a *bytes* se seguirá descartando y el valor de **bytes* se
   establecerá en "NULL"; se establecerá la excepción apropiada.

void PyBytes_ConcatAndDel(PyObject **bytes, PyObject *newpart)
    * Part of the Stable ABI.*

   Create a new bytes object in **bytes* containing the contents of
   *newpart* appended to *bytes*.  This version releases the *strong
   reference* to *newpart* (i.e. decrements its reference count).

int _PyBytes_Resize(PyObject **bytes, Py_ssize_t newsize)

   Resize a bytes object. *newsize* will be the new length of the
   bytes object. You can think of it as creating a new bytes object
   and destroying the old one, only more efficiently. Pass the address
   of an existing bytes object as an lvalue (it may be written into),
   and the new size desired.  On success, **bytes* holds the resized
   bytes object and "0" is returned; the address in **bytes* may
   differ from its input value.  If the reallocation fails, the
   original bytes object at **bytes* is deallocated, **bytes* is set
   to "NULL", "MemoryError" is set, and "-1" is returned.
