# 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-11-12 10:39+0800\n"

"Last-Translator: Rodrigo Tobar <rtobarc@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/extending/newtypes_tutorial.rst:7

msgid "Defining Extension Types: Tutorial"

msgstr "Definición de tipos de extensión: Tutorial"

#: ../Doc/extending/newtypes_tutorial.rst:14

msgid ""

"Python allows the writer of a C extension module to define new types that "

"can be manipulated from Python code, much like the built-in :class:`str` "

"and :class:`list` types. The code for all extension types follows a "

"pattern, but there are some details that you need to understand before you "

"can get started. This document is a gentle introduction to the topic."

msgstr ""

"Python le permite al escritor de un módulo de extensión C definir nuevos "

"tipos que pueden ser manipulados desde el código Python, al igual que los "

"tipos incorporados :class:`str` y :class:`list`. El código para todos los "

"tipos de extensión sigue un patrón, pero hay algunos detalles que debe "

"comprender antes de comenzar. Este documento es una introducción suave al "

"tema."

#: ../Doc/extending/newtypes_tutorial.rst:24

msgid "The Basics"

msgstr "Lo básico"

#: ../Doc/extending/newtypes_tutorial.rst:26

#, fuzzy

msgid ""

"The :term:`CPython` runtime sees all Python objects as variables of type :c:"

"expr:`PyObject*`, which serves as a \"base type\" for all Python objects. "

"The :c:type:`PyObject` structure itself only contains the object's :term:"

"`reference count` and a pointer to the object's \"type object\". This is "

"where the action is; the type object determines which (C) functions get "

"called by the interpreter when, for instance, an attribute gets looked up on "

"an object, a method called, or it is multiplied by another object. These C "

"functions are called \"type methods\"."

msgstr ""

"El tiempo de ejecución :term:`CPython` ve todos los objetos de Python como "

"variables de tipo :c:type:`PyObject\\*`, que sirve como un \"tipo base\" "

"para todos los objetos de Python. La estructura :c:type:`PyObject` solo "

"contiene el :term:`reference count` del objeto y un puntero al \"objeto "

"tipo\" del objeto. Aquí es donde está la acción; el objeto tipo determina "

"qué funciones (C) llama el intérprete cuando, por ejemplo, se busca un "

"atributo en un objeto, se llama un método o se multiplica por otro objeto. "

"Estas funciones de C se denominan \"métodos de tipo\"."

#: ../Doc/extending/newtypes_tutorial.rst:35

msgid ""

"So, if you want to define a new extension type, you need to create a new "

"type object."

msgstr ""

"Por lo tanto, si desea definir un nuevo tipo de extensión, debe crear un "

"nuevo objeto de tipo."

#: ../Doc/extending/newtypes_tutorial.rst:38

#, fuzzy

msgid ""

"This sort of thing can only be explained by example, so here's a minimal, "

"but complete, module that defines a new type named :class:`!Custom` inside a "

"C extension module :mod:`!custom`:"

msgstr ""

"Este tipo de cosas solo se pueden explicar con un ejemplo, por lo que aquí "

"hay un módulo mínimo, pero completo, que define un nuevo tipo llamado :class:"

"`Custom` dentro de un módulo de extensión C :mod:`custom`:"

#: ../Doc/extending/newtypes_tutorial.rst:43

msgid ""

"What we're showing here is the traditional way of defining *static* "

"extension types. It should be adequate for most uses. The C API also "

"allows defining heap-allocated extension types using the :c:func:"

"`PyType_FromSpec` function, which isn't covered in this tutorial."

msgstr ""

"Lo que estamos mostrando aquí es la forma tradicional de definir tipos de "

"extensión *estáticos*. Debe ser adecuado para la mayoría de los usos. La API "

"de C también permite definir tipos de extensiones asignadas en el montón "

"utilizando la función :c:func:`PyType_FromSpec`, que no se trata en este "

"tutorial."

#: ../Doc/extending/newtypes_tutorial.rst:50

msgid ""

"Now that's quite a bit to take in at once, but hopefully bits will seem "

"familiar from the previous chapter. This file defines three things:"

msgstr ""

"Ahora, eso es bastante para asimilar a la vez, pero espero que los "

"fragmentos le resulten familiares del capítulo anterior. Este archivo define "

"tres cosas:"

#: ../Doc/extending/newtypes_tutorial.rst:53

#, fuzzy

msgid ""

"What a :class:`!Custom` **object** contains: this is the ``CustomObject`` "

"struct, which is allocated once for each :class:`!Custom` instance."

msgstr ""

"Lo que contiene un **objeto** :class:`Custom`: esta es la estructura "

"``CustomObject``, que se asigna una vez para cada instancia de :class:"

"`Custom`."

#: ../Doc/extending/newtypes_tutorial.rst:55

#, fuzzy

msgid ""

"How the :class:`!Custom` **type** behaves: this is the ``CustomType`` "

"struct, which defines a set of flags and function pointers that the "

"interpreter inspects when specific operations are requested."

msgstr ""

"Cómo se comporta :class:`Custom` **type**: esta es la estructura "

"``CustomType``, que define un conjunto de indicadores y punteros de función "

"que el intérprete inspecciona cuando se solicitan operaciones específicas."

#: ../Doc/extending/newtypes_tutorial.rst:58

#, fuzzy

msgid ""

"How to initialize the :mod:`!custom` module: this is the ``PyInit_custom`` "

"function and the associated ``custommodule`` struct."

msgstr ""

"Cómo inicializar el módulo :mod:`custom`: esta es la función "

"``PyInit_custom`` y la estructura asociada ``custommodule``."

#: ../Doc/extending/newtypes_tutorial.rst:61

msgid "The first bit is::"

msgstr "La primera parte es::"

#: ../Doc/extending/newtypes_tutorial.rst:67

#, fuzzy

msgid ""

"This is what a Custom object will contain. ``PyObject_HEAD`` is mandatory "

"at the start of each object struct and defines a field called ``ob_base`` of "

"type :c:type:`PyObject`, containing a pointer to a type object and a "

"reference count (these can be accessed using the macros :c:macro:`Py_TYPE` "

"and :c:macro:`Py_REFCNT` respectively). The reason for the macro is to "

"abstract away the layout and to enable additional fields in :ref:`debug "

