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.

PyBytesObject

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

PyTypeObject PyBytes_Type

   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.

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.

PyObject* PyBytes_FromString(const char *v)
    *Return value: New reference.*

   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.*

   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.*

   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.*

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

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

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

Py_ssize_t PyBytes_Size(PyObject *o)

   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)

   Retorna un puntero al contenido de *o*. El puntero se refiere al
   búfer interno de *o*, que consiste en bytes "len(o) + 1". 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)

   Retorna los contenidos terminados en nulo del objeto *obj* a través
   de las variables de salida *buffer* y *length*.

   Si *length* es "NULL", el objeto bytes no puede contener bytes
   nulos incrustados; si lo hace, la función retorna "-1" y se genera
   un "ValueError".

   El búfer se refiere a un búfer interno de *obj*, que incluye un
   byte nulo adicional al final (sin contar 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)

   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)

   Crea un nuevo objeto de bytes en **bytes* que contenga el contenido
   de *newpart* agregado a *bytes*. Esta versión disminuye el recuento
   de referencias de *newpart*.

int _PyBytes_Resize(PyObject **bytes, Py_ssize_t newsize)

   Una forma de cambiar el tamaño de un objeto bytes aunque sea
   "inmutable". Solo use esto para construir un nuevo objeto bytes; no
   use esto si los bytes ya pueden ser conocidos en otras partes del
   código. Es un error llamar a esta función si el recuento en el
   objeto bytes de entrada no es uno. Pasa la dirección de un objeto
   de bytes existente como un *lvalue* (puede escribirse en él) y el
   nuevo tamaño deseado. En caso de éxito, **bytes* retiene el objeto
   de bytes redimensionados y se retorna "0"; la dirección en **bytes*
   puede diferir de su valor de entrada. Si la reasignación falla, el
   objeto de bytes original en **bytes* se desasigna, **bytes* se
   establece en "NULL", "MemoryError" se establece y se retorna "-1" .
