# Copyright (C) 2001-2020, Python Software Foundation
# This file is distributed under the same license as the Python package.
# Maintained by the python-doc-es workteam.
# docs-es@python.org /
# https://mail.python.org/mailman3/lists/docs-es.python.org/
# Check https://github.com/python/python-docs-es/blob/3.8/TRANSLATORS to
# get the list of volunteers
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.8\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2023-10-12 19:43+0200\n"
"PO-Revision-Date: 2021-10-30 19:57-0300\n"
"Last-Translator: Cristián Maureira-Fredes <cmaureirafredes@gmail.com>\n"
"Language: es\n"
"Language-Team: python-doc-es\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.13.0\n"

#: ../Doc/c-api/arg.rst:6
msgid "Parsing arguments and building values"
msgstr "Analizando argumentos y construyendo valores"

#: ../Doc/c-api/arg.rst:8
msgid ""
"These functions are useful when creating your own extensions functions and "
"methods.  Additional information and examples are available in :ref:"
"`extending-index`."
msgstr ""
"Estas funciones son útiles al crear sus propias funciones y métodos de "
"extensiones. Información y ejemplos adicionales están disponibles en :ref:"
"`extending-index`."

#: ../Doc/c-api/arg.rst:12
msgid ""
"The first three of these functions described, :c:func:`PyArg_ParseTuple`, :c:"
"func:`PyArg_ParseTupleAndKeywords`, and :c:func:`PyArg_Parse`, all use "
"*format strings* which are used to tell the function about the expected "
"arguments.  The format strings use the same syntax for each of these "
"functions."
msgstr ""
"Las tres primeras de estas funciones descritas, :c:func:`PyArg_ParseTuple`, :"
"c:func:`PyArg_ParseTupleAndKeywords`, y :c:func:`PyArg_Parse`, todas usan "
"*cadenas de caracteres de formato* que se utilizan para contarle a la "
"función sobre los argumentos esperados. Las cadenas de caracteres de formato "
"utilizan la misma sintaxis para cada una de estas funciones."

#: ../Doc/c-api/arg.rst:19
msgid "Parsing arguments"
msgstr "Analizando argumentos"

#: ../Doc/c-api/arg.rst:21
msgid ""
"A format string consists of zero or more \"format units.\"  A format unit "
"describes one Python object; it is usually a single character or a "
"parenthesized sequence of format units.  With a few exceptions, a format "
"unit that is not a parenthesized sequence normally corresponds to a single "
"address argument to these functions.  In the following description, the "
"quoted form is the format unit; the entry in (round) parentheses is the "
"Python object type that matches the format unit; and the entry in [square] "
"brackets is the type of the C variable(s) whose address should be passed."
msgstr ""
"Una cadena de formato consta de cero o más \"unidades de formato.\" Una "
"unidad de formato describe un objeto Python; por lo general es un solo "
"carácter o una secuencia de unidades formato entre paréntesis. Con unas "
"pocas excepciones, una unidad de formato que no es una secuencia entre "
"paréntesis normalmente corresponde a un único argumento de dirección de "
"estas funciones. En la siguiente descripción, la forma citada es la unidad "
"de formato; la entrada en paréntesis (redondos) es el tipo de objeto Python "
"que coincida con la unidad de formato; y la entrada entre corchetes "
"[cuadrados] es el tipo de la variable(s) C cuya dirección debe ser pasada."

#: ../Doc/c-api/arg.rst:31
msgid "Strings and buffers"
msgstr "Cadena de caracteres y búferes"

#: ../Doc/c-api/arg.rst:33
msgid ""
"These formats allow accessing an object as a contiguous chunk of memory. You "
"don't have to provide raw storage for the returned unicode or bytes area."
msgstr ""
"Estos formatos permiten acceder a un objeto como un bloque contiguo de "
"memoria. Usted no tiene que proporcionar almacenamiento en bruto para el "
"Unicode o área de bytes retornada."

#: ../Doc/c-api/arg.rst:37
msgid "Unless otherwise stated, buffers are not NUL-terminated."
msgstr ""
"A menos que se indique lo contrario, los búferes no son terminados en NULL "
"(*NUL-terminated*)."

#: ../Doc/c-api/arg.rst:39
msgid "There are three ways strings and buffers can be converted to C:"
msgstr ""

#: ../Doc/c-api/arg.rst:41
#, fuzzy
msgid ""
"Formats such as ``y*`` and ``s*`` fill a :c:type:`Py_buffer` structure. This "
"locks the underlying buffer so that the caller can subsequently use the "
"buffer even inside a :c:type:`Py_BEGIN_ALLOW_THREADS` block without the risk "
"of mutable data being resized or destroyed. As a result, **you have to "
"call** :c:func:`PyBuffer_Release` after you have finished processing the "
"data (or in any early abort case)."
msgstr ""
"Sin embargo, cuando una estructura :c:type:`Py_buffer` se llena, la memoria "
"intermedia subyacente está bloqueada de manera que la persona que llama "
"puede posteriormente utilizar la memoria intermedia incluso dentro de un "
"bloque :c:type:`Py_BEGIN_ALLOW_THREADS` sin el riesgo de que los datos "
"mutables sean redimensionados o destruidos. Como resultado, **usted tiene "
"que llamar** :c:func:`PyBuffer_Release` después de haber terminado de "
"procesar los datos (o en caso de aborto temprano)."

#: ../Doc/c-api/arg.rst:48
msgid ""
"The ``es``, ``es#``, ``et`` and ``et#`` formats allocate the result buffer. "
"**You have to call** :c:func:`PyMem_Free` after you have finished processing "
"the data (or in any early abort case)."
msgstr ""

#: ../Doc/c-api/arg.rst:54
msgid ""
"Other formats take a :class:`str` or a read-only :term:`bytes-like object`, "
"such as :class:`bytes`, and provide a ``const char *`` pointer to its "
"buffer. In this case the buffer is \"borrowed\": it is managed by the "
"corresponding Python object, and shares the lifetime of this object. You "
"won't have to release any memory yourself."
msgstr ""

#: ../Doc/c-api/arg.rst:61
msgid ""
"To ensure that the underlying buffer may be safely borrowed, the object's :c:"
"member:`PyBufferProcs.bf_releasebuffer` field must be ``NULL``. This "
"disallows common mutable objects such as :class:`bytearray`, but also some "
"read-only objects such as :class:`memoryview` of :class:`bytes`."
msgstr ""

#: ../Doc/c-api/arg.rst:67
msgid ""
"Besides this ``bf_releasebuffer`` requirement, there is no check to verify "
"whether the input object is immutable (e.g. whether it would honor a request "
"for a writable buffer, or whether another thread can mutate the data)."
msgstr ""

#: ../Doc/c-api/arg.rst:73
msgid ""
"For all ``#`` variants of formats (``s#``, ``y#``, etc.), the macro :c:macro:"
"`PY_SSIZE_T_CLEAN` must be defined before including :file:`Python.h`. On "
"Python 3.9 and older, the type of the length argument is :c:type:"
"`Py_ssize_t` if the :c:macro:`PY_SSIZE_T_CLEAN` macro is defined, or int "
"otherwise."
msgstr ""
"Para todas las variantes de formatos ``#`` (``s#``, ``y#``, etc.), la macro :"
"c:macro:`PY_SSIZE_T_CLEAN` tiene que estar definida antes de incluir :file:"
"`Python.h`. En Python 3.9 y versiones anteriores, el tipo del argumento "
"*length* es :c:type:`Py_ssize_t` si la macro :c:macro:`PY_SSIZE_T_CLEAN` "
"está definida, o int si no lo está."

#: ../Doc/c-api/arg.rst:98
msgid "``s`` (:class:`str`) [const char \\*]"
msgstr "``s`` (:class:`str`) [const char \\*]"

#: ../Doc/c-api/arg.rst:81
msgid ""
"Convert a Unicode object to a C pointer to a character string. A pointer to "
"an existing string is stored in the character pointer variable whose address "
"you pass.  The C string is NUL-terminated. The Python string must not "
"contain embedded null code points; if it does, a :exc:`ValueError` exception "
"is raised. Unicode objects are converted to C strings using ``'utf-8'`` "
"encoding. If this conversion fails, a :exc:`UnicodeError` is raised."
msgstr ""
"Convierte un objeto Unicode a un puntero C a una cadena de caracteres. Un "
"puntero a una cadena de caracteres existente se almacena en la variable "
"puntero del carácter cuya dirección se pasa. La cadena de caracteres en C es "
"terminada en NULL. La cadena de caracteres de Python no debe contener puntos "
"de código incrustado nulos; si lo hace, se lanza una excepción :exc:"
"`ValueError`. Los objetos Unicode se convierten en cadenas de caracteres de "
"C utilizando codificación ``'utf-8'``. Si esta conversión fallase lanza un :"
"exc:`UnicodeError`."

#: ../Doc/c-api/arg.rst:90
msgid ""
"This format does not accept :term:`bytes-like objects <bytes-like object>`.  "
"If you want to accept filesystem paths and convert them to C character "
"strings, it is preferable to use the ``O&`` format with :c:func:"
"`PyUnicode_FSConverter` as *converter*."
msgstr ""
"Este formato no acepta :term:`objetos de tipo bytes <bytes-like object>`. Si "
"desea aceptar los caminos del sistema de archivos y convertirlos en cadenas "
"de caracteres C, es preferible utilizar el formato ``O&`` con :func:"
"`PyUnicode_FSConverter` como convertidor."

#: ../Doc/c-api/arg.rst:96
msgid ""
"Previously, :exc:`TypeError` was raised when embedded null code points were "
"encountered in the Python string."
msgstr ""
"Anteriormente, :exc:`TypeError` se lanzó cuando se encontraron puntos de "
"código nulos incrustados en la cadena de caracteres de Python."