"builds <debug-build>`."

msgstr ""

"Esto es lo que contendrá un objeto personalizado. ``PyObject_HEAD`` es "

"obligatorio al comienzo de cada estructura de objeto y define un campo "

"llamado ``ob_base`` de tipo :c:type:`PyObject`, que contiene un puntero a un "

"objeto de tipo y un recuento de referencia (estos pueden ser accedidos "

"mediante las macros :c:macro:`Py_REFCNT` y :c:macro:`Py_TYPE` "

"respectivamente). El motivo de la macro es abstraer el diseño y habilitar "

"campos adicionales en las :ref:`compilaciones de depuración <debug-build>`."

#: ../Doc/extending/newtypes_tutorial.rst:76

msgid ""

"There is no semicolon above after the :c:macro:`PyObject_HEAD` macro. Be "

"wary of adding one by accident: some compilers will complain."

msgstr ""

"No hay punto y coma (;) arriba después de la macro :c:macro:`PyObject_HEAD`. "

"Tenga cuidado de agregar uno por accidente: algunos compiladores se quejarán."

#: ../Doc/extending/newtypes_tutorial.rst:79

msgid ""

"Of course, objects generally store additional data besides the standard "

"``PyObject_HEAD`` boilerplate; for example, here is the definition for "

"standard Python floats::"

msgstr ""

"Por supuesto, los objetos generalmente almacenan datos adicionales además "

"del estándar ``PyObject_HEAD`` repetitivo; por ejemplo, aquí está la "

"definición de puntos flotantes del estándar de Python::"

#: ../Doc/extending/newtypes_tutorial.rst:88

msgid "The second bit is the definition of the type object. ::"

msgstr "La segunda parte es la definición del tipo de objeto. ::"

#: ../Doc/extending/newtypes_tutorial.rst:101

msgid ""

"We recommend using C99-style designated initializers as above, to avoid "

"listing all the :c:type:`PyTypeObject` fields that you don't care about and "

"also to avoid caring about the fields' declaration order."

msgstr ""

"Recomendamos utilizar los inicializadores designados al estilo C99 como se "

"indica arriba, para evitar enumerar todos los campos :c:type:`PyTypeObject` "

"que no le interesan y también para evitar preocuparse por el orden de "

"declaración de los campos."

#: ../Doc/extending/newtypes_tutorial.rst:105

msgid ""

"The actual definition of :c:type:`PyTypeObject` in :file:`object.h` has many "

"more :ref:`fields <type-structs>` than the definition above. The remaining "

"fields will be filled with zeros by the C compiler, and it's common practice "

"to not specify them explicitly unless you need them."

msgstr ""

"La definición real de :c:type:`PyTypeObject` en :file:`object.h` tiene "

"muchos más :ref:`campos <type-structs>` que la definición anterior. El "

"compilador de C rellenará los campos restantes con ceros, y es una práctica "

"común no especificarlos explícitamente a menos que los necesite."

#: ../Doc/extending/newtypes_tutorial.rst:110

msgid "We're going to pick it apart, one field at a time::"

msgstr "Lo vamos a separar, un campo a la vez:"

#: ../Doc/extending/newtypes_tutorial.rst:114

msgid ""

"This line is mandatory boilerplate to initialize the ``ob_base`` field "

"mentioned above. ::"

msgstr ""

"Esta línea es obligatoria para inicializar el campo ``ob_base`` mencionado "

"anteriormente. ::"

#: ../Doc/extending/newtypes_tutorial.rst:119

msgid ""

"The name of our type. This will appear in the default textual "

"representation of our objects and in some error messages, for example:"

msgstr ""

"El nombre de nuestro tipo. Esto aparecerá en la representación textual "

"predeterminada de nuestros objetos y en algunos mensajes de error, por "

"ejemplo:"

#: ../Doc/extending/newtypes_tutorial.rst:129

#, fuzzy

msgid ""

"Note that the name is a dotted name that includes both the module name and "

"the name of the type within the module. The module in this case is :mod:`!"

"custom` and the type is :class:`!Custom`, so we set the type name to :class:"

"`!custom.Custom`. Using the real dotted import path is important to make "

"your type compatible with the :mod:`pydoc` and :mod:`pickle` modules. ::"

msgstr ""

"Tenga en cuenta que el nombre es un nombre punteado que incluye tanto el "

"nombre del módulo como el nombre del tipo dentro del módulo. El módulo en "

"este caso es :mod:`custom` y el tipo es :class:`Custom`, por lo que "

"establecemos el nombre del tipo en :class:`custom.Custom`. Usar la ruta de "

"importación punteada real es importante para que su tipo sea compatible con "

"los módulos :mod:`pydoc` y :mod:`pickle`. ::"

#: ../Doc/extending/newtypes_tutorial.rst:138

#, fuzzy

msgid ""

"This is so that Python knows how much memory to allocate when creating new :"

"class:`!Custom` instances. :c:member:`~PyTypeObject.tp_itemsize` is only "

"used for variable-sized objects and should otherwise be zero."

msgstr ""

"Esto es para que Python sepa cuánta memoria asignar al crear instancias "

"nuevas :class:`Custom`. :c:member:`~PyTypeObject.tp_itemsize` solo se usa "

"para objetos de tamaño variable y, de lo contrario, debería ser cero."

#: ../Doc/extending/newtypes_tutorial.rst:144

#, fuzzy

msgid ""

"If you want your type to be subclassable from Python, and your type has the "

"same :c:member:`~PyTypeObject.tp_basicsize` as its base type, you may have "

"problems with multiple inheritance. A Python subclass of your type will "

"have to list your type first in its :attr:`~class.__bases__`, or else it "

"will not be able to call your type's :meth:`~object.__new__` method without "

"getting an error. You can avoid this problem by ensuring that your type has "

"a larger value for :c:member:`~PyTypeObject.tp_basicsize` than its base type "

"does. Most of the time, this will be true anyway, because either your base "

"type will be :class:`object`, or else you will be adding data members to "

"your base type, and therefore increasing its size."

msgstr ""

"Si desea que su tipo pueda tener subclases desde Python, y su tipo tiene el "

"mismo :c:member:`~PyTypeObject.tp_basicsize` como su tipo base, puede tener "

