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

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

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

   Crea un nuevo objeto de bytes en **bytes* que contenga el contenido
   de *newpart* agregado a *bytes*. Esta versión libera la *strong
   reference* a *newpart* (es decir, disminuye su recuento de
   referencias).

int _PyBytes_Resize(PyObject **bytes, Py_ssize_t newsize)

   Redimensiona un objeto bytes. *newsize* será la nueva longitud del
   objeto bytes. Se puede considerar como crear un nuevo objeto bytes
   y destruir el anterior, solo que de forma más eficiente. Pasa la
   dirección de un objeto bytes existente como lvalue (se puede
   escribir en él) y el nuevo tamaño deseado. En caso de éxito,
   **bytes* contiene el objeto bytes redimensionado y se retorna "0";
   la dirección en **bytes* puede diferir de su valor de entrada. Si
   la reasignación falla, el objeto bytes original en **bytes* se
   desasigna, **bytes* se establece en "NULL", se establece
   "MemoryError" y se retorna "-1".

PyObject *PyBytes_Repr(PyObject *bytes, int smartquotes)
    * Part of the Stable ABI.*

   Get the string representation of *bytes*. This function is
   currently used to implement "bytes.__repr__()" in Python.

   This function does not do type checking; it is undefined behavior
   to pass *bytes* as a non-bytes object or "NULL".

   If *smartquotes* is true, the representation will use a double-
   quoted string instead of single-quoted string when single-quotes
   are present in *bytes*. For example, the byte string "'Python'"
   would be represented as "b"'Python'"" when *smartquotes* is true,
   or "b'\'Python\''" when it is false.

   On success, this function returns a *strong reference* to a "str"
   object containing the representation. On failure, this returns
   "NULL" with an exception set.

PyObject *PyBytes_DecodeEscape(const char *s, Py_ssize_t len, const char *errors, Py_ssize_t unicode, const char *recode_encoding)
    * Part of the Stable ABI.*

   Unescape a backslash-escaped string *s*. *s* must not be "NULL".
   *len* must be the size of *s*.

   *errors* must be one of ""strict"", ""replace"", or ""ignore"". If
   *errors* is "NULL", then ""strict"" is used by default.

   On success, this function returns a *strong reference* to a Python
   "bytes" object containing the unescaped string. On failure, this
   function returns "NULL" with an exception set.

   Distinto en la versión 3.9: *unicode* and *recode_encoding* are now
   unused.