#: ../Doc/c-api/arg.rst:104
msgid "``s*`` (:class:`str` or :term:`bytes-like object`) [Py_buffer]"
msgstr "``s*`` (:class:`str` o :term:`bytes-like object`) [Py_buffer]"

#: ../Doc/c-api/arg.rst:101
msgid ""
"This format accepts Unicode objects as well as bytes-like objects. It fills "
"a :c:type:`Py_buffer` structure provided by the caller. In this case the "
"resulting C string may contain embedded NUL bytes. Unicode objects are "
"converted to C strings using ``'utf-8'`` encoding."
msgstr ""
"Este formato acepta objetos Unicode, así como objetos de tipo bytes. Llena "
"una estructura  :c:type:`Py_buffer` proporcionada por la persona que llama. "
"En este caso la cadena de caracteres de C resultante puede contener bytes "
"NUL embebidos. Los objetos Unicode se convierten en cadenas de caracteres C "
"utilizando codificación ``'utf-8'``."

#: ../Doc/c-api/arg.rst:111
msgid ""
"``s#`` (:class:`str`, read-only :term:`bytes-like object`) [const char \\*, :"
"c:type:`Py_ssize_t`]"
msgstr ""
"``s#`` (:class:`str`, :term:`bytes-like object` de sólo lectura) [const char "
"\\*, :c:type:`Py_ssize_t`]"

#: ../Doc/c-api/arg.rst:107
#, fuzzy
msgid ""
"Like ``s*``, except that it provides a :ref:`borrowed buffer <c-arg-borrowed-"
"buffer>`. The result is stored into two C variables, the first one a pointer "
"to a C string, the second one its length. The string may contain embedded "
"null bytes. Unicode objects are converted to C strings using ``'utf-8'`` "
"encoding."
msgstr ""
"Como ``s*``, excepto que no acepta los objetos mutables. El resultado se "
"almacena en dos variables de C, la primera un puntero a una cadena de "
"caracteres C, el segundo es su longitud. La cadena de caracteres puede "
"contener caracteres nulos incrustados. Los objetos Unicode se convierten en "
"cadenas de caracteres C utilizando codificación ``'utf-8'``."

#: ../Doc/c-api/arg.rst:115 ../Doc/c-api/arg.rst:547
msgid "``z`` (:class:`str` or ``None``) [const char \\*]"
msgstr "``z`` (:class:`str` o ``None``) [const char \\*]"

#: ../Doc/c-api/arg.rst:114
msgid ""
"Like ``s``, but the Python object may also be ``None``, in which case the C "
"pointer is set to ``NULL``."
msgstr ""
"Como ``s``, pero el objeto Python también puede ser ``None``, en cuyo caso "
"el puntero C se establece en ``NULL``."

#: ../Doc/c-api/arg.rst:119
msgid ""
"``z*`` (:class:`str`, :term:`bytes-like object` or ``None``) [Py_buffer]"
msgstr ""
"``z*`` (:class:`str`, :term:`bytes-like object` o ``None``) [Py_buffer]"

#: ../Doc/c-api/arg.rst:118
msgid ""
"Like ``s*``, but the Python object may also be ``None``, in which case the "
"``buf`` member of the :c:type:`Py_buffer` structure is set to ``NULL``."
msgstr ""
"Como ``s*``, pero el objeto Python también puede ser ``None``, en cuyo caso "
"el miembro de ``buf`` de la estructura :c:type:`Py_buffer` se establece en "
"``NULL``."

#: ../Doc/c-api/arg.rst:123
msgid ""
"``z#`` (:class:`str`, read-only :term:`bytes-like object` or ``None``) "
"[const char \\*, :c:type:`Py_ssize_t`]"
msgstr ""
"``z#`` (:class:`str`, :term:`bytes-like object` de sólo lectura o ``None``) "
"[const char \\*, :c:type:`Py_ssize_t`]"

#: ../Doc/c-api/arg.rst:122
msgid ""
"Like ``s#``, but the Python object may also be ``None``, in which case the C "
"pointer is set to ``NULL``."
msgstr ""
"Como ``s#``, pero el objeto Python también puede ser ``None``, en cuyo caso "
"el puntero C se establece en ``NULL``."

#: ../Doc/c-api/arg.rst:134
msgid "``y`` (read-only :term:`bytes-like object`) [const char \\*]"
msgstr "``y`` (:term:`bytes-like object` de sólo lectura) [const char \\*]"

#: ../Doc/c-api/arg.rst:126
#, fuzzy
msgid ""
"This format converts a bytes-like object to a C pointer to a :ref:`borrowed "
"<c-arg-borrowed-buffer>` character string; it does not accept Unicode "
"objects.  The bytes buffer must not contain embedded null bytes; if it does, "
"a :exc:`ValueError` exception is raised."
msgstr ""
"Este formato convierte un objeto de tipo bytes a un puntero C a una cadena "
"de caracteres; no acepta objetos Unicode. El búfer de bytes no debe contener "
"bytes nulos incrustados; si lo hace, se lanza una excepción :exc:"
"`ValueError`."

#: ../Doc/c-api/arg.rst:132
msgid ""
"Previously, :exc:`TypeError` was raised when embedded null bytes were "
"encountered in the bytes buffer."
msgstr ""
"Anteriormente, :exc:`TypeError` se lanzó cuando bytes nulos incrustados se "
"encontraron en el buffer de bytes."

#: ../Doc/c-api/arg.rst:139
msgid "``y*`` (:term:`bytes-like object`) [Py_buffer]"
msgstr "``y*`` (:term:`bytes-like object`) [Py_buffer]"

#: ../Doc/c-api/arg.rst:137
msgid ""
"This variant on ``s*`` doesn't accept Unicode objects, only bytes-like "
"objects.  **This is the recommended way to accept binary data.**"
msgstr ""
"Esta variante de ``s*`` no acepta objetos Unicode, solamente los objetos de "
"tipo bytes. **Esta es la forma recomendada para aceptar datos binarios.**"

#: ../Doc/c-api/arg.rst:143
msgid ""
"``y#`` (read-only :term:`bytes-like object`) [const char \\*, :c:type:"
"`Py_ssize_t`]"
msgstr ""
"``y#`` (:term:`bytes-like object` de sólo lectura) [const char \\*, :c:type:"
"`Py_ssize_t`]"

#: ../Doc/c-api/arg.rst:142
msgid ""
"This variant on ``s#`` doesn't accept Unicode objects, only bytes-like "
"objects."
msgstr ""
"Esta variante en ``s#`` no acepta objetos Unicode, solo objetos similares a "
"bytes."

#: ../Doc/c-api/arg.rst:148
msgid "``S`` (:class:`bytes`) [PyBytesObject \\*]"
msgstr "``S`` (:class:`bytes`) [PyBytesObject \\*]"

#: ../Doc/c-api/arg.rst:146
#, fuzzy
msgid ""
"Requires that the Python object is a :class:`bytes` object, without "
"attempting any conversion.  Raises :exc:`TypeError` if the object is not a "
"bytes object.  The C variable may also be declared as :c:expr:`PyObject*`."
msgstr ""
"Requiere que el objeto Python es un objeto :class:`bytes`, sin intentar "
"ninguna conversión. Lanza :exc:`TypeError` si el objeto no es un objeto "
"bytes. La variable C también puede ser declarado como :c:type:`PyObject*`."

#: ../Doc/c-api/arg.rst:153
msgid "``Y`` (:class:`bytearray`) [PyByteArrayObject \\*]"
msgstr "``Y`` (:class:`bytearray`) [PyByteArrayObject \\*]"

#: ../Doc/c-api/arg.rst:151
#, fuzzy
msgid ""
"Requires that the Python object is a :class:`bytearray` object, without "
"attempting any conversion.  Raises :exc:`TypeError` if the object is not a :"
"class:`bytearray` object. The C variable may also be declared as :c:expr:"
"`PyObject*`."
msgstr ""
"Requiere que el objeto Python es un objeto :class:`bytearray`, sin intentar "
"ninguna conversión. Lanza  :exc:`TypeError` si el objeto no es un objeto :"
"class:`bytearray`. La variable C también puede ser declarada como :c:type:"
"`PyObject*`."

#: ../Doc/c-api/arg.rst:158
msgid "``U`` (:class:`str`) [PyObject \\*]"
msgstr "``U`` (:class:`str`) [PyObject \\*]"

#: ../Doc/c-api/arg.rst:156
#, fuzzy
msgid ""
"Requires that the Python object is a Unicode object, without attempting any "
"conversion.  Raises :exc:`TypeError` if the object is not a Unicode object.  "
"The C variable may also be declared as :c:expr:`PyObject*`."
msgstr ""
"Requiere que el objeto Python es un objeto Unicode, sin intentar ninguna "
"conversión. Lanza :exc:`TypeError` si el objeto no es un objeto Unicode. La "
"variable C también puede ser declarada como :c:type:`PyObject*`."

#: ../Doc/c-api/arg.rst:164
msgid "``w*`` (read-write :term:`bytes-like object`) [Py_buffer]"
msgstr "``w*`` (:term:`bytes-like object` de lectura y escritura) [Py_buffer]"

#: ../Doc/c-api/arg.rst:161
msgid ""
"This format accepts any object which implements the read-write buffer "
"interface. It fills a :c:type:`Py_buffer` structure provided by the caller. "
"The buffer may contain embedded null bytes. The caller have to call :c:func:"
"`PyBuffer_Release` when it is done with the buffer."
msgstr ""
"Este formato acepta cualquier objeto que implemente la interfaz del búfer de "
"lectura-escritura. Llena la estructura :c:type:`Py_buffer` proporcionada por "
"quien llama. El búfer puede contener bytes nulos incrustados. Quien llama "
"tiene que llamar :c:func:`PyBuffer_Release` cuando termina con el búfer."