"problemas con la herencia múltiple. Una subclase de Python de su tipo tendrá "

"que enumerar su tipo primero en su :attr:`~class.__bases__`, o de lo "

"contrario no podrá llamar al método de su tipo :meth:`__new__` sin obtener "

"un error. Puede evitar este problema asegurándose de que su tipo tenga un "

"valor mayor para :c:member:`~PyTypeObject.tp_basicsize` que su tipo base. La "

"mayoría de las veces, esto será cierto de todos modos, porque su tipo base "

"será :class:`object`, o de lo contrario agregará miembros de datos a su tipo "

"base y, por lo tanto, aumentará su tamaño."

#: ../Doc/extending/newtypes_tutorial.rst:154

#, fuzzy

msgid "We set the class flags to :c:macro:`Py_TPFLAGS_DEFAULT`. ::"

msgstr "Configuramos las banderas de clase a :const:`Py_TPFLAGS_DEFAULT`. ::"

#: ../Doc/extending/newtypes_tutorial.rst:158

msgid ""

"All types should include this constant in their flags. It enables all of "

"the members defined until at least Python 3.3. If you need further members, "

"you will need to OR the corresponding flags."

msgstr ""

"Todos los tipos deben incluir esta constante en sus banderas. Habilita todos "

"los miembros definidos hasta al menos Python 3.3. Si necesita más miembros, "

"necesitará O (*OR*) las banderas correspondientes."

#: ../Doc/extending/newtypes_tutorial.rst:162

msgid ""

"We provide a doc string for the type in :c:member:`~PyTypeObject.tp_doc`. ::"

msgstr ""

"Proporcionamos una cadena de documentos para el tipo en :c:member:"

"`~PyTypeObject.tp_doc`. ::"

#: ../Doc/extending/newtypes_tutorial.rst:166

#, fuzzy

msgid ""

"To enable object creation, we have to provide a :c:member:`~PyTypeObject."

"tp_new` handler. This is the equivalent of the Python method :meth:`~object."

"__new__`, but has to be specified explicitly. In this case, we can just use "

"the default implementation provided by the API function :c:func:"

"`PyType_GenericNew`. ::"

msgstr ""

"Para habilitar la creación de objetos, debemos proporcionar un controlador :"

"c:member:`~PyTypeObject.tp_new`. Este es el equivalente del método Python :"

"meth:`__new__`, pero debe especificarse explícitamente. En este caso, "

"podemos usar la implementación predeterminada proporcionada por la función "

"API :c:func:`PyType_GenericNew`. ::"

#: ../Doc/extending/newtypes_tutorial.rst:173

#, fuzzy

msgid ""

"Everything else in the file should be familiar, except for some code in :c:"

"func:`!PyInit_custom`::"

msgstr ""

"Todo lo demás en el archivo debe ser familiar, excepto algún código en :c:"

"func:`PyInit_custom`::"

#: ../Doc/extending/newtypes_tutorial.rst:179

#, fuzzy

msgid ""

"This initializes the :class:`!Custom` type, filling in a number of members "

"to the appropriate default values, including :c:member:`~PyObject.ob_type` "

"that we initially set to ``NULL``. ::"

msgstr ""

"Esto inicializa el tipo :class:`Custom`, completando un número de miembros "

"con los valores predeterminados apropiados, que incluyen :attr:`ob_type` que "

"inicialmente configuramos en ``NULL``. ::"

#: ../Doc/extending/newtypes_tutorial.rst:190

#, fuzzy

msgid ""

"This adds the type to the module dictionary. This allows us to create :"

"class:`!Custom` instances by calling the :class:`!Custom` class:"

msgstr ""

"Esto agrega el tipo al diccionario del módulo. Esto nos permite crear "

"instancias :class:`Custom` llamando la clase :class:`Custom`:"

#: ../Doc/extending/newtypes_tutorial.rst:198

#, fuzzy

msgid ""

"That's it! All that remains is to build it; put the above code in a file "

"called :file:`custom.c`,"

msgstr ""

"¡Eso es! Todo lo que queda es construirlo; ponga el código anterior en un "

"archivo llamado :file:`custom.c` y:"

#: ../Doc/extending/newtypes_tutorial.rst:203

#, fuzzy

msgid "in a file called :file:`pyproject.toml`, and"

msgstr "en un archivo llamado :file:`setup.py`; luego escribiendo"

#: ../Doc/extending/newtypes_tutorial.rst:210

msgid "in a file called :file:`setup.py`; then typing"

msgstr "en un archivo llamado :file:`setup.py`; luego escribiendo"

#: ../Doc/extending/newtypes_tutorial.rst:216

#, fuzzy

msgid ""

"in a shell should produce a file :file:`custom.so` in a subdirectory and "

"install it; now fire up Python --- you should be able to ``import custom`` "

"and play around with ``Custom`` objects."

msgstr ""

"en un shell debería producir un archivo :file:`custom.so` en un "

"subdirectorio; muévete a ese directorio y abre Python --- deberías poder "

"``import custom`` y jugar con objetos personalizados."

#: ../Doc/extending/newtypes_tutorial.rst:220

msgid "That wasn't so hard, was it?"

msgstr "Eso no fue tan difícil, ¿verdad?"

#: ../Doc/extending/newtypes_tutorial.rst:222

msgid ""

"Of course, the current Custom type is pretty uninteresting. It has no data "

"and doesn't do anything. It can't even be subclassed."

msgstr ""

"Por supuesto, el tipo personalizado actual es bastante poco interesante. No "

"tiene datos y no hace nada. Ni siquiera se puede subclasificar."

#: ../Doc/extending/newtypes_tutorial.rst:227

msgid "Adding data and methods to the Basic example"

msgstr "Agregar datos y métodos al ejemplo básico"

#: ../Doc/extending/newtypes_tutorial.rst:229

#, fuzzy

msgid ""

"Let's extend the basic example to add some data and methods. Let's also "

"make the type usable as a base class. We'll create a new module, :mod:`!"

"custom2` that adds these capabilities:"

msgstr ""

"Extendamos el ejemplo básico para agregar algunos datos y métodos. También "

"hagamos que el tipo sea utilizable como una clase base. Crearemos un nuevo "

"módulo, :mod:`custom2` que agrega estas capacidades:"