#: ../Doc/c-api/arg.rst:181
msgid "``es`` (:class:`str`) [const char \\*encoding, char \\*\\*buffer]"
msgstr "``es`` (:class:`str`) [const char \\*encoding, char \\*\\*buffer]"

#: ../Doc/c-api/arg.rst:167
msgid ""
"This variant on ``s`` is used for encoding Unicode into a character buffer. "
"It only works for encoded data without embedded NUL bytes."
msgstr ""
"Esta variante en ``s`` se usa para codificar Unicode en un búfer de "
"caracteres. Solo funciona para datos codificados sin bytes NUL integrados."

#: ../Doc/c-api/arg.rst:170
#, fuzzy
msgid ""
"This format requires two arguments.  The first is only used as input, and "
"must be a :c:expr:`const char*` which points to the name of an encoding as a "
"NUL-terminated string, or ``NULL``, in which case ``'utf-8'`` encoding is "
"used. An exception is raised if the named encoding is not known to Python.  "
"The second argument must be a :c:expr:`char**`; the value of the pointer it "
"references will be set to a buffer with the contents of the argument text. "
"The text will be encoded in the encoding specified by the first argument."
msgstr ""
"Este formato requiere dos argumentos. El primero solo se usa como entrada, y "
"debe ser :c:type:`const char*` que apunta al nombre de una codificación como "
"una cadena de caracteres terminada en NUL, o ``NULL``, en cuyo caso se "
"utiliza la codificación ``'utf-8'``. Se lanza una excepción si Python no "
"conoce la codificación con nombre. El segundo argumento debe ser :c:type:"
"`char**`; el valor del puntero al que hace referencia se establecerá en un "
"búfer con el contenido del texto del argumento. El texto se codificará en la "
"codificación especificada por el primer argumento."

#: ../Doc/c-api/arg.rst:178
msgid ""
":c:func:`PyArg_ParseTuple` will allocate a buffer of the needed size, copy "
"the encoded data into this buffer and adjust *\\*buffer* to reference the "
"newly allocated storage.  The caller is responsible for calling :c:func:"
"`PyMem_Free` to free the allocated buffer after use."
msgstr ""
":c:func:`PyArg_ParseTuple` asignará un búfer del tamaño necesitado, copiará "
"los datos codificados en este búfer y ajustará *\\*buffer* para referenciar "
"el nuevo almacenamiento asignado. Quien llama es responsable para llamar :c:"
"func:`PyMem_Free` para liberar el búfer asignado después de su uso."

#: ../Doc/c-api/arg.rst:186
msgid ""
"``et`` (:class:`str`, :class:`bytes` or :class:`bytearray`) [const char "
"\\*encoding, char \\*\\*buffer]"
msgstr ""
"``et`` (:class:`str`, :class:`bytes` o :class:`bytearray`) [const char "
"\\*encoding, char \\*\\*buffer]"

#: ../Doc/c-api/arg.rst:184
msgid ""
"Same as ``es`` except that byte string objects are passed through without "
"recoding them.  Instead, the implementation assumes that the byte string "
"object uses the encoding passed in as parameter."
msgstr ""
"Igual que ``es``, excepto que los objetos de cadena de caracteres de bytes "
"se pasan sin recodificarlos. En cambio, la implementación supone que el "
"objeto de cadena de caracteres de bytes utiliza la codificación que se pasa "
"como parámetro."

#: ../Doc/c-api/arg.rst:217
msgid ""
"``es#`` (:class:`str`) [const char \\*encoding, char \\*\\*buffer, :c:type:"
"`Py_ssize_t` \\*buffer_length]"
msgstr ""
"``es#`` (:class:`str`) [const char \\*encoding, char \\*\\*buffer, :c:type:"
"`Py_ssize_t` \\*buffer_length]"

#: ../Doc/c-api/arg.rst:189
msgid ""
"This variant on ``s#`` is used for encoding Unicode into a character buffer. "
"Unlike the ``es`` format, this variant allows input data which contains NUL "
"characters."
msgstr ""
"Esta variante en ``s#`` se usa para codificar Unicode en un búfer de "
"caracteres. A diferencia del formato ``es``, esta variante permite datos de "
"entrada que contienen caracteres NUL."

#: ../Doc/c-api/arg.rst:193
#, fuzzy
msgid ""
"It requires three arguments.  The first is only used as input, and must be "
"a :c:expr:`const char*` which points to the name of an encoding as a NUL-"
"terminated string, or ``NULL``, in which case ``'utf-8'`` encoding is used. "
"An exception is raised if the named encoding is not known to Python.  The "
"second argument must be a :c:expr:`char**`; the value of the pointer it "
"references will be set to a buffer with the contents of the argument text. "
"The text will be encoded in the encoding specified by the first argument. "
"The third argument must be a pointer to an integer; the referenced integer "
"will be set to the number of bytes in the output buffer."
msgstr ""
"Requiere tres argumentos. El primero solo se usa como entrada, y debe ser :c:"
"type:`const char*` que apunta al nombre de una codificación como una cadena "
"de caracteres terminada en NUL, o ``NULL``, en cuyo caso ``Se utiliza la "
"codificación 'utf-8'``. Se lanza una excepción si Python no conoce la "
"codificación con nombre. El segundo argumento debe ser :c:type:`char**`; El "
"valor del puntero al que hace referencia se establecerá en un búfer con el "
"contenido del texto del argumento. El texto se codificará en la codificación "
"especificada por el primer argumento. El tercer argumento debe ser un "
"puntero a un entero; el número entero referenciado se establecerá en el "
"número de bytes en el búfer de salida."

#: ../Doc/c-api/arg.rst:203
msgid "There are two modes of operation:"
msgstr "Hay dos modos de operación:"

#: ../Doc/c-api/arg.rst:205
msgid ""
"If *\\*buffer* points a ``NULL`` pointer, the function will allocate a "
"buffer of the needed size, copy the encoded data into this buffer and set "
"*\\*buffer* to reference the newly allocated storage.  The caller is "
"responsible for calling :c:func:`PyMem_Free` to free the allocated buffer "
"after usage."
msgstr ""
"Si *\\*buffer* señala un puntero ``NULL``, la función asignará un búfer del "
"tamaño necesario, copiará los datos codificados en este búfer y configurará "
"*\\*buffer* para hacer referencia al almacenamiento recién asignado. Quien "
"llama es responsable de llamar a :c:func:`PyMem_Free` para liberar el búfer "
"asignado después del uso."

#: ../Doc/c-api/arg.rst:210
msgid ""
"If *\\*buffer* points to a non-``NULL`` pointer (an already allocated "
"buffer), :c:func:`PyArg_ParseTuple` will use this location as the buffer and "
"interpret the initial value of *\\*buffer_length* as the buffer size.  It "
"will then copy the encoded data into the buffer and NUL-terminate it.  If "
"the buffer is not large enough, a :exc:`ValueError` will be set."
msgstr ""
"Si *\\*buffer* apunta a un puntero no ``NULL`` (un búfer ya asignado), :c:"
"func:`PyArg_ParseTuple` usará esta ubicación como el búfer e interpretará el "
"valor inicial de *\\*buffer_length* como el tamaño del búfer. Luego copiará "
"los datos codificados en el búfer y los terminará en NUL. Si el búfer no es "
"lo suficientemente grande, se establecerá a :exc:`ValueError`."

#: ../Doc/c-api/arg.rst:216
msgid ""
"In both cases, *\\*buffer_length* is set to the length of the encoded data "
"without the trailing NUL byte."
msgstr ""
"En ambos casos, *\\*buffer_length* se establece a la longitud de los datos "
"codificados sin el byte NUL final."

#: ../Doc/c-api/arg.rst:222
msgid ""
"``et#`` (:class:`str`, :class:`bytes` or :class:`bytearray`) [const char "
"\\*encoding, char \\*\\*buffer, :c:type:`Py_ssize_t` \\*buffer_length]"
msgstr ""
"``et#`` (:class:`str`, :class:`bytes` o :class:`bytearray`) [const char "
"\\*encoding, char \\*\\*buffer, :c:type:`Py_ssize_t` \\*buffer_length]"

#: ../Doc/c-api/arg.rst:220
msgid ""
"Same as ``es#`` except that byte string objects are passed through without "
"recoding them. Instead, the implementation assumes that the byte string "
"object uses the encoding passed in as parameter."
msgstr ""
"Igual que ``es#``, excepto que los objetos de cadena de caracteres de bytes "
"se pasan sin recodificarlos. En cambio, la implementación supone que el "
"objeto de cadena de caracteres de bytes utiliza la codificación que se pasa "
"como parámetro."

#: ../Doc/c-api/arg.rst:224
msgid ""
"``u``, ``u#``, ``Z``, and ``Z#`` are removed because they used a legacy "
"``Py_UNICODE*`` representation."
msgstr ""

#: ../Doc/c-api/arg.rst:230
msgid "Numbers"
msgstr "Números"

#: ../Doc/c-api/arg.rst:234
msgid "``b`` (:class:`int`) [unsigned char]"
msgstr "``b`` (:class:`int`) [unsigned char]"

#: ../Doc/c-api/arg.rst:233
#, fuzzy
msgid ""
"Convert a nonnegative Python integer to an unsigned tiny int, stored in a C :"
"c:expr:`unsigned char`."
msgstr ""
"Convierte un entero de Python no negativo en un pequeño int sin signo, "
"almacenado en un :c:type:`unsigned char` de C."

#: ../Doc/c-api/arg.rst:238 ../Doc/c-api/arg.rst:581
msgid "``B`` (:class:`int`) [unsigned char]"
msgstr "``B`` (:class:`int`) [unsigned char]"

#: ../Doc/c-api/arg.rst:237
#, fuzzy
msgid ""
"Convert a Python integer to a tiny int without overflow checking, stored in "
"a C :c:expr:`unsigned char`."
msgstr ""
"Convierte un entero de Python en un pequeño int sin comprobación de "
"desbordamiento, almacenado en un :c:type:`unsigned char` de C."

#: ../Doc/c-api/arg.rst:241 ../Doc/c-api/arg.rst:575
msgid "``h`` (:class:`int`) [short int]"
msgstr "``h`` (:class:`int`) [short int]"

#: ../Doc/c-api/arg.rst:241
#, fuzzy
msgid "Convert a Python integer to a C :c:expr:`short int`."
msgstr "Convierte un entero de Python a un :c:type:`short int` de C."

#: ../Doc/c-api/arg.rst:245 ../Doc/c-api/arg.rst:584
msgid "``H`` (:class:`int`) [unsigned short int]"
msgstr "``H`` (:class:`int`) [unsigned short int]"

#: ../Doc/c-api/arg.rst:244
#, fuzzy
msgid ""
"Convert a Python integer to a C :c:expr:`unsigned short int`, without "
"overflow checking."
msgstr ""
"Convierte un entero de Python a un :c:type:`unsigned short int` de C, sin "
"verificación de desbordamiento."

#: ../Doc/c-api/arg.rst:248 ../Doc/c-api/arg.rst:569
msgid "``i`` (:class:`int`) [int]"
msgstr "``i`` (:class:`int`) [int]"

#: ../Doc/c-api/arg.rst:248
#, fuzzy
msgid "Convert a Python integer to a plain C :c:expr:`int`."
msgstr "Convierte un entero Python a un :c:type:`int` de C plano."

#: ../Doc/c-api/arg.rst:252 ../Doc/c-api/arg.rst:587
msgid "``I`` (:class:`int`) [unsigned int]"
msgstr "``I`` (:class:`int`) [unsigned int]"

#: ../Doc/c-api/arg.rst:251
#, fuzzy
msgid ""
"Convert a Python integer to a C :c:expr:`unsigned int`, without overflow "
"checking."
msgstr ""
"Convierte un entero de Python a un :c:type:`unsigned int` de C, sin "
"verificación de desbordamiento."

#: ../Doc/c-api/arg.rst:255 ../Doc/c-api/arg.rst:578
msgid "``l`` (:class:`int`) [long int]"
msgstr "``l`` (:class:`int`) [long int]"

#: ../Doc/c-api/arg.rst:255
#, fuzzy
msgid "Convert a Python integer to a C :c:expr:`long int`."
msgstr "Convierte un entero Python a un :c:type:`long int` de C."

#: ../Doc/c-api/arg.rst:259 ../Doc/c-api/arg.rst:590
msgid "``k`` (:class:`int`) [unsigned long]"
msgstr "``k`` (:class:`int`) [unsigned long]"

#: ../Doc/c-api/arg.rst:258
#, fuzzy
msgid ""
"Convert a Python integer to a C :c:expr:`unsigned long` without overflow "
"checking."
msgstr ""
"Convierte un entero de Python a un :c:type:`unsigned long` de C, sin "
"verificación de desbordamiento."

#: ../Doc/c-api/arg.rst:262 ../Doc/c-api/arg.rst:593
msgid "``L`` (:class:`int`) [long long]"
msgstr "``L`` (:class:`int`) [long long]"

#: ../Doc/c-api/arg.rst:262
#, fuzzy
msgid "Convert a Python integer to a C :c:expr:`long long`."
msgstr "Convierte un entero de Python a un :c:type:`long long` de C."

#: ../Doc/c-api/arg.rst:266 ../Doc/c-api/arg.rst:596
msgid "``K`` (:class:`int`) [unsigned long long]"
msgstr "``K`` (:class:`int`) [unsigned long long]"

#: ../Doc/c-api/arg.rst:265
#, fuzzy
msgid ""
"Convert a Python integer to a C :c:expr:`unsigned long long` without "
"overflow checking."
msgstr ""
"Convierte un entero de Python a un :c:type:`unsigned long long` de C, sin "
"verificación de desbordamiento."

#: ../Doc/c-api/arg.rst:269 ../Doc/c-api/arg.rst:599
#, fuzzy
msgid "``n`` (:class:`int`) [:c:type:`Py_ssize_t`]"
msgstr "``n`` (:class:`int`) [Py_ssize_t]"

#: ../Doc/c-api/arg.rst:269
msgid "Convert a Python integer to a C :c:type:`Py_ssize_t`."
msgstr "Convierte un entero de Python a un :c:type:`Py_ssize_t` de C."

#: ../Doc/c-api/arg.rst:276
msgid "``c`` (:class:`bytes` or :class:`bytearray` of length 1) [char]"
msgstr "``c`` (:class:`bytes` o :class:`bytearray` de largo 1) [char]"

#: ../Doc/c-api/arg.rst:272
#, fuzzy
msgid ""
"Convert a Python byte, represented as a :class:`bytes` or :class:`bytearray` "
"object of length 1, to a C :c:expr:`char`."
msgstr ""
"Convierte un byte de Python, representado como un objeto :class:`bytes` o :"
"class:`bytearray` de longitud 1, a un :c:type:`char` de C."

#: ../Doc/c-api/arg.rst:275
msgid "Allow :class:`bytearray` objects."
msgstr "Permite objetos :class:`bytearray`."

#: ../Doc/c-api/arg.rst:280 ../Doc/c-api/arg.rst:607
msgid "``C`` (:class:`str` of length 1) [int]"
msgstr "``C`` (:class:`str` de largo 1) [int]"

#: ../Doc/c-api/arg.rst:279
#, fuzzy
msgid ""
"Convert a Python character, represented as a :class:`str` object of length "
"1, to a C :c:expr:`int`."
msgstr ""
"Convierte un carácter Python, representado como un objeto :class:`str` de "
"longitud 1, a un tipo :c:type:`int` de C."

#: ../Doc/c-api/arg.rst:283 ../Doc/c-api/arg.rst:613
msgid "``f`` (:class:`float`) [float]"
msgstr "``f`` (:class:`float`) [float]"

#: ../Doc/c-api/arg.rst:283
#, fuzzy
msgid "Convert a Python floating point number to a C :c:expr:`float`."
msgstr ""
"Convierte un número de punto flotante de Python a un :c:type:`float` de C."

#: ../Doc/c-api/arg.rst:286 ../Doc/c-api/arg.rst:610
msgid "``d`` (:class:`float`) [double]"
msgstr "``d`` (:class:`float`) [double]"

#: ../Doc/c-api/arg.rst:286
#, fuzzy
msgid "Convert a Python floating point number to a C :c:expr:`double`."
msgstr ""
"Convierte un número de punto flotante de Python a un :c:type:`double` de C."

#: ../Doc/c-api/arg.rst:289
msgid "``D`` (:class:`complex`) [Py_complex]"
msgstr "``D`` (:class:`complex`) [Py_complex]"

#: ../Doc/c-api/arg.rst:289
msgid "Convert a Python complex number to a C :c:type:`Py_complex` structure."
msgstr ""
"Convierte un número complejo de Python en una estructura :c:type:"
"`Py_complex` de C."

#: ../Doc/c-api/arg.rst:292
msgid "Other objects"
msgstr "Otros objetos"

#: ../Doc/c-api/arg.rst:299 ../Doc/c-api/arg.rst:626
msgid "``O`` (object) [PyObject \\*]"
msgstr "``O`` (object) [PyObject \\*]"

#: ../Doc/c-api/arg.rst:295
#, fuzzy
msgid ""
"Store a Python object (without any conversion) in a C object pointer.  The C "
"program thus receives the actual object that was passed.  A new :term:"
"`strong reference` to the object is not created (i.e. its reference count is "
"not increased). The pointer stored is not ``NULL``."
msgstr ""
"Almacena un objeto Python (sin ninguna conversión) en un puntero de objeto "
"C. El programa C recibe así el objeto real que se pasó. El recuento de "
"referencia del objeto no aumenta. El puntero almacenado no es ``NULL``."

#: ../Doc/c-api/arg.rst:306
msgid "``O!`` (object) [*typeobject*, PyObject \\*]"
msgstr "``O!`` (object) [*typeobject*, PyObject \\*]"

#: ../Doc/c-api/arg.rst:302
#, fuzzy
msgid ""
"Store a Python object in a C object pointer.  This is similar to ``O``, but "
"takes two C arguments: the first is the address of a Python type object, the "
"second is the address of the C variable (of type :c:expr:`PyObject*`) into "
"which the object pointer is stored.  If the Python object does not have the "
"required type, :exc:`TypeError` is raised."
msgstr ""
"Almacena un objeto Python en un puntero de objeto C. Esto es similar a "
"``O``, pero toma dos argumentos C: el primero es la dirección de un objeto "
"de tipo Python, el segundo es la dirección de la variable C (de tipo :c:type:"
"`PyObject*`) en el que se almacena el puntero del objeto. Si el objeto "
"Python no tiene el tipo requerido, se lanza :exc:`TypeError`."

#: ../Doc/c-api/arg.rst:331 ../Doc/c-api/arg.rst:640
msgid "``O&`` (object) [*converter*, *anything*]"
msgstr "``O&`` (object) [*converter*, *anything*]"

#: ../Doc/c-api/arg.rst:311
#, fuzzy
msgid ""
"Convert a Python object to a C variable through a *converter* function.  "
"This takes two arguments: the first is a function, the second is the address "
"of a C variable (of arbitrary type), converted to :c:expr:`void *`.  The "
"*converter* function in turn is called as follows::"
msgstr ""
"Convierte un objeto Python en una variable C a través de una función "
"*converter*. Esto requiere dos argumentos: el primero es una función, el "
"segundo es la dirección de una variable C (de tipo arbitrario), convertida "
"a :c:type:`void *`. La función *converter* a su vez se llama de la siguiente "
"manera::"