#: ../Doc/extending/newtypes_tutorial.rst:236

msgid "This version of the module has a number of changes."

msgstr "Esta versión del módulo tiene una serie de cambios."

#: ../Doc/extending/newtypes_tutorial.rst:238

#, fuzzy

msgid ""

"The :class:`!Custom` type now has three data attributes in its C struct, "

"*first*, *last*, and *number*. The *first* and *last* variables are Python "

"strings containing first and last names. The *number* attribute is a C "

"integer."

msgstr ""

"El tipo :class:`Custom` ahora tiene tres atributos de datos en su estructura "

"C, *first*, *last* y *number*. Las variables *first* y *last* son cadenas de "

"caracteres de Python que contienen nombres y apellidos. El atributo *number* "

"es un entero C."

#: ../Doc/extending/newtypes_tutorial.rst:242

msgid "The object structure is updated accordingly::"

msgstr "La estructura del objeto se actualiza en consecuencia::"

#: ../Doc/extending/newtypes_tutorial.rst:251

msgid ""

"Because we now have data to manage, we have to be more careful about object "

"allocation and deallocation. At a minimum, we need a deallocation method::"

msgstr ""

"Debido a que ahora tenemos datos para administrar, debemos ser más "

"cuidadosos con la asignación de objetos y la desasignación. Como mínimo, "

"necesitamos un método de desasignación::"

#: ../Doc/extending/newtypes_tutorial.rst:262

msgid "which is assigned to the :c:member:`~PyTypeObject.tp_dealloc` member::"

msgstr "que se asigna al miembro :c:member:`~PyTypeObject.tp_dealloc`::"

#: ../Doc/extending/newtypes_tutorial.rst:266

#, fuzzy

msgid ""

"This method first clears the reference counts of the two Python attributes. :"

"c:func:`Py_XDECREF` correctly handles the case where its argument is "

"``NULL`` (which might happen here if ``tp_new`` failed midway). It then "

"calls the :c:member:`~PyTypeObject.tp_free` member of the object's type "

"(computed by ``Py_TYPE(self)``) to free the object's memory. Note that the "

"object's type might not be :class:`!CustomType`, because the object may be "

"an instance of a subclass."

msgstr ""

"Este método primero borra los recuentos de referencia de los dos atributos "

"de Python. :c:func:`Py_XDECREF` maneja correctamente el caso donde su "

"argumento es ``NULL`` (lo que podría ocurrir aquí si ``tp_new`` fallara a "

"mitad de camino). Luego llama al miembro :c:member:`~PyTypeObject.tp_free` "

"del tipo de objeto (calculado por ``Py_TYPE(self)``) para liberar la memoria "

"del objeto. Tenga en cuenta que el tipo de objeto podría no ser :class:"

"`CustomType`, porque el objeto puede ser una instancia de una subclase."

#: ../Doc/extending/newtypes_tutorial.rst:275

msgid ""

"The explicit cast to ``destructor`` above is needed because we defined "

"``Custom_dealloc`` to take a ``CustomObject *`` argument, but the "

"``tp_dealloc`` function pointer expects to receive a ``PyObject *`` "

"argument. Otherwise, the compiler will emit a warning. This is object-"

"oriented polymorphism, in C!"

msgstr ""

"La conversión explícita a ``destructor`` anterior es necesaria porque "

"definimos ``Custom_dealloc`` para tomar un argumento ``CustomObject *``, "

"pero el puntero de función ``tp_dealloc`` espera recibir un argumento "

"``PyObject *``. De lo contrario, el compilador emitirá una advertencia. Este "

"es un polimorfismo orientado a objetos, en C!"

#: ../Doc/extending/newtypes_tutorial.rst:281

msgid ""

"We want to make sure that the first and last names are initialized to empty "

"strings, so we provide a ``tp_new`` implementation::"

msgstr ""

"Queremos asegurarnos de que el nombre y el apellido se inicialicen en "

"cadenas de caracteres vacías, por lo que proporcionamos una implementación "

"``tp_new``::"

#: ../Doc/extending/newtypes_tutorial.rst:305

msgid "and install it in the :c:member:`~PyTypeObject.tp_new` member::"

msgstr "e instalarlo en el miembro :c:member:`~PyTypeObject.tp_new`::"

#: ../Doc/extending/newtypes_tutorial.rst:309

#, fuzzy

msgid ""

"The ``tp_new`` handler is responsible for creating (as opposed to "

"initializing) objects of the type. It is exposed in Python as the :meth:"

"`~object.__new__` method. It is not required to define a ``tp_new`` member, "

"and indeed many extension types will simply reuse :c:func:"

"`PyType_GenericNew` as done in the first version of the :class:`!Custom` "

"type above. In this case, we use the ``tp_new`` handler to initialize the "

"``first`` and ``last`` attributes to non-``NULL`` default values."

msgstr ""

"El controlador ``tp_new`` es responsable de crear (en lugar de inicializar) "

"objetos del tipo. Está expuesto en Python como el método :meth:`__new__`. No "

"es necesario definir un miembro ``tp_new``, y de hecho muchos tipos de "

"extensiones simplemente reutilizarán :c:func:`PyType_GenericNew` como se "

"hizo en la primera versión del tipo ``Personalizado`` anterior. En este "

"caso, usamos el controlador ``tp_new`` para inicializar los atributos "

"``first`` y ``last`` a valores predeterminados que no sean ``NULL``."

#: ../Doc/extending/newtypes_tutorial.rst:317

msgid ""

"``tp_new`` is passed the type being instantiated (not necessarily "

"``CustomType``, if a subclass is instantiated) and any arguments passed when "

"the type was called, and is expected to return the instance created. "

"``tp_new`` handlers always accept positional and keyword arguments, but they "

"often ignore the arguments, leaving the argument handling to initializer (a."

"k.a. ``tp_init`` in C or ``__init__`` in Python) methods."

msgstr ""

"``tp_new`` se pasa el tipo que se instancia (no necesariamente "

"``CustomType``, si se instancia una subclase) y cualquier argumento pasado "

"cuando se llamó al tipo, y se espera que retorna la instancia creada. Los "

"manejadores ``tp_new`` siempre aceptan argumentos posicionales y de palabras "