#: ../Doc/c-api/arg.rst:318
#, fuzzy
msgid ""
"where *object* is the Python object to be converted and *address* is the :c:"
"expr:`void*` argument that was passed to the ``PyArg_Parse*`` function. The "
"returned *status* should be ``1`` for a successful conversion and ``0`` if "
"the conversion has failed.  When the conversion fails, the *converter* "
"function should raise an exception and leave the content of *address* "
"unmodified."
msgstr ""
"donde *object* es el objeto de Python a convertir y *address* es el "
"argumento :c:type:`void*` que se pasó a la función :c:func:`PyArg_Parse\\*`. "
"El *status* retornado debe ser ``1`` para una conversión exitosa y ``0`` si "
"la conversión ha fallado. Cuando la conversión falla, la función *converter* "
"debería lanzar una excepción y dejar el contenido de *address* sin modificar."

#: ../Doc/c-api/arg.rst:324
msgid ""
"If the *converter* returns ``Py_CLEANUP_SUPPORTED``, it may get called a "
"second time if the argument parsing eventually fails, giving the converter a "
"chance to release any memory that it had already allocated. In this second "
"call, the *object* parameter will be ``NULL``; *address* will have the same "
"value as in the original call."
msgstr ""
"Si el *converter* retorna ``Py_CLEANUP_SUPPORTED``, se puede llamar por "
"segunda vez si el análisis del argumento finalmente falla, dando al "
"convertidor la oportunidad de liberar cualquier memoria que ya haya "
"asignado. En esta segunda llamada, el parámetro *object* será ``NULL``; "
"*address* tendrá el mismo valor que en la llamada original."

#: ../Doc/c-api/arg.rst:330
msgid "``Py_CLEANUP_SUPPORTED`` was added."
msgstr "``Py_CLEANUP_SUPPORTED`` fue agregada."

#: ../Doc/c-api/arg.rst:340
msgid "``p`` (:class:`bool`) [int]"
msgstr "``p`` (:class:`bool`) [int]"

#: ../Doc/c-api/arg.rst:334
msgid ""
"Tests the value passed in for truth (a boolean **p**\\ redicate) and "
"converts the result to its equivalent C true/false integer value. Sets the "
"int to ``1`` if the expression was true and ``0`` if it was false. This "
"accepts any valid Python value.  See :ref:`truth` for more information about "
"how Python tests values for truth."
msgstr ""
"Prueba el valor pasado por verdad (un booleano predicado **p**) y convierte "
"el resultado a su valor entero C verdadero/falso entero equivalente. "
"Establece int en ``1`` si la expresión era verdadera y ``0`` si era falsa. "
"Esto acepta cualquier valor válido de Python. Consulte :ref:`truth` para "
"obtener más información sobre cómo Python prueba los valores por verdad."

#: ../Doc/c-api/arg.rst:345 ../Doc/c-api/arg.rst:643
msgid "``(items)`` (:class:`tuple`) [*matching-items*]"
msgstr "``(items)`` (:class:`tuple`) [*matching-items*]"

#: ../Doc/c-api/arg.rst:343
msgid ""
"The object must be a Python sequence whose length is the number of format "
"units in *items*.  The C arguments must correspond to the individual format "
"units in *items*.  Format units for sequences may be nested."
msgstr ""
"El objeto debe ser una secuencia de Python cuya longitud es el número de "
"unidades de formato en *items*. Los argumentos C deben corresponder a las "
"unidades de formato individuales en *items*. Las unidades de formato para "
"secuencias pueden estar anidadas."

#: ../Doc/c-api/arg.rst:347
#, fuzzy
msgid ""
"It is possible to pass \"long\" integers (integers whose value exceeds the "
"platform's :c:macro:`LONG_MAX`) however no proper range checking is done --- "
"the most significant bits are silently truncated when the receiving field is "
"too small to receive the value (actually, the semantics are inherited from "
"downcasts in C --- your mileage may vary)."
msgstr ""
"Es posible pasar enteros \"largos\" (enteros cuyo valor excede el de la "
"plataforma :const:`LONG_MAX`), sin embargo, no se realiza una verificación "
"de rango adecuada --- los bits más significativos se truncan silenciosamente "
"cuando el campo receptor es demasiado pequeño para recibir el valor (en "
"realidad, la semántica se hereda de las descargas en C --- su kilometraje "
"puede variar)."

#: ../Doc/c-api/arg.rst:353
msgid ""
"A few other characters have a meaning in a format string.  These may not "
"occur inside nested parentheses.  They are:"
msgstr ""
"Algunos otros caracteres tienen un significado en una cadena de formato. "
"Esto puede no ocurrir dentro de paréntesis anidados. Son:"

#: ../Doc/c-api/arg.rst:361
msgid "``|``"
msgstr "``|``"

#: ../Doc/c-api/arg.rst:357
msgid ""
"Indicates that the remaining arguments in the Python argument list are "
"optional. The C variables corresponding to optional arguments should be "
"initialized to their default value --- when an optional argument is not "
"specified, :c:func:`PyArg_ParseTuple` does not touch the contents of the "
"corresponding C variable(s)."
msgstr ""
"Indica que los argumentos restantes en la lista de argumentos de Python son "
"opcionales. Las variables C correspondientes a argumentos opcionales deben "
"inicializarse a su valor predeterminado --- cuando no se especifica un "
"argumento opcional, :c:func:`PyArg_ParseTuple` no toca el contenido de las "
"variables C correspondientes."

#: ../Doc/c-api/arg.rst:370
msgid "``$``"
msgstr "``$``"

#: ../Doc/c-api/arg.rst:364
msgid ""
":c:func:`PyArg_ParseTupleAndKeywords` only: Indicates that the remaining "
"arguments in the Python argument list are keyword-only.  Currently, all "
"keyword-only arguments must also be optional arguments, so ``|`` must always "
"be specified before ``$`` in the format string."
msgstr ""
":c:func:`PyArg_ParseTupleAndKeywords` solamente: indica que los argumentos "
"restantes en la lista de argumentos de Python son solo palabras clave. "
"Actualmente, todos los argumentos de solo palabras clave también deben ser "
"argumentos opcionales, por lo que ``|`` siempre debe especificarse antes de "
"``$`` en la cadena de formato."

#: ../Doc/c-api/arg.rst:375
msgid "``:``"
msgstr "``:``"

#: ../Doc/c-api/arg.rst:373
msgid ""
"The list of format units ends here; the string after the colon is used as "
"the function name in error messages (the \"associated value\" of the "
"exception that :c:func:`PyArg_ParseTuple` raises)."
msgstr ""
"La lista de unidades de formato termina aquí; la cadena después de los dos "
"puntos se usa como el nombre de la función en los mensajes de error (el "
"\"valor asociado\" de la excepción que :c:func:`PyArg_ParseTuple` lanza)."

#: ../Doc/c-api/arg.rst:380
msgid "``;``"
msgstr "``;``"

#: ../Doc/c-api/arg.rst:378
msgid ""
"The list of format units ends here; the string after the semicolon is used "
"as the error message *instead* of the default error message.  ``:`` and ``;"
"`` mutually exclude each other."
msgstr ""
"La lista de unidades de formato termina aquí; la cadena después del punto y "
"coma se usa como mensaje de error *en lugar de* del mensaje de error "
"predeterminado. ``:`` y ``;`` se excluyen mutuamente."

#: ../Doc/c-api/arg.rst:382
#, fuzzy
msgid ""
"Note that any Python object references which are provided to the caller are "
"*borrowed* references; do not release them (i.e. do not decrement their "
"reference count)!"
msgstr ""
"Tenga en cuenta que las referencias de objetos de Python que se proporcionan "
"a la persona que llama son referencias *prestadas* (*borrowed*); ¡no "
"disminuya su conteo de referencias!"

#: ../Doc/c-api/arg.rst:386
msgid ""
"Additional arguments passed to these functions must be addresses of "
"variables whose type is determined by the format string; these are used to "
"store values from the input tuple.  There are a few cases, as described in "
"the list of format units above, where these parameters are used as input "
"values; they should match what is specified for the corresponding format "
"unit in that case."
msgstr ""
"Los argumentos adicionales pasados a estas funciones deben ser direcciones "
"de variables cuyo tipo está determinado por la cadena de formato; Estos se "
"utilizan para almacenar valores de la tupla de entrada. Hay algunos casos, "
"como se describe en la lista de unidades de formato anterior, donde estos "
"parámetros se utilizan como valores de entrada; deben coincidir con lo "
"especificado para la unidad de formato correspondiente en ese caso."

#: ../Doc/c-api/arg.rst:392
#, fuzzy
msgid ""
"For the conversion to succeed, the *arg* object must match the format and "
"the format must be exhausted.  On success, the ``PyArg_Parse*`` functions "
"return true, otherwise they return false and raise an appropriate exception. "
"When the ``PyArg_Parse*`` functions fail due to conversion failure in one of "
"the format units, the variables at the addresses corresponding to that and "
"the following format units are left untouched."
msgstr ""
"Para que la conversión tenga éxito, el objeto *arg* debe coincidir con el "
"formato y el formato debe estar agotado. En caso de éxito, las funciones :c:"
"func:`PyArg_Parse\\*` retornan verdadero; de lo contrario, retornan falso y "
"generan una excepción apropiada. Cuando las funciones :c:func:"
"`PyArg_Parse\\*` fallan debido a un error de conversión en una de las "
"unidades de formato, las variables en las direcciones correspondientes y las "
"siguientes unidades de formato quedan intactas."

#: ../Doc/c-api/arg.rst:401
msgid "API Functions"
msgstr "Funciones API"

#: ../Doc/c-api/arg.rst:405
msgid ""
"Parse the parameters of a function that takes only positional parameters "
"into local variables.  Returns true on success; on failure, it returns false "
"and raises the appropriate exception."
msgstr ""
"Analiza los parámetros de una función que solo toma parámetros posicionales "
"en variables locales. Retorna verdadero en el éxito; en caso de fallo, "
"retorna falso y lanza la excepción apropiada."