"clave, pero a menudo ignoran los argumentos, dejando el manejo de argumentos "

"al inicializador (también conocido como, ``tp_init`` en C o ``__init__`` en "

"Python)."

#: ../Doc/extending/newtypes_tutorial.rst:325

msgid ""

"``tp_new`` shouldn't call ``tp_init`` explicitly, as the interpreter will do "

"it itself."

msgstr ""

"``tp_new`` no debería llamar explícitamente a ``tp_init``, ya que el "

"intérprete lo hará por sí mismo."

#: ../Doc/extending/newtypes_tutorial.rst:328

msgid ""

"The ``tp_new`` implementation calls the :c:member:`~PyTypeObject.tp_alloc` "

"slot to allocate memory::"

msgstr ""

"La implementación ``tp_new`` llama al :c:member:`~PyTypeObject.tp_alloc` "

"para asignar memoria::"

#: ../Doc/extending/newtypes_tutorial.rst:333

msgid ""

"Since memory allocation may fail, we must check the :c:member:`~PyTypeObject."

"tp_alloc` result against ``NULL`` before proceeding."

msgstr ""

"Como la asignación de memoria puede fallar, debemos verificar el resultado :"

"c:member:`~PyTypeObject.tp_alloc` contra ``NULL`` antes de continuar."

#: ../Doc/extending/newtypes_tutorial.rst:337

msgid ""

"We didn't fill the :c:member:`~PyTypeObject.tp_alloc` slot ourselves. "

"Rather :c:func:`PyType_Ready` fills it for us by inheriting it from our base "

"class, which is :class:`object` by default. Most types use the default "

"allocation strategy."

msgstr ""

"No llenamos la ranura :c:member:`~PyTypeObject.tp_alloc` nosotros mismos. "

"Más bien :c:func:`PyType_Ready` lo llena para nosotros al heredarlo de "

"nuestra clase base, que es :class:`object` por defecto. La mayoría de los "

"tipos utilizan la estrategia de asignación predeterminada."

#: ../Doc/extending/newtypes_tutorial.rst:343

#, fuzzy

msgid ""

"If you are creating a co-operative :c:member:`~PyTypeObject.tp_new` (one "

"that calls a base type's :c:member:`~PyTypeObject.tp_new` or :meth:`~object."

"__new__`), you must *not* try to determine what method to call using method "

"resolution order at runtime. Always statically determine what type you are "

"going to call, and call its :c:member:`~PyTypeObject.tp_new` directly, or "

"via ``type->tp_base->tp_new``. If you do not do this, Python subclasses of "

"your type that also inherit from other Python-defined classes may not work "

"correctly. (Specifically, you may not be able to create instances of such "

"subclasses without getting a :exc:`TypeError`.)"

msgstr ""

"Si está creando una cooperativa :c:member:`~PyTypeObject.tp_new` (una que "

"llama a un tipo base :c:member:`~PyTypeObject.tp_new` o :meth:`__new__`), "

"*no* debe intentar determinar a qué método llamar utilizando el orden de "

"resolución del método en tiempo de ejecución. Siempre determine "

"estáticamente a qué tipo va a llamar, y llame a su :c:member:`~PyTypeObject."

"tp_new` directamente, o mediante ``type->tp_base->tp_new``. Si no hace esto, "

"las subclases de Python de su tipo que también heredan de otras clases "

"definidas por Python pueden no funcionar correctamente. (Específicamente, es "

"posible que no pueda crear instancias de tales subclases sin obtener un :exc:"

"`TypeError`)."

#: ../Doc/extending/newtypes_tutorial.rst:353

msgid ""

"We also define an initialization function which accepts arguments to provide "

"initial values for our instance::"

msgstr ""

"También definimos una función de inicialización que acepta argumentos para "

"proporcionar valores iniciales para nuestra instancia::"

#: ../Doc/extending/newtypes_tutorial.rst:382

msgid "by filling the :c:member:`~PyTypeObject.tp_init` slot. ::"

msgstr "rellenando la ranura :c:member:`~PyTypeObject.tp_init`. ::"

#: ../Doc/extending/newtypes_tutorial.rst:386

#, fuzzy

msgid ""

"The :c:member:`~PyTypeObject.tp_init` slot is exposed in Python as the :meth:"

"`~object.__init__` method. It is used to initialize an object after it's "

"created. Initializers always accept positional and keyword arguments, and "

"they should return either ``0`` on success or ``-1`` on error."

msgstr ""

"La ranura :c:member:`~PyTypeObject.tp_init` está expuesta en Python como el "

"método :meth:`__init__`. Se utiliza para inicializar un objeto una vez "

"creado. Los inicializadores siempre aceptan argumentos posicionales y de "

"palabras clave, y deben retornar ``0`` en caso de éxito o ``-1`` en caso de "

"error."

#: ../Doc/extending/newtypes_tutorial.rst:391

#, fuzzy

msgid ""

"Unlike the ``tp_new`` handler, there is no guarantee that ``tp_init`` is "

"called at all (for example, the :mod:`pickle` module by default doesn't "

"call :meth:`~object.__init__` on unpickled instances). It can also be "

"called multiple times. Anyone can call the :meth:`!__init__` method on our "

"objects. For this reason, we have to be extra careful when assigning the "

"new attribute values. We might be tempted, for example to assign the "

"``first`` member like this::"

msgstr ""

"A diferencia del controlador ``tp_new``, no hay garantía de que se llame a "

"``tp_init`` (por ejemplo, el módulo :mod:`pickle` por defecto no llama a :"

"meth:`__init__` en instancias no controladas ) También se puede llamar "

"varias veces. Cualquiera puede llamar al método :meth:`__init__` en nuestros "

"objetos. Por esta razón, debemos tener mucho cuidado al asignar los nuevos "

"valores de atributo. Podríamos sentirnos tentados, por ejemplo, a asignar el "

"``primer`` miembro de esta manera:"

#: ../Doc/extending/newtypes_tutorial.rst:405

msgid ""

"But this would be risky. Our type doesn't restrict the type of the "

"``first`` member, so it could be any kind of object. It could have a "

"destructor that causes code to be executed that tries to access the "

"``first`` member; or that destructor could release the :term:`Global "

"interpreter Lock <GIL>` and let arbitrary code run in other threads that "

"accesses and modifies our object."

msgstr ""

"Pero esto sería arriesgado. Nuestro tipo no restringe el tipo del ``primer`` "

"miembro, por lo que podría ser cualquier tipo de objeto. Podría tener un "

"destructor que haga que se ejecute código que intente acceder al ``primer`` "

"miembro; o ese destructor podría liberar el :term:`Global Interpreter Lock "

"<GIL>` y permite que se ejecute código arbitrario en otros hilos que acceden "

"y modifican nuestro objeto."

#: ../Doc/extending/newtypes_tutorial.rst:412

msgid ""

"To be paranoid and protect ourselves against this possibility, we almost "

"always reassign members before decrementing their reference counts. When "

"don't we have to do this?"

msgstr ""

"Para ser paranoicos y protegernos de esta posibilidad, casi siempre "

"reasignamos miembros antes de disminuir sus recuentos de referencias. "

"¿Cuándo no tenemos que hacer esto?"

#: ../Doc/extending/newtypes_tutorial.rst:416

msgid "when we absolutely know that the reference count is greater than 1;"

msgstr ""

"cuando sabemos absolutamente que el recuento de referencia es mayor que 1;"

#: ../Doc/extending/newtypes_tutorial.rst:418

msgid ""

"when we know that deallocation of the object [#]_ will neither release the :"

"term:`GIL` nor cause any calls back into our type's code;"

msgstr ""

"cuando sabemos que la desasignación del objeto [#]_ no liberará el :term:"

"`GIL` ni causará ninguna llamada al código de nuestro tipo;"

#: ../Doc/extending/newtypes_tutorial.rst:421

msgid ""

"when decrementing a reference count in a :c:member:`~PyTypeObject."

"tp_dealloc` handler on a type which doesn't support cyclic garbage "

"collection [#]_."

msgstr ""

"al disminuir un recuento de referencias en un manejador :c:member:"

"`~PyTypeObject.tp_dealloc` en un tipo que no admite la recolección de basura "

"cíclica [#]_."

#: ../Doc/extending/newtypes_tutorial.rst:424

msgid ""

"We want to expose our instance variables as attributes. There are a number "

"of ways to do that. The simplest way is to define member definitions::"

msgstr ""

"Queremos exponer nuestras variables de instancia como atributos. Hay varias "

"formas de hacerlo. La forma más simple es definir definiciones de miembros::"

#: ../Doc/extending/newtypes_tutorial.rst:437

msgid ""

"and put the definitions in the :c:member:`~PyTypeObject.tp_members` slot::"

msgstr ""

"y poner las definiciones en la ranura :c:member:`~PyTypeObject.tp_members`::"

#: ../Doc/extending/newtypes_tutorial.rst:441

msgid ""

"Each member definition has a member name, type, offset, access flags and "

"documentation string. See the :ref:`Generic-Attribute-Management` section "

"below for details."

msgstr ""

"Cada definición de miembro tiene un nombre de miembro, tipo, desplazamiento, "

"banderas de acceso y cadena de caracteres de documentación. Consulte la "

"sección :ref:`Generic-Attribute-Management` a continuación para obtener más "

"detalles."

#: ../Doc/extending/newtypes_tutorial.rst:445

msgid ""

"A disadvantage of this approach is that it doesn't provide a way to restrict "

"the types of objects that can be assigned to the Python attributes. We "

"expect the first and last names to be strings, but any Python objects can be "

"assigned. Further, the attributes can be deleted, setting the C pointers to "

"``NULL``. Even though we can make sure the members are initialized to non-"

"``NULL`` values, the members can be set to ``NULL`` if the attributes are "

"deleted."

msgstr ""

"Una desventaja de este enfoque es que no proporciona una forma de restringir "

"los tipos de objetos que se pueden asignar a los atributos de Python. "

"Esperamos que el nombre y el apellido sean cadenas, pero se pueden asignar "

"objetos de Python. Además, los atributos se pueden eliminar, configurando "

"los punteros C en ``NULL``. Si bien podemos asegurarnos de que los miembros "

"se inicialicen en valores que no sean ``NULL``, los miembros se pueden "

"establecer en ``NULL`` si se eliminan los atributos."

#: ../Doc/extending/newtypes_tutorial.rst:452

#, fuzzy

msgid ""

"We define a single method, :meth:`!Custom.name()`, that outputs the objects "

"name as the concatenation of the first and last names. ::"

msgstr ""

"Definimos un método único, :meth:`Custom.name()`, que genera el nombre de "

"los objetos como la concatenación de los nombres y apellidos. ::"

#: ../Doc/extending/newtypes_tutorial.rst:469

#, fuzzy

msgid ""

"The method is implemented as a C function that takes a :class:`!Custom` (or :"

"class:`!Custom` subclass) instance as the first argument. Methods always "

"take an instance as the first argument. Methods often take positional and "

"keyword arguments as well, but in this case we don't take any and don't need "

"to accept a positional argument tuple or keyword argument dictionary. This "

"method is equivalent to the Python method:"

msgstr ""

"El método se implementa como una función C que toma una instancia de :class:"

"`Custom` (o subclase :class:`Custom`) como primer argumento. Los métodos "

"siempre toman una instancia como primer argumento. Los métodos a menudo "

"también toman argumentos posicionales y de palabras clave, pero en este caso "

"no tomamos ninguno y no necesitamos aceptar una tupla de argumentos "

"posicionales o un diccionario de argumentos de palabras clave. Este método "

"es equivalente al método Python:"

#: ../Doc/extending/newtypes_tutorial.rst:481

#, fuzzy

msgid ""

"Note that we have to check for the possibility that our :attr:`!first` and :"

"attr:`!last` members are ``NULL``. This is because they can be deleted, in "

"which case they are set to ``NULL``. It would be better to prevent deletion "

"of these attributes and to restrict the attribute values to be strings. "

"We'll see how to do that in the next section."

msgstr ""

"Tenga en cuenta que tenemos que verificar la posibilidad de que nuestros "

"miembros :attr:`first` y :attr:`last` sean ``NULL``. Esto se debe a que se "

"pueden eliminar, en cuyo caso se establecen en ``NULL``. Sería mejor evitar "

"la eliminación de estos atributos y restringir los valores de los atributos "