#: ../Doc/c-api/arg.rst:412
msgid ""
"Identical to :c:func:`PyArg_ParseTuple`, except that it accepts a va_list "
"rather than a variable number of arguments."
msgstr ""
"Idéntico a :c:func:`PyArg_ParseTuple`, excepto que acepta una *va_list* en "
"lugar de un número variable de argumentos ."

#: ../Doc/c-api/arg.rst:418
msgid ""
"Parse the parameters of a function that takes both positional and keyword "
"parameters into local variables.  The *keywords* argument is a ``NULL``-"
"terminated array of keyword parameter names.  Empty names denote :ref:"
"`positional-only parameters <positional-only_parameter>`. Returns true on "
"success; on failure, it returns false and raises the appropriate exception."
msgstr ""
"Analiza los parámetros de una función que toma parámetros posicionales y de "
"palabras clave en variables locales. El argumento *keywords* es un arreglo "
"terminado en ``NULL`` de nombres de parámetros de palabras clave. Los "
"nombres vacíos denotan :ref:`parámetros solo posicionales <positional-"
"only_parameter>`. Retorna verdadero cuando hay éxito; en caso de fallo, "
"retorna falso y lanza la excepción apropiada."

#: ../Doc/c-api/arg.rst:425
msgid ""
"Added support for :ref:`positional-only parameters <positional-"
"only_parameter>`."
msgstr ""
"Soporte agregado para :ref:`sólo parámetros posicionales <positional-"
"only_parameter>`."

#: ../Doc/c-api/arg.rst:432
msgid ""
"Identical to :c:func:`PyArg_ParseTupleAndKeywords`, except that it accepts a "
"va_list rather than a variable number of arguments."
msgstr ""
"Idéntico a :c:func:`PyArg_ParseTupleAndKeywords`, excepto que acepta una "
"*va_list* en lugar de un número variable de argumentos."

#: ../Doc/c-api/arg.rst:438
msgid ""
"Ensure that the keys in the keywords argument dictionary are strings.  This "
"is only needed if :c:func:`PyArg_ParseTupleAndKeywords` is not used, since "
"the latter already does this check."
msgstr ""
"Asegúrese de que las claves en el diccionario de argumentos de palabras "
"clave son cadenas. Esto solo es necesario si :c:func:"
"`PyArg_ParseTupleAndKeywords` no se utiliza, ya que este último ya hace esta "
"comprobación."

#: ../Doc/c-api/arg.rst:448
msgid ""
"Function used to deconstruct the argument lists of \"old-style\" functions "
"--- these are functions which use the :const:`METH_OLDARGS` parameter "
"parsing method, which has been removed in Python 3.  This is not recommended "
"for use in parameter parsing in new code, and most code in the standard "
"interpreter has been modified to no longer use this for that purpose.  It "
"does remain a convenient way to decompose other tuples, however, and may "
"continue to be used for that purpose."
msgstr ""
"Función utilizada para deconstruir las listas de argumentos de las funciones "
"de \"estilo antiguo\" --- estas son funciones que usan el método de análisis "
"de parámetros :const:`METH_OLDARGS`, que se ha eliminado en Python 3. No se "
"recomienda su uso en el análisis de parámetros en código nuevo, y la mayoría "
"del código en el intérprete estándar se ha modificado para que ya no se use "
"para ese propósito. Sin embargo, sigue siendo una forma conveniente de "
"descomponer otras tuplas, y puede continuar usándose para ese propósito."

#: ../Doc/c-api/arg.rst:459
#, fuzzy
msgid ""
"A simpler form of parameter retrieval which does not use a format string to "
"specify the types of the arguments.  Functions which use this method to "
"retrieve their parameters should be declared as :c:macro:`METH_VARARGS` in "
"function or method tables.  The tuple containing the actual parameters "
"should be passed as *args*; it must actually be a tuple.  The length of the "
"tuple must be at least *min* and no more than *max*; *min* and *max* may be "
"equal.  Additional arguments must be passed to the function, each of which "
"should be a pointer to a :c:expr:`PyObject*` variable; these will be filled "
"in with the values from *args*; they will contain :term:`borrowed references "
"<borrowed reference>`. The variables which correspond to optional parameters "
"not given by *args* will not be filled in; these should be initialized by "
"the caller. This function returns true on success and false if *args* is not "
"a tuple or contains the wrong number of elements; an exception will be set "
"if there was a failure."
msgstr ""
"Una forma más simple de recuperación de parámetros que no utiliza una cadena "
"de formato para especificar los tipos de argumentos. Las funciones que "
"utilizan este método para recuperar sus parámetros deben declararse como :"
"const:`METH_VARARGS` en las tablas de funciones o métodos. La tupla que "
"contiene los parámetros reales debe pasarse como *args*; en realidad debe "
"ser una tupla. La longitud de la tupla debe ser al menos *min* y no más de "
"*max*; *min* y *max* pueden ser iguales. Se deben pasar argumentos "
"adicionales a la función, cada uno de los cuales debe ser un puntero a una "
"variable :c:type:`PyObject*`; estos se completarán con los valores de "
"*args*; contendrán :term:`referencias prestadas <borrowed reference>`. Las "
"variables que corresponden a parámetros opcionales no dados por *args* no se "
"completarán; estos deben ser inicializados por quien llama. Esta función "
"retorna verdadero en caso de éxito y falso si *args* no es una tupla o "
"contiene el número incorrecto de elementos; se establecerá una excepción si "
"hubo una falla."

#: ../Doc/c-api/arg.rst:474
#, fuzzy
msgid ""
"This is an example of the use of this function, taken from the sources for "
"the :mod:`!_weakref` helper module for weak references::"
msgstr ""
"Este es un ejemplo del uso de esta función, tomado de las fuentes del módulo "
"auxiliar :mod:`_weakref` para referencias débiles::"

#: ../Doc/c-api/arg.rst:490
msgid ""
"The call to :c:func:`PyArg_UnpackTuple` in this example is entirely "
"equivalent to this call to :c:func:`PyArg_ParseTuple`::"
msgstr ""
"La llamada a :c:func:`PyArg_UnpackTuple` en este ejemplo es completamente "
"equivalente a esta llamada a :c:func:`PyArg_ParseTuple`::"

#: ../Doc/c-api/arg.rst:498
msgid "Building values"
msgstr "Construyendo valores"

#: ../Doc/c-api/arg.rst:502
#, fuzzy
msgid ""
"Create a new value based on a format string similar to those accepted by the "
"``PyArg_Parse*`` family of functions and a sequence of values.  Returns the "
"value or ``NULL`` in the case of an error; an exception will be raised if "
"``NULL`` is returned."
msgstr ""
"Crea un nuevo valor basado en una cadena de formato similar a los aceptados "
"por la familia de funciones :c:func:`PyArg_Parse\\*` y una secuencia de "
"valores. Retorna el valor o ``NULL`` en caso de error; se lanzará una "
"excepción si se retorna ``NULL``."

#: ../Doc/c-api/arg.rst:507
msgid ""
":c:func:`Py_BuildValue` does not always build a tuple.  It builds a tuple "
"only if its format string contains two or more format units.  If the format "
"string is empty, it returns ``None``; if it contains exactly one format "
"unit, it returns whatever object is described by that format unit.  To force "
"it to return a tuple of size 0 or one, parenthesize the format string."
msgstr ""
":c:func:`Py_BuildValue` no siempre genera una tupla. Construye una tupla "
"solo si su cadena de formato contiene dos o más unidades de formato. Si la "
"cadena de formato está vacía, retorna ``None``; si contiene exactamente una "
"unidad de formato, retorna el objeto que describa esa unidad de formato. "
"Para forzarlo a retornar una tupla de tamaño 0 o uno, paréntesis la cadena "
"de formato."

#: ../Doc/c-api/arg.rst:513
msgid ""
"When memory buffers are passed as parameters to supply data to build "
"objects, as for the ``s`` and ``s#`` formats, the required data is copied.  "
"Buffers provided by the caller are never referenced by the objects created "
"by :c:func:`Py_BuildValue`.  In other words, if your code invokes :c:func:"
"`malloc` and passes the allocated memory to :c:func:`Py_BuildValue`, your "
"code is responsible for calling :c:func:`free` for that memory once :c:func:"
"`Py_BuildValue` returns."
msgstr ""
"Cuando los búfer de memoria se pasan como parámetros para suministrar datos "
"para construir objetos, como para los formatos ``s`` y ``s#``, los datos "
"requeridos se copian. Las memorias intermedias proporcionadas por quien "
"llama nunca son referenciadas por los objetos creados por :c:func:"
"`Py_BuildValue`. En otras palabras, si su código invoca :c:func:`malloc` y "
"pasa la memoria asignada a :c:func:`Py_BuildValue`, su código es responsable "
"de llamar a :c:func:`free` para esa memoria una vez retorna :c:func:"
"`Py_BuildValue`."

#: ../Doc/c-api/arg.rst:521
msgid ""
"In the following description, the quoted form is the format unit; the entry "
"in (round) parentheses is the Python object type that the format unit will "
"return; and the entry in [square] brackets is the type of the C value(s) to "
"be passed."
msgstr ""
"En la siguiente descripción, la cadena de caracteres entre comillas, `así`, "
"es la unidad de formato; la entrada entre paréntesis (redondos) es el tipo "
"de objeto Python que retornará la unidad de formato; y la entrada entre "
"corchetes [cuadrados] es el tipo de los valores C que se pasarán."