"para que sean cadenas de caracteres. Veremos cómo hacerlo en la siguiente "

"sección."

#: ../Doc/extending/newtypes_tutorial.rst:487

msgid ""

"Now that we've defined the method, we need to create an array of method "

"definitions::"

msgstr ""

"Ahora que hemos definido el método, necesitamos crear un arreglo de "

"definiciones de métodos::"

#: ../Doc/extending/newtypes_tutorial.rst:497

#, fuzzy

msgid ""

"(note that we used the :c:macro:`METH_NOARGS` flag to indicate that the "

"method is expecting no arguments other than *self*)"

msgstr ""

"(tenga en cuenta que usamos el indicador :const:`METH_NOARGS` para indicar "

"que el método no espera argumentos distintos de *self*)"

#: ../Doc/extending/newtypes_tutorial.rst:500

msgid "and assign it to the :c:member:`~PyTypeObject.tp_methods` slot::"

msgstr "y asignarlo a la ranura :c:member:`~PyTypeObject.tp_methods`::"

#: ../Doc/extending/newtypes_tutorial.rst:504

#, fuzzy

msgid ""

"Finally, we'll make our type usable as a base class for subclassing. We've "

"written our methods carefully so far so that they don't make any assumptions "

"about the type of the object being created or used, so all we need to do is "

"to add the :c:macro:`Py_TPFLAGS_BASETYPE` to our class flag definition::"

msgstr ""

"Finalmente, haremos que nuestro tipo sea utilizable como una clase base para "

"la subclase. Hemos escrito nuestros métodos cuidadosamente hasta ahora para "

"que no hagan suposiciones sobre el tipo de objeto que se está creando o "

"utilizando, por lo que todo lo que tenemos que hacer es agregar :const:"

"`Py_TPFLAGS_BASETYPE` a nuestra definición de bandera de clase::"

#: ../Doc/extending/newtypes_tutorial.rst:511

#, fuzzy

msgid ""

"We rename :c:func:`!PyInit_custom` to :c:func:`!PyInit_custom2`, update the "

"module name in the :c:type:`PyModuleDef` struct, and update the full class "

"name in the :c:type:`PyTypeObject` struct."

msgstr ""

"Cambiamos el nombre de :c:func:`PyInit_custom` a :c:func:`PyInit_custom2`, "

"actualizamos el nombre del módulo en la estructura :c:type:`PyModuleDef` y "

"actualizamos el nombre completo de la clase en la estructura :c:type:"

"`PyTypeObject`."

#: ../Doc/extending/newtypes_tutorial.rst:515

#, fuzzy

msgid "Finally, we update our :file:`setup.py` file to include the new module,"

msgstr ""

"Finalmente, actualizamos nuestro archivo :file:`setup.py` para construir el "

"nuevo módulo:"

#: ../Doc/extending/newtypes_tutorial.rst:525

msgid "and then we re-install so that we can ``import custom2``:"

msgstr ""

#: ../Doc/extending/newtypes_tutorial.rst:532

msgid "Providing finer control over data attributes"

msgstr "Proporcionar un control más preciso sobre los atributos de datos"

#: ../Doc/extending/newtypes_tutorial.rst:534

#, fuzzy

msgid ""

"In this section, we'll provide finer control over how the :attr:`!first` "

"and :attr:`!last` attributes are set in the :class:`!Custom` example. In the "

"previous version of our module, the instance variables :attr:`!first` and :"

"attr:`!last` could be set to non-string values or even deleted. We want to "

"make sure that these attributes always contain strings."

msgstr ""

"En esta sección, proporcionaremos un control más preciso sobre cómo se "

"establecen los atributos :attr:`first` y :attr:`last` en el ejemplo :class:"

"`Custom`. En la versión anterior de nuestro módulo, las variables de "

"instancia :attr:`first` y :attr:`last` podrían establecerse en valores que "

"no sean de cadena o incluso eliminarse. Queremos asegurarnos de que estos "

"atributos siempre contengan cadenas."

#: ../Doc/extending/newtypes_tutorial.rst:543

#, fuzzy

msgid ""

"To provide greater control, over the :attr:`!first` and :attr:`!last` "

"attributes, we'll use custom getter and setter functions. Here are the "

"functions for getting and setting the :attr:`!first` attribute::"

msgstr ""

"Para proporcionar un mayor control sobre los atributos :attr:`first` y :attr:"

"`last`, usaremos funciones personalizadas *getter* y *setter*. Estas son las "

"funciones para obtener y configurar el atributo :attr:`first`::"

#: ../Doc/extending/newtypes_tutorial.rst:574

#, fuzzy

msgid ""

"The getter function is passed a :class:`!Custom` object and a \"closure\", "

"which is a void pointer. In this case, the closure is ignored. (The "

"closure supports an advanced usage in which definition data is passed to the "

"getter and setter. This could, for example, be used to allow a single set of "

"getter and setter functions that decide the attribute to get or set based on "

"data in the closure.)"

msgstr ""

"La función *getter* se pasa al objeto :class:`Custom` y un "

"\"cierre\" (*closure*), que es un puntero nulo. En este caso, se ignora el "

"cierre. (El cierre admite un uso avanzado en el que los datos de definición "

"se pasan al captador y al definidor. Esto podría, por ejemplo, usarse para "

"permitir un solo conjunto de funciones de captador y definidor que deciden "

"que el atributo se obtenga o establezca en función de los datos en el "

"cierre.)"

#: ../Doc/extending/newtypes_tutorial.rst:580

#, fuzzy

msgid ""

"The setter function is passed the :class:`!Custom` object, the new value, "

"and the closure. The new value may be ``NULL``, in which case the attribute "

"is being deleted. In our setter, we raise an error if the attribute is "

"deleted or if its new value is not a string."

msgstr ""

"La función *setter* pasa el objeto :class:`Custom`, el nuevo valor y el "

"cierre. El nuevo valor puede ser ``NULL``, en cuyo caso se está eliminando "

"el atributo. En nuestro *setter*, generamos un error si el atributo se "

"elimina o si su nuevo valor no es una cadena."

#: ../Doc/extending/newtypes_tutorial.rst:585

msgid "We create an array of :c:type:`PyGetSetDef` structures::"