#: ../Doc/c-api/arg.rst:525
msgid ""
"The characters space, tab, colon and comma are ignored in format strings "
"(but not within format units such as ``s#``).  This can be used to make long "
"format strings a tad more readable."
msgstr ""
"Los caracteres espacio, tabulación, dos puntos y coma se ignoran en las "
"cadenas de formato (pero no dentro de las unidades de formato como ``s#``). "
"Esto se puede usar para hacer que las cadenas de formato largo sean un poco "
"más legibles."

#: ../Doc/c-api/arg.rst:531
msgid "``s`` (:class:`str` or ``None``) [const char \\*]"
msgstr "``s`` (:class:`str` o ``None``) [const char \\*]"

#: ../Doc/c-api/arg.rst:530
msgid ""
"Convert a null-terminated C string to a Python :class:`str` object using "
"``'utf-8'`` encoding. If the C string pointer is ``NULL``, ``None`` is used."
msgstr ""
"Convierte una cadena de caracteres C terminada en nulo en un objeto Python :"
"class:`str` usando la codificación ``'utf-8'``. Si el puntero de la cadena "
"de caracteres C es ``NULL``, se usa ``None``."

#: ../Doc/c-api/arg.rst:536
msgid ""
"``s#`` (:class:`str` or ``None``) [const char \\*, :c:type:`Py_ssize_t`]"
msgstr ""
"``s#`` (:class:`str` o ``None``) [const char \\*, :c:type:`Py_ssize_t`]"

#: ../Doc/c-api/arg.rst:534
msgid ""
"Convert a C string and its length to a Python :class:`str` object using "
"``'utf-8'`` encoding. If the C string pointer is ``NULL``, the length is "
"ignored and ``None`` is returned."
msgstr ""
"Convierte una cadena de caracteres de C y su longitud en un objeto Python :"
"class:`str` utilizando la codificación ``'utf-8'``. Si el puntero de la "
"cadena de caracteres de C es ``NULL``, la longitud se ignora y se retorna "
"``None``."

#: ../Doc/c-api/arg.rst:540
msgid "``y`` (:class:`bytes`) [const char \\*]"
msgstr "``y`` (:class:`bytes`) [const char \\*]"

#: ../Doc/c-api/arg.rst:539
msgid ""
"This converts a C string to a Python :class:`bytes` object.  If the C string "
"pointer is ``NULL``, ``None`` is returned."
msgstr ""
"Esto convierte una cadena de caracteres de C en un objeto Python :class:"
"`bytes`. Si el puntero de la cadena de caracteres de C es ``NULL``, se "
"retorna ``None``."

#: ../Doc/c-api/arg.rst:544
msgid "``y#`` (:class:`bytes`) [const char \\*, :c:type:`Py_ssize_t`]"
msgstr "``y#`` (:class:`bytes`) [const char \\*, :c:type:`Py_ssize_t`]"

#: ../Doc/c-api/arg.rst:543
msgid ""
"This converts a C string and its lengths to a Python object.  If the C "
"string pointer is ``NULL``, ``None`` is returned."
msgstr ""
"Esto convierte una cadena de caracteres de C y sus longitudes en un objeto "
"Python. Si el puntero de la cadena de caracteres de C es ``NULL``, se "
"retorna ``None``."

#: ../Doc/c-api/arg.rst:547 ../Doc/c-api/arg.rst:563
msgid "Same as ``s``."
msgstr "Igual que ``s``."

#: ../Doc/c-api/arg.rst:550
msgid ""
"``z#`` (:class:`str` or ``None``) [const char \\*, :c:type:`Py_ssize_t`]"
msgstr ""
"``z#`` (:class:`str` o ``None``) [const char \\*, :c:type:`Py_ssize_t`]"

#: ../Doc/c-api/arg.rst:550 ../Doc/c-api/arg.rst:566
msgid "Same as ``s#``."
msgstr "Igual que ``s#``."

#: ../Doc/c-api/arg.rst:555
msgid "``u`` (:class:`str`) [const wchar_t \\*]"
msgstr "``u`` (:class:`str`) [const wchar_t \\*]"

#: ../Doc/c-api/arg.rst:553
#, fuzzy
msgid ""
"Convert a null-terminated :c:type:`wchar_t` buffer of Unicode (UTF-16 or "
"UCS-4) data to a Python Unicode object.  If the Unicode buffer pointer is "
"``NULL``, ``None`` is returned."
msgstr ""
"Convierte un búfer :c:type:`wchar_t` de datos Unicode (UTF-16 o UCS-4) en un "
"objeto Python Unicode. Si el puntero del búfer Unicode es ``NULL``, se "
"retorna ``None``."

#: ../Doc/c-api/arg.rst:560
msgid "``u#`` (:class:`str`) [const wchar_t \\*, :c:type:`Py_ssize_t`]"
msgstr "``u#`` (:class:`str`) [const wchar_t \\*, :c:type:`Py_ssize_t`]"

#: ../Doc/c-api/arg.rst:558
msgid ""
"Convert a Unicode (UTF-16 or UCS-4) data buffer and its length to a Python "
"Unicode object.   If the Unicode buffer pointer is ``NULL``, the length is "
"ignored and ``None`` is returned."
msgstr ""
"Convierte un búfer de datos Unicode (UTF-16 o UCS-4) y su longitud en un "
"objeto Python Unicode. Si el puntero del búfer Unicode es ``NULL``, la "
"longitud se ignora y se retorna ``None``."

#: ../Doc/c-api/arg.rst:563
msgid "``U`` (:class:`str` or ``None``) [const char \\*]"
msgstr "``U`` (:class:`str` o ``None``) [const char \\*]"

#: ../Doc/c-api/arg.rst:566
msgid ""
"``U#`` (:class:`str` or ``None``) [const char \\*, :c:type:`Py_ssize_t`]"
msgstr ""
"``z#`` (:class:`str` o ``None``) [const char \\*, :c:type:`Py_ssize_t`]"

#: ../Doc/c-api/arg.rst:569
#, fuzzy
msgid "Convert a plain C :c:expr:`int` to a Python integer object."
msgstr "Convierte un :c:type:`int` plano de C a un objeto entero de Python."

#: ../Doc/c-api/arg.rst:572
msgid "``b`` (:class:`int`) [char]"
msgstr "``b`` (:class:`int`) [char]"

#: ../Doc/c-api/arg.rst:572
#, fuzzy
msgid "Convert a plain C :c:expr:`char` to a Python integer object."
msgstr "Convierte un :c:type:`char` plano de C a un objeto entero de Python."

#: ../Doc/c-api/arg.rst:575
#, fuzzy
msgid "Convert a plain C :c:expr:`short int` to a Python integer object."
msgstr ""
"Convierte un :c:type:`short int` plano de C a un objeto entero de Python."

#: ../Doc/c-api/arg.rst:578
#, fuzzy
msgid "Convert a C :c:expr:`long int` to a Python integer object."
msgstr "Convierta un :c:type:`long int` de C en un objeto entero de Python."

#: ../Doc/c-api/arg.rst:581
#, fuzzy
msgid "Convert a C :c:expr:`unsigned char` to a Python integer object."
msgstr "Convierte un :c:type:`unsigned char` de C a un entero de Python."

#: ../Doc/c-api/arg.rst:584
#, fuzzy
msgid "Convert a C :c:expr:`unsigned short int` to a Python integer object."
msgstr "Convierte un :c:type:`unsigned short int` de C a un entero de Python."

#: ../Doc/c-api/arg.rst:587
#, fuzzy
msgid "Convert a C :c:expr:`unsigned int` to a Python integer object."
msgstr "Convierte un :c:type:`unsigned int` de C a un entero de Python."

#: ../Doc/c-api/arg.rst:590
#, fuzzy
msgid "Convert a C :c:expr:`unsigned long` to a Python integer object."
msgstr "Convierte un :c:type:`unsigned long` de C a un entero de Python."

#: ../Doc/c-api/arg.rst:593
#, fuzzy
msgid "Convert a C :c:expr:`long long` to a Python integer object."
msgstr "Convierte un :c:type:`long long` de C en un objeto entero de Python."

#: ../Doc/c-api/arg.rst:596
#, fuzzy
msgid "Convert a C :c:expr:`unsigned long long` to a Python integer object."
msgstr "Convierte un :c:type:`unsigned long long` de C a un entero de Python."

#: ../Doc/c-api/arg.rst:599
msgid "Convert a C :c:type:`Py_ssize_t` to a Python integer."
msgstr "Convierte un :c:type:`Py_ssize_t` de C a un entero de Python."

#: ../Doc/c-api/arg.rst:603
msgid "``c`` (:class:`bytes` of length 1) [char]"
msgstr "``c`` (:class:`bytes` de largo 1) [char]"

#: ../Doc/c-api/arg.rst:602
#, fuzzy
msgid ""
"Convert a C :c:expr:`int` representing a byte to a Python :class:`bytes` "
"object of length 1."
msgstr ""
"Convierte un :c:type:`int` de C representando un byte a un objeto :class:"
"`bytes` de Python de largo 1."

#: ../Doc/c-api/arg.rst:606
#, fuzzy
msgid ""
"Convert a C :c:expr:`int` representing a character to Python :class:`str` "
"object of length 1."
msgstr ""
"Convierte un :c:type:`int` de C representando un carácter a un objeto :class:"
"`str` de Python de largo 1."

#: ../Doc/c-api/arg.rst:610
#, fuzzy
msgid "Convert a C :c:expr:`double` to a Python floating point number."
msgstr ""
"Convierte un :c:type:`double` de C a un número de punto flotante de Python."

#: ../Doc/c-api/arg.rst:613
#, fuzzy
msgid "Convert a C :c:expr:`float` to a Python floating point number."
msgstr ""
"Convierte un :c:type:`float` de C a un número de punto flotante de Python."

#: ../Doc/c-api/arg.rst:616
msgid "``D`` (:class:`complex`) [Py_complex \\*]"
msgstr "``D`` (:class:`complex`) [Py_complex \\*]"