msgstr "Creamos un arreglo de estructuras :c:type:`PyGetSetDef`::"

#: ../Doc/extending/newtypes_tutorial.rst:595

msgid "and register it in the :c:member:`~PyTypeObject.tp_getset` slot::"

msgstr "y lo registra en la ranura :c:member:`~PyTypeObject.tp_getset`::"

#: ../Doc/extending/newtypes_tutorial.rst:599

msgid ""

"The last item in a :c:type:`PyGetSetDef` structure is the \"closure\" "

"mentioned above. In this case, we aren't using a closure, so we just pass "

"``NULL``."

msgstr ""

"El último elemento en la estructura :c:type:`PyGetSetDef` es el "

"\"cierre\" (*closure*) mencionado anteriormente. En este caso, no estamos "

"usando un cierre, por lo que simplemente pasamos ``NULL``."

#: ../Doc/extending/newtypes_tutorial.rst:602

msgid "We also remove the member definitions for these attributes::"

msgstr "También eliminamos las definiciones de miembro para estos atributos::"

#: ../Doc/extending/newtypes_tutorial.rst:610

msgid ""

"We also need to update the :c:member:`~PyTypeObject.tp_init` handler to only "

"allow strings [#]_ to be passed::"

msgstr ""

"También necesitamos actualizar el manejador :c:member:`~PyTypeObject."

"tp_init` para permitir que solo se pasen las cadenas [#]_::"

#: ../Doc/extending/newtypes_tutorial.rst:639

msgid ""

"With these changes, we can assure that the ``first`` and ``last`` members "

"are never ``NULL`` so we can remove checks for ``NULL`` values in almost all "

"cases. This means that most of the :c:func:`Py_XDECREF` calls can be "

"converted to :c:func:`Py_DECREF` calls. The only place we can't change "

"these calls is in the ``tp_dealloc`` implementation, where there is the "

"possibility that the initialization of these members failed in ``tp_new``."

msgstr ""

"Con estos cambios, podemos asegurar que los miembros ``primero`` y "

"``último`` nunca sean ``NULL``, por lo que podemos eliminar las "

"comprobaciones de los valores ``NULL`` en casi todos los casos. Esto "

"significa que la mayoría de las llamadas :c:func:`Py_XDECREF` se pueden "

"convertir en llamadas :c:func:`Py_DECREF`. El único lugar donde no podemos "

"cambiar estas llamadas es en la implementación ``tp_dealloc``, donde existe "

"la posibilidad de que la inicialización de estos miembros falle en "

"``tp_new``."

#: ../Doc/extending/newtypes_tutorial.rst:646

msgid ""

"We also rename the module initialization function and module name in the "

"initialization function, as we did before, and we add an extra definition to "

"the :file:`setup.py` file."

msgstr ""

"También cambiamos el nombre de la función de inicialización del módulo y el "

"nombre del módulo en la función de inicialización, como lo hicimos antes, y "

"agregamos una definición adicional al archivo :file:`setup.py`."

#: ../Doc/extending/newtypes_tutorial.rst:652

msgid "Supporting cyclic garbage collection"

msgstr "Apoyo a la recolección de basura cíclica"

#: ../Doc/extending/newtypes_tutorial.rst:654

msgid ""

"Python has a :term:`cyclic garbage collector (GC) <garbage collection>` that "

"can identify unneeded objects even when their reference counts are not zero. "

"This can happen when objects are involved in cycles. For example, consider:"

msgstr ""

"Python tiene un :term:`recolector de basura cíclico (GC) <garbage "

"collection>` que puede identificar objetos innecesarios incluso cuando sus "

"recuentos de referencia no son cero. Esto puede suceder cuando los objetos "

"están involucrados en ciclos. Por ejemplo, considere:"

#: ../Doc/extending/newtypes_tutorial.rst:664

msgid ""

"In this example, we create a list that contains itself. When we delete it, "

"it still has a reference from itself. Its reference count doesn't drop to "

"zero. Fortunately, Python's cyclic garbage collector will eventually figure "

"out that the list is garbage and free it."

msgstr ""

"En este ejemplo, creamos una lista que se contiene a sí misma. Cuando lo "

"eliminamos, todavía tiene una referencia de sí mismo. Su recuento de "

"referencia no cae a cero. Afortunadamente, el recolector cíclico de basura "

"de Python finalmente descubrirá que la lista es basura y la liberará."

#: ../Doc/extending/newtypes_tutorial.rst:669

#, fuzzy

msgid ""

"In the second version of the :class:`!Custom` example, we allowed any kind "

"of object to be stored in the :attr:`!first` or :attr:`!last` attributes "

"[#]_. Besides, in the second and third versions, we allowed subclassing :"

"class:`!Custom`, and subclasses may add arbitrary attributes. For any of "

"those two reasons, :class:`!Custom` objects can participate in cycles:"

msgstr ""

"En la segunda versión del ejemplo :class:`Custom`, permitimos que cualquier "

"tipo de objeto se almacene en :attr:`first` o :attr:`last` atributos [#]_. "

"Además, en la segunda y tercera versión, permitimos subclases :class:"

"`Custom`, y las subclases pueden agregar atributos arbitrarios. Por "

"cualquiera de esos dos motivos, los objetos :class:`Custom` pueden "

"participar en ciclos:"

#: ../Doc/extending/newtypes_tutorial.rst:683

#, fuzzy

msgid ""

"To allow a :class:`!Custom` instance participating in a reference cycle to "

"be properly detected and collected by the cyclic GC, our :class:`!Custom` "

"type needs to fill two additional slots and to enable a flag that enables "

"these slots:"

msgstr ""

"Para permitir que una instancia de :class:`Custom` que participa en un ciclo "

"de referencia sea detectada y recolectada correctamente por el GC cíclico, "

"nuestro tipo :class:`Custom` necesita llenar dos espacios adicionales y "

"habilitar un indicador que permita estos espacios:"

#: ../Doc/extending/newtypes_tutorial.rst:690

msgid ""

"First, the traversal method lets the cyclic GC know about subobjects that "

"could participate in cycles::"

msgstr ""

"Primero, el método transversal permite que el GC cíclico conozca los "

"subobjetos que podrían participar en los ciclos::"

#: ../Doc/extending/newtypes_tutorial.rst:710