#: ../Doc/c-api/arg.rst:616
msgid "Convert a C :c:type:`Py_complex` structure to a Python complex number."
msgstr ""
"Convierte una estructura :c:type:`Py_complex` de C en un número complejo de "
"Python."

#: ../Doc/c-api/arg.rst:619
#, fuzzy
msgid ""
"Pass a Python object untouched but create a new :term:`strong reference` to "
"it (i.e. its reference count is incremented by one). If the object passed in "
"is a ``NULL`` pointer, it is assumed that this was caused because the call "
"producing the argument found an error and set an exception. Therefore, :c:"
"func:`Py_BuildValue` will return ``NULL`` but won't raise an exception.  If "
"no exception has been raised yet, :exc:`SystemError` is set."
msgstr ""
"Pasa un objeto Python sin tocarlo (excepto por su recuento de referencia, "
"que se incrementa en uno). Si el objeto pasado es un puntero ``NULL``, se "
"supone que esto fue causado porque la llamada que produjo el argumento "
"encontró un error y estableció una excepción. Por lo tanto, :c:func:"
"`Py_BuildValue` retornará ``NULL`` pero no lanzará una excepción. Si aún no "
"se ha producido ninguna excepción, se establece :exc:`SystemError`."

#: ../Doc/c-api/arg.rst:629
msgid "``S`` (object) [PyObject \\*]"
msgstr "``S`` (object) [PyObject \\*]"

#: ../Doc/c-api/arg.rst:629
msgid "Same as ``O``."
msgstr "Igual que ``O``."

#: ../Doc/c-api/arg.rst:634
msgid "``N`` (object) [PyObject \\*]"
msgstr "``N`` (object) [PyObject \\*]"

#: ../Doc/c-api/arg.rst:632
#, fuzzy
msgid ""
"Same as ``O``, except it doesn't create a new :term:`strong reference`. "
"Useful when the object is created by a call to an object constructor in the "
"argument list."
msgstr ""
"Igual que ``O``, excepto que no incrementa el recuento de referencia en el "
"objeto. Útil cuando el objeto se crea mediante una llamada a un constructor "
"de objetos en la lista de argumentos."

#: ../Doc/c-api/arg.rst:637
#, fuzzy
msgid ""
"Convert *anything* to a Python object through a *converter* function.  The "
"function is called with *anything* (which should be compatible with :c:expr:"
"`void*`) as its argument and should return a \"new\" Python object, or "
"``NULL`` if an error occurred."
msgstr ""
"Convierte *anything* a un objeto Python a través de una función *converter*. "
"La función se llama con *anything* (que debería ser compatible con :c:type:"
"`void*`) como argumento y debería retornar un \"nuevo\" objeto de Python, o "
"``NULL`` si se produjo un error."

#: ../Doc/c-api/arg.rst:643
msgid ""
"Convert a sequence of C values to a Python tuple with the same number of "
"items."
msgstr ""
"Convierta una secuencia de valores C en una tupla de Python con el mismo "
"número de elementos."

#: ../Doc/c-api/arg.rst:646
msgid "``[items]`` (:class:`list`) [*matching-items*]"
msgstr "``[items]`` (:class:`list`) [*matching-items*]"

#: ../Doc/c-api/arg.rst:646
msgid ""
"Convert a sequence of C values to a Python list with the same number of "
"items."
msgstr ""
"Convierte una secuencia de valores C en una lista de Python con el mismo "
"número de elementos."

#: ../Doc/c-api/arg.rst:651
msgid "``{items}`` (:class:`dict`) [*matching-items*]"
msgstr "``{items}`` (:class:`dict`) [*matching-items*]"

#: ../Doc/c-api/arg.rst:649
msgid ""
"Convert a sequence of C values to a Python dictionary.  Each pair of "
"consecutive C values adds one item to the dictionary, serving as key and "
"value, respectively."
msgstr ""
"Convierte una secuencia de valores C en un diccionario Python. Cada par de "
"valores C consecutivos agrega un elemento al diccionario, que sirve como "
"clave y valor, respectivamente."

#: ../Doc/c-api/arg.rst:653
msgid ""
"If there is an error in the format string, the :exc:`SystemError` exception "
"is set and ``NULL`` returned."
msgstr ""
"Si hay un error en la cadena de formato, se establece la excepción :exc:"
"`SystemError` y se retorna ``NULL``."

#: ../Doc/c-api/arg.rst:658
msgid ""
"Identical to :c:func:`Py_BuildValue`, except that it accepts a va_list "
"rather than a variable number of arguments."
msgstr ""
"Idéntico a :c:func:`Py_BuildValue`, excepto que acepta una *va_list* en "
"lugar de un número variable de argumentos."

#~ msgid ""
#~ "In general, when a format sets a pointer to a buffer, the buffer is "
#~ "managed by the corresponding Python object, and the buffer shares the "
#~ "lifetime of this object.  You won't have to release any memory yourself. "
#~ "The only exceptions are ``es``, ``es#``, ``et`` and ``et#``."
#~ msgstr ""
#~ "En general, cuando un formato establece un puntero a un búfer, el búfer "
#~ "es gestionado por el objeto de Python correspondiente, y el búfer "
#~ "comparte la vida útil de este objeto. Usted no tendrá que liberar "
#~ "cualquier memoria usted mismo. Las únicas excepciones son ``es``, "
#~ "``es#``, ``et`` y ``et#``."

#~ msgid ""
#~ "Some formats require a read-only :term:`bytes-like object`, and set a "
#~ "pointer instead of a buffer structure.  They work by checking that the "
#~ "object's :c:member:`PyBufferProcs.bf_releasebuffer` field is ``NULL``, "
#~ "which disallows mutable objects such as :class:`bytearray`."
#~ msgstr ""
#~ "Algunos formatos requieren :term:`bytes-like object` de sólo lectura, y "
#~ "establecen un puntero en lugar de una estructura de búfer. Trabajan "
#~ "comprobando que el campo del objeto :c:member:`PyBufferProcs."
#~ "bf_releasebuffer` es ``NULL``, que no permite objetos mutables como :"
#~ "class:`bytearray`."

#~ msgid "``u`` (:class:`str`) [const Py_UNICODE \\*]"
#~ msgstr "``u`` (:class:`str`) [const Py_UNICODE \\*]"

#~ msgid ""
#~ "Convert a Python Unicode object to a C pointer to a NUL-terminated buffer "
#~ "of Unicode characters.  You must pass the address of a :c:type:"
#~ "`Py_UNICODE` pointer variable, which will be filled with the pointer to "
#~ "an existing Unicode buffer.  Please note that the width of a :c:type:"
#~ "`Py_UNICODE` character depends on compilation options (it is either 16 or "
#~ "32 bits). The Python string must not contain embedded null code points; "
#~ "if it does, a :exc:`ValueError` exception is raised."
#~ msgstr ""
#~ "Convierte un objeto Unicode de Python a un puntero a un búfer C NUL "
#~ "terminado de caracteres Unicode. Debe pasar la dirección de una variable "
#~ "de puntero :c:type:`Py_UNICODE`, que se llena con el puntero a un búfer "
#~ "Unicode existente. Tenga en cuenta que el ancho de un carácter :c:type:"
#~ "`Py_UNICODE` depende de las opciones de compilación (que es  16 o 32 "
#~ "bits). La cadena de Python no debe contener puntos de código incrustado "
#~ "nulos; si lo hace, se lanza una excepción :exc:`ValueError`."

#~ msgid ""
#~ "Part of the old-style :c:type:`Py_UNICODE` API; please migrate to using :"
#~ "c:func:`PyUnicode_AsWideCharString`."
#~ msgstr ""
#~ "Parte de la API de viejo estilo :c:type:`Py_UNICODE`; favor migrar al uso "
#~ "de :c:func:`PyUnicode_AsWideCharString`."

#~ msgid "``u#`` (:class:`str`) [const Py_UNICODE \\*, :c:type:`Py_ssize_t`]"
#~ msgstr "``u#`` (:class:`str`) [const Py_UNICODE \\*, :c:type:`Py_ssize_t`]"

#~ msgid ""
#~ "This variant on ``u`` stores into two C variables, the first one a "
#~ "pointer to a Unicode data buffer, the second one its length.  This "
#~ "variant allows null code points."
#~ msgstr ""
#~ "Esta variante en ``u`` almacena en dos variables de C, el primero un "
#~ "puntero a un búfer de datos Unicode, el segundo de su longitud. Esta "
#~ "variante permite puntos de código nulos."

#~ msgid "``Z`` (:class:`str` or ``None``) [const Py_UNICODE \\*]"
#~ msgstr "``Z`` (:class:`str` o ``None``) [const Py_UNICODE \\*]"

#~ msgid ""
#~ "Like ``u``, but the Python object may also be ``None``, in which case "
#~ "the :c:type:`Py_UNICODE` pointer is set to ``NULL``."
#~ msgstr ""
#~ "Como ``u``, pero el objeto Python también puede ser ``None``, en cuyo "
#~ "caso el puntero :c:type:`Py_UNICODE` se establece en ``NULL``."

#~ msgid ""
#~ "``Z#`` (:class:`str` or ``None``) [const Py_UNICODE \\*, :c:type:"
#~ "`Py_ssize_t`]"
#~ msgstr ""
#~ "``z#`` (:class:`str` o ``None``) [const Py_UNICODE \\*, :c:type:"
#~ "`Py_ssize_t`]"

#~ msgid ""
#~ "Like ``u#``, but the Python object may also be ``None``, in which case "
#~ "the :c:type:`Py_UNICODE` pointer is set to ``NULL``."
#~ msgstr ""
#~ "Al igual que ``u#``, pero el objeto Python también puede ser ``None``, en "
#~ "cuyo caso el puntero :c:type:`Py_UNICODE` se establece en ``NULL``."