From 1bbf5547bc24b8baf998fc6a573b460afb348b00 Mon Sep 17 00:00:00 2001 From: Miguel Angel R Date: Mon, 21 Dec 2020 20:05:35 -0600 Subject: [PATCH 01/17] =?UTF-8?q?Traducci=C3=B3n=20reference/datamodel?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Closes #304. Se cierra PR #1168 y se incluyen modificaciones conjuntas. Avance a 45% --- reference/datamodel.po | 465 ++++++++++++++++++++++++++++++++++++++--- 1 file changed, 435 insertions(+), 30 deletions(-) diff --git a/reference/datamodel.po b/reference/datamodel.po index 64a7eeb182..68b190c3f0 100644 --- a/reference/datamodel.po +++ b/reference/datamodel.po @@ -11,16 +11,16 @@ msgstr "" "Project-Id-Version: Python 3.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2020-05-05 12:54+0200\n" -"PO-Revision-Date: 2020-06-09 20:48-0500\n" +"PO-Revision-Date: 2020-12-21 19:07-0600\n" "Language-Team: python-doc-es\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 2.8.0\n" "Plural-Forms: nplurals=2; plural=(n != 1);\n" -"Last-Translator: Carlos Joel Delgado Pizarro \n" +"Last-Translator: Miguel Ángel Ramírez \n" "Language: es\n" -"X-Generator: Poedit 2.3\n" +"X-Generator: Poedit 2.4.2\n" #: ../Doc/reference/datamodel.rst:6 msgid "Data model" @@ -598,9 +598,10 @@ msgid "" "placing a comma-separated list of expressions in square brackets. (Note that " "there are no special cases needed to form lists of length 0 or 1.)" msgstr "" -"The items of a list are arbitrary Python objects. Lists are formed by " -"placing a comma-separated list of expressions in square brackets. (Note that " -"there are no special cases needed to form lists of length 0 or 1.)" +"Los elementos de una lista son objetos de Python arbitrarios. Las listas se " +"forman colocando una lista de expresiones separadas por comas entre " +"corchetes. (Tome en cuenta que no hay casos especiales necesarios para " +"formar listas de longitud 0 o 1.)" #: ../Doc/reference/datamodel.rst:356 msgid "Byte Arrays" @@ -1019,12 +1020,20 @@ msgid "" "`__module__` is the name of the module the method was defined in, or " "``None`` if unavailable." msgstr "" +"Atributos especiales de solo lectura: :attr:`__self__` es el objeto de " +"instancia de clase, :attr:`__func__` es el objeto de función; :attr:" +"`__doc__` es la documentación del método (al igual que ``__func__." +"__doc__``); :attr:`~definition.__name__` es el nombre del método (al igual " +"que ``__func__.__name__``); :attr:`__module__` es el nombre del módulo en el " +"que el método fue definido, o ``None`` si no se encuentra disponible." #: ../Doc/reference/datamodel.rst:578 msgid "" "Methods also support accessing (but not setting) the arbitrary function " "attributes on the underlying function object." msgstr "" +"Los métodos también admiten obtener (más no establecer) los atributos " +"arbitrarios de la función en el objeto de función subyacente." #: ../Doc/reference/datamodel.rst:581 msgid "" @@ -1032,6 +1041,10 @@ msgid "" "class (perhaps via an instance of that class), if that attribute is a user-" "defined function object or a class method object." msgstr "" +"Los objetos de métodos definidos por usuarios pueden ser creados al obtener " +"el atributo de una clase (probablemente a través de la instancia de dicha " +"clase), si tal atributo es el objeto de una función definida por el usuario " +"o el objeto del método de una clase." #: ../Doc/reference/datamodel.rst:585 msgid "" @@ -1040,6 +1053,11 @@ msgid "" "attribute is the instance, and the method object is said to be bound. The " "new method's :attr:`__func__` attribute is the original function object." msgstr "" +"Cuando un objeto de instancia de método es creado al obtener un objeto de " +"función definida por el usuario desde una clase a través de una de sus " +"instancias, su atributo :attr:`__self__` es la instancia, y el objeto de " +"método se dice que está enlazado. El nuevo atributo de método :attr:" +"`__func__` es el objeto de función original." #: ../Doc/reference/datamodel.rst:591 msgid "" @@ -1048,6 +1066,10 @@ msgid "" "itself, and its :attr:`__func__` attribute is the function object underlying " "the class method." msgstr "" +"Cuando un objeto de instancia de método es creado al obtener un objeto de " +"método de clase a partir de una clase o instancia, su atributo :attr:" +"`__self__` es la clase misma, y su atributo :attr:`__func__` es el objeto de " +"función subyacente al método de la clase." #: ../Doc/reference/datamodel.rst:596 msgid "" @@ -1057,6 +1079,12 @@ msgid "" "contains a definition for a function :meth:`f`, and ``x`` is an instance of :" "class:`C`, calling ``x.f(1)`` is equivalent to calling ``C.f(x, 1)``." msgstr "" +"Cuando el objeto de la instancia de método es invocado, la función " +"subyacente (:attr:`__func__`) es llamada, insertando la instancia de clase (:" +"attr:`__self__`) delante de la lista de argumentos. Por ejemplo, cuando :" +"class:`C` es una clase que contiene la definición de una función :meth:`f`, " +"y ``x`` es una instancia de :class:`C`, invocar ``x.f(1)`` es equivalente a " +"invocar ``C.f(x, 1)``." #: ../Doc/reference/datamodel.rst:603 msgid "" @@ -1065,6 +1093,10 @@ msgid "" "itself, so that calling either ``x.f(1)`` or ``C.f(1)`` is equivalent to " "calling ``f(C,1)`` where ``f`` is the underlying function." msgstr "" +"Cuando el objeto de instancia de método es derivado del objeto del método de " +"clase, la “instancia de clase” almacenada en :attr:`__self__` en realidad " +"será la clase misma, de manera que invocar ya sea ``x.f(1)``o ``C.f(1)`` es " +"equivalente a invocar ``f(C,1)`` donde ``f`` es la función subyacente." #: ../Doc/reference/datamodel.rst:608 msgid "" @@ -1078,10 +1110,20 @@ msgid "" "class instance are not converted to bound methods; this *only* happens when " "the function is an attribute of the class." msgstr "" +"Tome en cuenta que la transformación de objeto de función a objeto de método " +"de instancia ocurre cada vez que el atributo es obtenido de la instancia. " +"En algunos casos, una optimización fructífera es asignar el atributo a una " +"variable local e invocarla. Note también que esta transformación únicamente " +"ocurre con funciones definidas por usuario; otros objetos invocables (y " +"todos los objetos no invocables) son obtenidos sin transformación. También " +"es importante mencionar que las funciones definidas por el usuario, que son " +"atributos de la instancia de una clase no son convertidos a métodos " +"enlazados; esto ocurre *únicamente* cuando la función es un atributo de la " +"clase." #: ../Doc/reference/datamodel.rst:632 msgid "Generator functions" -msgstr "" +msgstr "Funciones generadoras" #: ../Doc/reference/datamodel.rst:624 msgid "" @@ -1095,10 +1137,19 @@ msgid "" "raised and the iterator will have reached the end of the set of values to be " "returned." msgstr "" +"Una función o método que utiliza la declaración :keyword:`yield` (ver " +"sección :ref:`yield`) se llama :dfn:`generator function`. Dicha función, " +"cuando es invocada, siempre devuelve un objeto iterador que puede ser " +"utilizado para ejecutar el cuerpo de la función: invocando el método " +"iterador :meth:`iterator.__next__` hará que la función se ejecute hasta " +"proporcionar un valor utilizando la declaración :keyword:`!yield`. Cuando " +"la función ejecuta una declaración :keyword:`return` o llega hasta el final, " +"una excepción :exc:`StopIteration` es lanzada y el iterador habrá llegado al " +"final del conjunto de valores a ser devueltos." #: ../Doc/reference/datamodel.rst:642 msgid "Coroutine functions" -msgstr "" +msgstr "Funciones de corrutina" #: ../Doc/reference/datamodel.rst:638 msgid "" @@ -1108,10 +1159,15 @@ msgid "" "as :keyword:`async with` and :keyword:`async for` statements. See also the :" "ref:`coroutine-objects` section." msgstr "" +"Una función o método que es definido utilizando :keyword:`async def` se " +"llama :dfn:`coroutine function`. Dicha función, cuando es invocada, retorna " +"un objeto :term:`coroutine`. Éste puede contener expresiones :keyword:" +"`await`, así como declaraciones :keyword:`async with` y :keyword:`async " +"for`. Ver también la sección :ref:`coroutine-objects`." #: ../Doc/reference/datamodel.rst:661 msgid "Asynchronous generator functions" -msgstr "" +msgstr "Funciones generadoras asincrónicas" #: ../Doc/reference/datamodel.rst:649 msgid "" @@ -1121,6 +1177,11 @@ msgid "" "object which can be used in an :keyword:`async for` statement to execute the " "body of the function." msgstr "" +"Una función o método que es definido usando :keyword:`async def` y que " +"utiliza la declaración :keyword:`yield` se llama :dfn:`asynchronous " +"generator function`. Dicha función, al ser invocada, retorna un objeto " +"iterador asincrónico que puede ser utilizado en una declaración :keyword:" +"`async for` para ejecutar el cuerpo de la función." #: ../Doc/reference/datamodel.rst:655 msgid "" @@ -1131,10 +1192,16 @@ msgid "" "`StopAsyncIteration` exception is raised and the asynchronous iterator will " "have reached the end of the set of values to be yielded." msgstr "" +"Invocando el método del iterador asincrónico :meth:`aiterator.__anext__` " +"retornará un :term:`awaitable` que al ser esperado se ejecutará hasta " +"proporcionar un valor utilizando la expresión :keyword:`yield`. Cuando la " +"función ejecuta una declaración :keyword:`return` vacía o llega a su final, " +"una excepción :exc:`StopAsyncIteration` es lanzada y el iterador asincrónico " +"habrá llegado al final del conjunto de valores a ser producidos." #: ../Doc/reference/datamodel.rst:676 msgid "Built-in functions" -msgstr "" +msgstr "Funciones incorporadas" #: ../Doc/reference/datamodel.rst:669 msgid "" @@ -1147,10 +1214,20 @@ msgid "" "``None`` (but see the next item); :attr:`__module__` is the name of the " "module the function was defined in or ``None`` if unavailable." msgstr "" +"Un objeto de función incorporada es un envoltorio (wrapper) alrededor de una " +"función C. Ejemplos de funciones incorporadas son :func:`len` y :func:`math." +"sin` (:mod:`math` es un módulo estándar incorporado). El número y tipo de " +"argumentos son determinados por la función C. Atributos especiales de solo " +"lectura: :attr:`__doc__` es la cadena de documentación de la función, o " +"``None`` si no se encuentra disponible; :attr:`~definition.__name__` es el " +"nombre de la función; :attr:`__init__` es establecido como ``None`` (sin " +"embargo ver el siguiente elemento); :attr:`__module__` es el nombre del " +"módulo en el que la función fue definida o ``None`` si no se encuentra " +"disponible." #: ../Doc/reference/datamodel.rst:688 msgid "Built-in methods" -msgstr "" +msgstr "Métodos incorporados" #: ../Doc/reference/datamodel.rst:684 msgid "" @@ -1160,10 +1237,16 @@ msgid "" "*alist* is a list object. In this case, the special read-only attribute :" "attr:`__self__` is set to the object denoted by *alist*." msgstr "" +"Éste es realmente un disfraz distinto de una función incorporada, esta vez " +"teniendo un objeto que se pasa a la función C como un argumento extra " +"implícito. Un ejemplo de un método incorporado es ``alist.append()``, " +"asumiendo que *alist* es un objeto de lista. En este caso, el atributo " +"especial de solo lectura :attr:`__self__` es establecido al objeto indicado " +"por *alist*." #: ../Doc/reference/datamodel.rst:695 msgid "Classes" -msgstr "" +msgstr "Clases" #: ../Doc/reference/datamodel.rst:691 msgid "" @@ -1173,20 +1256,27 @@ msgid "" "`__new__` and, in the typical case, to :meth:`__init__` to initialize the " "new instance." msgstr "" +"Las clases son invocables. Estos objetos normalmente actúan como fábricas " +"de nuevas instancias de ellos mismos, pero las variaciones son posibles para " +"los tipos de clases que anulan :meth:`__new__`. Los argumentos de la " +"invocación son pasados a :meth:`__new__` y, en el caso típico, a :meth:" +"`__init__` para iniciar la nueva instancia." #: ../Doc/reference/datamodel.rst:700 msgid "Class Instances" -msgstr "" +msgstr "Instancias de clases" #: ../Doc/reference/datamodel.rst:698 msgid "" "Instances of arbitrary classes can be made callable by defining a :meth:" "`__call__` method in their class." msgstr "" +"Las instancias de clases arbitrarias se pueden hacer invocables definiendo " +"el método :meth:`__call__` en su clase." #: ../Doc/reference/datamodel.rst:750 msgid "Modules" -msgstr "" +msgstr "Módulos" #: ../Doc/reference/datamodel.rst:707 msgid "" @@ -1201,12 +1291,25 @@ msgid "" "not contain the code object used to initialize the module (since it isn't " "needed once the initialization is done)." msgstr "" +"Los módulos son una unidad básica organizacional en código Python, y son " +"creados por el :ref:`import system ` al ser invocados ya sea " +"por la declaración :keyword:`import`, o invocando funciones como :func:" +"`importlib.import_module` y la incorporada :func:`__import__`. Un objeto de " +"módulo tiene un espacio de nombres implementado por un objeto de diccionario " +"(éste es el diccionario al que hace referencia el atributo de funciones " +"``__globals__`` definido en el módulo). Las referencias de atributos son " +"traducidas a búsquedas en este diccionario, p. ej., ``m.x`` es equivalente a " +"``m.__dict__[“x”]``. Un objeto de módulo no contiene el objeto de código " +"utilizado para iniciar el módulo (ya que no es necesario una vez que la " +"inicialización es realizada)." #: ../Doc/reference/datamodel.rst:719 msgid "" "Attribute assignment updates the module's namespace dictionary, e.g., ``m.x " "= 1`` is equivalent to ``m.__dict__[\"x\"] = 1``." msgstr "" +"La asignación de atributos actualiza el diccionario de espacio de nombres " +"del módulo, p. ej., ``m.x = 1`` es equivalente a ``m.__dict__[“x”] = 1``." #: ../Doc/reference/datamodel.rst:729 msgid "" @@ -1221,12 +1324,25 @@ msgid "" "loaded dynamically from a shared library, it is the pathname of the shared " "library file." msgstr "" +"Atributos predefinidos (escribibles): :attr:`__name__` es el nombre del " +"módulo; :attr:`__doc__` es la cadena de documentación del módulo, o ``None`` " +"si no se encuentra disponible; :attr:`__annotations__` (opcional) es un " +"diccionario que contiene :term:`variable annotations ` " +"recolectado durante la ejecución del cuerpo del módulo; :attr:`__file__` es " +"el nombre de ruta del archivo en el cual el módulo fue cargado, si fue " +"cargado desde un archivo. El atributo :attr:`__file__` puede faltar para " +"ciertos tipos de módulos, tal como módulos C que son vinculados " +"estáticamente al intérprete; para módulos de extensión cargados " +"dinámicamente desde una librería compartida, es el nombre de ruta del " +"archivo de la librería compartida." #: ../Doc/reference/datamodel.rst:742 msgid "" "Special read-only attribute: :attr:`~object.__dict__` is the module's " "namespace as a dictionary object." msgstr "" +"El atributo especial de solo lectura :attr:`~object.__dict__` es el espacio " +"de nombres del módulo como un objeto de diccionario." #: ../Doc/reference/datamodel.rst:747 msgid "" @@ -1235,10 +1351,15 @@ msgid "" "still has live references. To avoid this, copy the dictionary or keep the " "module around while using its dictionary directly." msgstr "" +"Debido a la manera en la que CPython limpia los diccionarios de módulo, el " +"diccionario de módulo será limpiado cuando el módulo se encuentra fuera de " +"alcance, incluso si el diccionario aún tiene referencias existentes. Para " +"evitar esto, copie el diccionario o mantenga el módulo cerca mientras usa el " +"diccionario directamente." #: ../Doc/reference/datamodel.rst:809 msgid "Custom classes" -msgstr "" +msgstr "Clases personalizadas" #: ../Doc/reference/datamodel.rst:753 msgid "" @@ -1255,6 +1376,19 @@ msgid "" "found in the documentation accompanying the 2.3 release at https://www." "python.org/download/releases/2.3/mro/." msgstr "" +"Los tipos de clases personalizadas son normalmente creadas por definiciones " +"de clases (ver sección :ref:`class`). Una clase tiene implementado un " +"espacio de nombres por un objeto de diccionario. Las referencias de " +"atributos de clase son traducidas a búsquedas en este diccionario, p. ej., " +"``C.x`` es traducido a ``C.__dict__[“x”]`` (aunque hay una serie de enlaces " +"que permiten la ubicación de atributos por otros medios). Cuando el nombre " +"de atributo no es encontrado ahí, la búsqueda de atributo continúa en las " +"clases base. Esta búsqueda de las clases base utiliza la orden de resolución " +"de métodos C3 que se comporta correctamente aún en la presencia de " +"estructuras de herencia ‘diamante’ donde existen múltiples rutas de herencia " +"que llevan a un ancestro común. Detalles adicionales en el MRO C3 utilizados " +"por Python pueden ser encontrados en la documentación correspondiente a la " +"versión 2.3 en https://www.python.org/download/releases/2.3/mro/." #: ../Doc/reference/datamodel.rst:777 msgid "" @@ -1266,18 +1400,30 @@ msgid "" "attributes retrieved from a class may differ from those actually contained " "in its :attr:`~object.__dict__`." msgstr "" +"Cuando la referencia de un atributo de clase (digamos, para la clase :class:" +"`C`) produce un objeto de método de clase, éste es transformado a un objeto " +"de método de instancia cuyo atributo :attr:`__self__` es :class:`C`. Cuando " +"produce un objeto de un método estático, éste es transformado al objeto " +"envuelto por el objeto de método estático. Ver sección :ref:`descriptors` " +"para otra manera en la que los atributos obtenidos de una clase pueden " +"diferir de los que en realidad están contenidos en su :attr:`~object." +"__dict__`." #: ../Doc/reference/datamodel.rst:787 msgid "" "Class attribute assignments update the class's dictionary, never the " "dictionary of a base class." msgstr "" +"Las asignaciones de atributos de clase actualizan el diccionario de la " +"clase, nunca el diccionario de la clase base." #: ../Doc/reference/datamodel.rst:792 msgid "" "A class object can be called (see above) to yield a class instance (see " "below)." msgstr "" +"Un objeto de clase puede ser invocado (ver arriba) para producir una " +"instancia de clase (ver a continuación)." #: ../Doc/reference/datamodel.rst:802 msgid "" @@ -1290,10 +1436,19 @@ msgid "" "(optional) is a dictionary containing :term:`variable annotations ` collected during class body execution." msgstr "" +"Atributos especiales: :attr:`~definition.__name__` es el nombre de la " +"clase; :attr:`__module__` es el nombre del módulo en el que la clase fue " +"definida; :attr:`~object.__dict__` es el diccionario que contiene el espacio " +"de nombres de la clase; :attr:`~class.__bases__` es una tupla que contiene " +"las clases base, en orden de ocurrencia en la lista de clases base; :attr:" +"`__doc__` es la cadena de documentación de la clase, o ``None`` si no está " +"definida; :attr:`__annotations__` (opcional) es un diccionario que contiene :" +"term:`variable annotations ` recolectado durante la " +"ejecución del cuerpo de la clase." #: ../Doc/reference/datamodel.rst:852 msgid "Class instances" -msgstr "" +msgstr "Instancias de clase" #: ../Doc/reference/datamodel.rst:818 msgid "" @@ -1311,6 +1466,21 @@ msgid "" "class attribute is found, and the object's class has a :meth:`__getattr__` " "method, that is called to satisfy the lookup." msgstr "" +"Una instancia de clase es creado al invocar un objeto de clase (ver " +"arriba). Una instancia de clase tiene implementado un espacio de nombres " +"como diccionario que es el primer lugar en el que se buscan referencias de " +"atributos. Cuando un atributo no es encontrado ahí, y la clase de instancia " +"tiene un atributo con ese nombre, la búsqueda continúa con los atributos de " +"clase. Si se encuentra que un atributo de clase es un objeto de función " +"definido por el usuario, es transformado en un objeto de método de instancia " +"cuyo atributo :attr:`__self__` es la instancia. Los objetos de método y " +"método de clase estáticos también son transformados; ver más adelante debajo " +"de “Clases”. Ver sección :ref:`descriptors` para otra forma en la que los " +"atributos de una clase obtenida a través de sus instancias puede diferir de " +"los objetos realmente almacenados en el :attr:`~object.__dict__` de la " +"clase. Si no se encuentra ningún atributo de clase, y la clase del objeto " +"tiene un método :meth:`__getattr__`, éste es llamado para satisfacer la " +"búsqueda." #: ../Doc/reference/datamodel.rst:834 msgid "" @@ -1319,22 +1489,31 @@ msgid "" "`__delattr__` method, this is called instead of updating the instance " "dictionary directly." msgstr "" +"Asignación y eliminación de atributos actualizan el diccionario de la " +"instancia, nunca el diccionario de la clase. Si la clase tiene un método :" +"meth:`__setattr__` o :meth:`__delattr__`, éste es invocado en lugar de " +"actualizar el diccionario de la instancia directamente." #: ../Doc/reference/datamodel.rst:844 msgid "" "Class instances can pretend to be numbers, sequences, or mappings if they " "have methods with certain special names. See section :ref:`specialnames`." msgstr "" +"Instancias de clases pueden pretender ser números, secuencias o mapeos si " +"tienen métodos con ciertos nombres especiales. Ver sección :ref:" +"`specialnames`." #: ../Doc/reference/datamodel.rst:851 msgid "" "Special attributes: :attr:`~object.__dict__` is the attribute dictionary; :" "attr:`~instance.__class__` is the instance's class." msgstr "" +"Atributos especiales: :attr:`~object.__dict__` es el diccionario de " +"atributos; :attr:`~instance.__class__` es la clase de la instancia." #: ../Doc/reference/datamodel.rst:878 msgid "I/O objects (also known as file objects)" -msgstr "" +msgstr "Objetos E/S (también conocidos como objetos de archivo)" #: ../Doc/reference/datamodel.rst:868 msgid "" @@ -1344,6 +1523,11 @@ msgid "" "makefile` method of socket objects (and perhaps by other functions or " "methods provided by extension modules)." msgstr "" +"Un :term:`file object` representa un archivo abierto. Diversos accesos " +"directos se encuentran disponibles para crear objetos de archivo: la función " +"incorporada :func:`open`, así como :func:`os.popen`, :func:`os.fdopen`, y el " +"método de objetos socket :meth:`~socket.makefile` (y quizás por otras " +"funciones y métodos proporcionados por módulos de extensión)." #: ../Doc/reference/datamodel.rst:874 msgid "" @@ -1352,10 +1536,15 @@ msgid "" "and error streams; they are all open in text mode and therefore follow the " "interface defined by the :class:`io.TextIOBase` abstract class." msgstr "" +"Los objetos ``sys.stdin``, ``sys.stdout`` y ``sys.stderr`` son iniciados a " +"objetos de archivos correspondientes a la entrada y salida estándar del " +"intérprete, así como flujos de error; todos ellos están abiertos en el modo " +"de texto y por lo tanto siguen la interface definida por la clase abstracta :" +"class:`io.TextIOBase`." #: ../Doc/reference/datamodel.rst:1123 msgid "Internal types" -msgstr "" +msgstr "Tipos internos" #: ../Doc/reference/datamodel.rst:885 msgid "" @@ -1363,10 +1552,13 @@ msgid "" "Their definitions may change with future versions of the interpreter, but " "they are mentioned here for completeness." msgstr "" +"Algunos tipos utilizados internamente por el intérprete son expuestos al " +"usuario. Sus definiciones pueden cambiar en futuras versiones del " +"intérprete, pero son mencionadas aquí para complementar." #: ../Doc/reference/datamodel.rst:960 msgid "Code objects" -msgstr "" +msgstr "Objetos de código" #: ../Doc/reference/datamodel.rst:892 msgid "" @@ -1379,6 +1571,16 @@ msgid "" "run-time). Unlike function objects, code objects are immutable and contain " "no references (directly or indirectly) to mutable objects." msgstr "" +"Los objetos de código representan código de Python ejecutable *compilado por " +"bytes*, o :term:`bytecode`. La diferencia entre un objeto de código y un " +"objeto de función es que el objeto de función contiene una referencia " +"explícita a los globales de la función (el módulo en el que fue definido), " +"mientras el objeto de código no contiene contexto; de igual manera los " +"valores por defecto de los argumentos son almacenados en el objeto de " +"función, no en el objeto de código (porque representan valores calculados en " +"tiempo de ejecución). A diferencia de objetos de función, los objetos de " +"código son inmutables y no contienen referencias (directas o indirectas) a " +"objetos mutables." #: ../Doc/reference/datamodel.rst:919 msgid "" @@ -1403,6 +1605,28 @@ msgid "" "interpreter); :attr:`co_stacksize` is the required stack size; :attr:" "`co_flags` is an integer encoding a number of flags for the interpreter." msgstr "" +"Atributos especiales de solo lectura: :attr:`co_name` da el nombre de la " +"función; :attr:`co_argcount` es el número total de argumentos posicionales " +"(incluyendo argumentos únicamente posicionales y argumentos con valores por " +"default); :attr:`co_posonlyargcount` es el número de argumentos únicamente " +"posicionales (incluyendo argumentos con valores por default); :attr:" +"`co_kwonlyargcountp` es el número de argumentos solo de palabra clave " +"(incluyendo argumentos con valores por default); :attr:`co_nlocals` es el " +"número de variables usadas por la función (incluyendo argumentos); :attr:" +"`co_varnames` es una tupla que contiene los nombres con las variables " +"locales (empezando con los nombres de argumento); :attr:`co_cellvars` es una " +"tupla que contiene los nombres de variables locales que son referenciadas " +"por funciones anidadas; :attr:`co_freevars` es una tupla que contiene los " +"nombres de variables libres; :attr:`co_code` es una cadena que representa la " +"secuencia de instrucciones de bytecode; :attr:`co_consts` es una tupla que " +"contiene las literales usadas por el bytecode; :attr:`co_names` es una tupla " +"que contiene los nombres usados por el bytecode; :attr:`co_filename` es el " +"nombre de archivo de donde el código fue compilado; :attr:`co_firstlineno` " +"es el primer número de línea de la función; :attr:`co_lnotab` es una cadena " +"codificando el mapeo desde el desplazamiento de bytecode al número de líneas " +"(ver el código fuente del intérprete para más detalles); :attr:" +"`co_stacksize` es el tamaño de pila requerido; :attr:`co_flags` es un entero " +"codificando el número de banderas para el intérprete." #: ../Doc/reference/datamodel.rst:943 msgid "" @@ -1412,6 +1636,12 @@ msgid "" "``**keywords`` syntax to accept arbitrary keyword arguments; bit ``0x20`` is " "set if the function is a generator." msgstr "" +"Los siguientes bits de bandera son definidos por :attr:`co_flags` : bit " +"``0x04`` es establecido si la función utiliza la sintaxis ``*arguments`` " +"para aceptar un número arbitrario de argumentos posicionales; bit ``0x08`` " +"es establecido si la función utiliza la sintaxis ``**keywords`` para aceptar " +"argumentos de palabras clave arbitrarios; bit ``0x20`` es establecido si la " +"función es un generador." #: ../Doc/reference/datamodel.rst:949 msgid "" @@ -1421,26 +1651,38 @@ msgid "" "compiled with future division enabled; bits ``0x10`` and ``0x1000`` were " "used in earlier versions of Python." msgstr "" +"Declaraciones de características futuras (``from __future__ import " +"division``) también utiliza bits en :attr:`co_flags` para indicar si el " +"objeto de código fue compilado con alguna característica particular " +"habilitada: el bit ``0x2000`` es establecido si la función fue compilada con " +"división futura habilitada; los bits ``0x10`` y ``0x1000`` fueron utilizados " +"en versiones previas de Python." #: ../Doc/reference/datamodel.rst:955 msgid "Other bits in :attr:`co_flags` are reserved for internal use." -msgstr "" +msgstr "Otros bits en :attr:`co_flags` son reservados para uso interno." #: ../Doc/reference/datamodel.rst:959 msgid "" "If a code object represents a function, the first item in :attr:`co_consts` " "is the documentation string of the function, or ``None`` if undefined." msgstr "" +"Si un objeto de código representa una función, el primer elemento en :attr:" +"`co_consts` es la cadena de documentación de la función, o ``None`` si no " +"está definido." #: ../Doc/reference/datamodel.rst:1019 msgid "Frame objects" -msgstr "" +msgstr "Objetos de marco" #: ../Doc/reference/datamodel.rst:967 msgid "" "Frame objects represent execution frames. They may occur in traceback " "objects (see below), and are also passed to registered trace functions." msgstr "" +"Los objetos de marco representan marcos de ejecución. Pueden ocurrir en " +"objetos de rastreo (ver a continuación), y son también pasados hacia " +"funciones de rastreo registradas." #: ../Doc/reference/datamodel.rst:978 msgid "" @@ -1452,6 +1694,14 @@ msgid "" "names; :attr:`f_lasti` gives the precise instruction (this is an index into " "the bytecode string of the code object)." msgstr "" +"Atributos especiales de solo lectura: :attr:`f_back` es para el marco de " +"pila anterior (hacia quien produce el llamado), o ``None`` si éste es el " +"marco de pila inferior; :attr:`f_code` es el objeto de código ejecutado en " +"este marco; :attr:`f_locals` es el diccionario utilizado para buscar " +"variables locales; :attr:`f_globals` es usado por las variables globales; :" +"attr:`f_builtins` es utilizado por nombres incorporados (intrínsecos); :attr:" +"`f_lasti` da la instrucción precisa (éste es un índice dentro de la cadena " +"de bytecode del objeto de código)." #: ../Doc/reference/datamodel.rst:992 msgid "" @@ -1460,6 +1710,11 @@ msgid "" "debugger). Normally an event is triggered for each new source line - this " "can be disabled by setting :attr:`f_trace_lines` to :const:`False`." msgstr "" +"Atributos especiales escribibles: :attr:`f_trace`, de lo contrario ``None``, " +"es una función llamada por distintos eventos durante la ejecución del código " +"(éste es utilizado por el depurador). Normalmente un evento es desencadenado " +"por cada una de las líneas fuente - esto puede ser deshabilitado " +"estableciendo :attr:`f_trace_lines` a :const:`False`." #: ../Doc/reference/datamodel.rst:997 msgid "" @@ -1468,6 +1723,11 @@ msgid "" "undefined interpreter behaviour if exceptions raised by the trace function " "escape to the function being traced." msgstr "" +"Las implementaciones *pueden* permitir que eventos por código de operación " +"sean solicitados estableciendo :attr:`f_trace_opcodes` a :const:`True`. " +"Tenga en cuenta que esto puede llevar a un comportamiento indefinido del " +"intérprete si se levantan excepciones por la función de rastreo escape hacia " +"la función que está siendo rastreada." #: ../Doc/reference/datamodel.rst:1002 msgid "" @@ -1476,10 +1736,15 @@ msgid "" "most frame). A debugger can implement a Jump command (aka Set Next " "Statement) by writing to f_lineno." msgstr "" +":attr:`f_lineno` es el número de línea actual del marco --- escribiendo a " +"esta forma dentro de una función de rastreo salta a la línea dada (solo para " +"el último marco). Un depurador puede implementar un comando de salto " +"(*Jump*) (también conocido como *Set Next Statement*) al escribir en " +"f_lineno." #: ../Doc/reference/datamodel.rst:1007 msgid "Frame objects support one method:" -msgstr "" +msgstr "Objetos de marco soportan un método:" #: ../Doc/reference/datamodel.rst:1011 msgid "" @@ -1488,14 +1753,19 @@ msgid "" "This helps break reference cycles involving frame objects (for example when " "catching an exception and storing its traceback for later use)." msgstr "" +"Este método limpia todas las referencias a variables locales mantenidas por " +"el marco. También, si el marco pertenecía a un generador, éste es " +"finalizado. Esto ayuda a interrumpir los ciclos de referencia que involucran " +"objetos de marco (por ejemplo al detectar una excepción y almacenando su " +"rastro para uso posterior)." #: ../Doc/reference/datamodel.rst:1017 msgid ":exc:`RuntimeError` is raised if the frame is currently executing." -msgstr "" +msgstr ":exc:`RuntimeError` es lanzado si el marco se encuentra en ejecución." #: ../Doc/reference/datamodel.rst:1079 msgid "Traceback objects" -msgstr "" +msgstr "Objetos de seguimiento de pila (traceback)" #: ../Doc/reference/datamodel.rst:1034 msgid "" @@ -1503,6 +1773,10 @@ msgid "" "object is implicitly created when an exception occurs, and may also be " "explicitly created by calling :class:`types.TracebackType`." msgstr "" +"Los objetos de seguimiento de pila representan el trazo de pila (*stack " +"trace*) de una excepción. Un objeto de rastreo es creado de manera implícita " +"cuando se da una excepción, y puede ser creada de manera explícita al " +"llamar :class:`types.TracebackType`." #: ../Doc/reference/datamodel.rst:1038 msgid "" @@ -1513,6 +1787,13 @@ msgid "" "`try`.) It is accessible as the third item of the tuple returned by ``sys." "exc_info()``, and as the ``__traceback__`` attribute of the caught exception." msgstr "" +"Para seguimientos de pila (tracebacks) creados de manera implícita, cuando " +"la búsqueda por un manejo de excepciones desenvuelve la pila de ejecución, " +"en cada nivel de desenvolvimiento se inserta un objeto de rastreo al frente " +"del rastreo actual. Cuando se entra a un manejo de excepción, la pila de " +"rastreo se vuelve disponible para el programa. (Ver sección :ref:`try`.) Es " +"accesible como el tercer elemento de la tupla devuelta por ``sys." +"exc_info()``, y como el atributo ``__traceback__`` de la excepción capturada." #: ../Doc/reference/datamodel.rst:1046 msgid "" @@ -1520,6 +1801,10 @@ msgid "" "(nicely formatted) to the standard error stream; if the interpreter is " "interactive, it is also made available to the user as ``sys.last_traceback``." msgstr "" +"Cuando el programa no contiene un gestor apropiado, el trazo de pila es " +"escrito (muy bien formateado) a la secuencia de error estándar; si el " +"intérprete es interactivo, también se vuelve disponible al usuario como " +"``sys.last_traceback``." #: ../Doc/reference/datamodel.rst:1051 msgid "" @@ -1527,6 +1812,9 @@ msgid "" "to determine how the ``tb_next`` attributes should be linked to form a full " "stack trace." msgstr "" +"Para seguimientos de pila creados de forma explícita, depende de su creador " +"determinar cómo los atributos ``tb_next`` deberían ser ligados para formar " +"un trazo de pila completo (*full stack trace*)." #: ../Doc/reference/datamodel.rst:1061 msgid "" @@ -1537,6 +1825,13 @@ msgid "" "number of its frame object if the exception occurred in a :keyword:`try` " "statement with no matching except clause or with a finally clause." msgstr "" +"Atributos especiales de solo lectura: :attr:`tb_frame` apunta al marco de " +"ejecución del nivel actual; :attr:`tb_lineno` da el número de línea donde " +"ocurrió la excepción; :attr:`tb_lasti` indica la instrucción precisa. El " +"número de línea y la última instrucción en el seguimiento de pila puede " +"diferir del número de línea de su objeto de marco si la excepción ocurrió en " +"una declaración :keyword:`try` sin una cláusula de excepción (except) " +"correspondiente o con una cláusula *finally*." #: ../Doc/reference/datamodel.rst:1073 msgid "" @@ -1544,22 +1839,31 @@ msgid "" "trace (towards the frame where the exception occurred), or ``None`` if there " "is no next level." msgstr "" +"Atributo especial escribible: :attr:`tb_next` es el siguiente nivel en el " +"trazo de pila (hacia el marco en donde ocurrió la excepción), o ``None`` si " +"no existe un siguiente nivel." #: ../Doc/reference/datamodel.rst:1077 msgid "" "Traceback objects can now be explicitly instantiated from Python code, and " "the ``tb_next`` attribute of existing instances can be updated." msgstr "" +"Los objetos de seguimiento de pila ya pueden ser instanciados de manera " +"explícita desde código de Python, y el atributo ``tb_next`` de instancias " +"existentes puede ser actualizado." #: ../Doc/reference/datamodel.rst:1105 msgid "Slice objects" -msgstr "" +msgstr "Objetos de segmento (Slice objects)" #: ../Doc/reference/datamodel.rst:1084 msgid "" "Slice objects are used to represent slices for :meth:`__getitem__` methods. " "They are also created by the built-in :func:`slice` function." msgstr "" +"Los objetos de segmento son utilizados para representar segmentos para " +"métodos :meth:`__getitem__`. También son creados por la función incorporada :" +"func:`slice`." #: ../Doc/reference/datamodel.rst:1092 msgid "" @@ -1567,10 +1871,14 @@ msgid "" "`~slice.stop` is the upper bound; :attr:`~slice.step` is the step value; " "each is ``None`` if omitted. These attributes can have any type." msgstr "" +"Atributos especiales de solo lectura: :attr:`~slice.start` es el límite " +"inferior; :attr:`~slice.stop` es el límite superior; :attr:`~slice.step` es " +"el valor de paso; cada uno es ``None`` si es omitido. Estos atributos pueden " +"ser de cualquier tipo." #: ../Doc/reference/datamodel.rst:1096 msgid "Slice objects support one method:" -msgstr "" +msgstr "Los objetos de segmento soportan un método:" #: ../Doc/reference/datamodel.rst:1100 msgid "" @@ -1581,10 +1889,16 @@ msgid "" "stride length of the slice. Missing or out-of-bounds indices are handled in " "a manner consistent with regular slices." msgstr "" +"Este método toma un argumento *length* de entero simple y calcula " +"información relacionada con el segmento que el mismo describiría si fuera " +"aplicado a una secuencia de elementos *length*. Devuelve una tupla de tres " +"enteros; respectivamente estos son los índices *start* y *stop* y el *step* " +"o longitud del paso del segmento. Índices faltantes o fuera de los límites " +"son manipulados de manera consistente con segmentos regulares." #: ../Doc/reference/datamodel.rst:1115 msgid "Static method objects" -msgstr "" +msgstr "Objetos de método estático" #: ../Doc/reference/datamodel.rst:1108 msgid "" @@ -1597,10 +1911,20 @@ msgid "" "callable, although the objects they wrap usually are. Static method objects " "are created by the built-in :func:`staticmethod` constructor." msgstr "" +"Los objetos de método estático proveen una forma de anular la transformación " +"de objetos de función a objetos de método descritos anteriormente. Un objeto " +"de método estático es una envoltura (*wrapper*) alrededor de cualquier otro " +"objeto, usualmente un objeto de método definido por usuario. Cuando un " +"objeto de método estático es obtenido desde una clase o una instancia de " +"clase, usualmente el objeto retornado es el objeto envuelto, el cual no está " +"objeto a ninguna transformación adicional. Los objetos de método estático no " +"pueden ser llamados, aunque generalmente los objetos que estos envuelven sí. " +"Los objetos de método estático son creados por el constructor incorporado :" +"func:`staticmethod`." #: ../Doc/reference/datamodel.rst:1123 msgid "Class method objects" -msgstr "" +msgstr "Objetos de método de clase" #: ../Doc/reference/datamodel.rst:1118 msgid "" @@ -1610,10 +1934,17 @@ msgid "" "retrieval is described above, under \"User-defined methods\". Class method " "objects are created by the built-in :func:`classmethod` constructor." msgstr "" +"Un objeto de método de clase, igual que un objeto de método estático, es un " +"envoltorio (wrapper) alrededor de otro objeto que altera la forma en la que " +"el objeto es obtenido desde las clases y las instancias de clase. El " +"comportamiento de los objetos de método de clase sobre tal obtención es " +"descrita más arriba, debajo de “Métodos definidos por usuario”. Objetos de " +"clase de método son creados por el constructor incorporado :func:" +"`classmethod`." #: ../Doc/reference/datamodel.rst:1128 msgid "Special method names" -msgstr "" +msgstr "Nombres especiales de método" #: ../Doc/reference/datamodel.rst:1134 msgid "" @@ -1628,6 +1959,17 @@ msgid "" "appropriate method is defined (typically :exc:`AttributeError` or :exc:" "`TypeError`)." msgstr "" +"Una clase puede implementar ciertas operaciones que son invocadas por " +"sintaxis especiales (como operaciones aritméticas o de sub-índice y " +"segmentación) definiendo métodos con nombres especiales. Este es el enfoque " +"de Python hacia :dfn:`operator overloading`, permitiendo a las clases " +"definir su propio comportamiento con respecto a los operadores del lenguaje. " +"Por ejemplo, si una clase define un método llamado :meth:`__getitem__`, y " +"``x`` es una instancia de esta clase, entonces ``x[i]`` es aproximadamente " +"equivalente a ``type(x).__getitem__(x, i)``. A excepción de donde se " +"menciona, los intentos por ejecutar una operación lanzan una excepción " +"cuando no es definido un método apropiado (normalmente :exc:`AttributeError` " +"o :exc:`TypeError`)." #: ../Doc/reference/datamodel.rst:1144 msgid "" @@ -1637,6 +1979,11 @@ msgid "" "instances will raise a :exc:`TypeError` (without falling back to :meth:" "`__getitem__`). [#]_" msgstr "" +"Estableciendo un método especial a ``None`` indica que la operación " +"correspondiente no se encuentra disponible. Por ejemplo, si una clase " +"establece :meth:`__iter__` a ``None``, la clase no es iterable, así que " +"llamando :func:`iter` en sus instancias lanzará un :exc:`TypeError` (sin " +"volver a :meth:`__getitem__`). [#]_" #: ../Doc/reference/datamodel.rst:1150 msgid "" @@ -1647,10 +1994,17 @@ msgid "" "sense. (One example of this is the :class:`~xml.dom.NodeList` interface in " "the W3C's Document Object Model.)" msgstr "" +"Cuando se implementa una clase que emula cualquier tipo incorporado, es " +"importante que la emulación solo sea implementado al grado que hace sentido " +"para el objeto que está siendo modelado. Por ejemplo, algunas secuencias " +"pueden trabajar bien con la obtención de elementos individuales, pero " +"extraer un segmento puede no tener mucho sentido. (Un ejemplo de esto es la " +"interfaz :class:`~xml.dom.NodeList`, en el Modelo de Objetos del Documento " +"del W3C.)" #: ../Doc/reference/datamodel.rst:1161 msgid "Basic customization" -msgstr "" +msgstr "Personalización básica" #: ../Doc/reference/datamodel.rst:1167 msgid "" @@ -1661,6 +2015,13 @@ msgid "" "(the call to the class). The return value of :meth:`__new__` should be the " "new object instance (usually an instance of *cls*)." msgstr "" +"Es llamado para crear una nueva instancia de clase *cls*. :meth:`__new__` es " +"un método estático (como un caso especial, así que no se necesita declarar " +"como tal) que toma la clase de donde fue solicitada una instancia como su " +"primer argumento. Los argumentos restantes son aquellos que se pasan a la " +"expresión del constructor de objetos (para llamar a la clase). El valor " +"retornado de :meth:`__new__` deberá ser la nueva instancia de objeto " +"(normalmente una instancia de *cls*)." #: ../Doc/reference/datamodel.rst:1174 msgid "" @@ -1669,6 +2030,10 @@ msgid "" "with appropriate arguments and then modifying the newly-created instance as " "necessary before returning it." msgstr "" +"Implementaciones típicas crean una nueva instancia de la clase invocando el " +"método :meth:`__new__` de la súper clase utilizando ``super().__new__(cls[, " +"…])`` con argumentos apropiados y después modificando la recién creada " +"instancia como necesaria antes de retornarla." #: ../Doc/reference/datamodel.rst:1179 msgid "" @@ -1678,12 +2043,19 @@ msgid "" "new instance and the remaining arguments are the same as were passed to the " "object constructor." msgstr "" +"Si :meth:`__new__` es invocado durante la construcción del objeto y éste " +"retorna una instancia o subclase de *cls*, entonces el nuevo método :meth:" +"`__init__` de la instancia será invocado como ``__init__(self[, …])``, donde " +"*self* es la nueva instancia y los argumentos restantes son iguales como " +"fueron pasados hacia el constructor de objetos." #: ../Doc/reference/datamodel.rst:1184 msgid "" "If :meth:`__new__` does not return an instance of *cls*, then the new " "instance's :meth:`__init__` method will not be invoked." msgstr "" +"Si :meth:`__new__` no devuelve una instancia de *cls*, entonces el nuevo " +"método :meth:`__init__` de la instancia no será invocado." #: ../Doc/reference/datamodel.rst:1187 msgid "" @@ -1692,6 +2064,10 @@ msgid "" "commonly overridden in custom metaclasses in order to customize class " "creation." msgstr "" +":meth:`__new__` es destinado principalmente para permitir a subclases de " +"tipos inmutables (como int, str, o tuple) personalizar la creación de " +"instancias. También es comúnmente anulado en metaclases personalizadas con " +"el fin de personalizar la creación de clase." #: ../Doc/reference/datamodel.rst:1196 msgid "" @@ -1702,14 +2078,27 @@ msgid "" "ensure proper initialization of the base class part of the instance; for " "example: ``super().__init__([args...])``." msgstr "" +"Llamado después de que la instancia ha sido creada (por :meth:`__new__`), " +"pero antes es retornada a quien produce la llamada. Los argumentos son " +"aquellos pasados a la expresión del constructor de la clase. Si una clase " +"base tiene un método :meth:`__init__`, el método :meth:`__init__` de clase " +"derivada, de existir, debe llamarlo explícitamente para asegurar la " +"inicialización apropiada de la clase base que es parte de la instancia; por " +"ejemplo: ``super().__init__([args…])``." #: ../Doc/reference/datamodel.rst:1203 +#, fuzzy msgid "" "Because :meth:`__new__` and :meth:`__init__` work together in constructing " "objects (:meth:`__new__` to create it, and :meth:`__init__` to customize " "it), no non-``None`` value may be returned by :meth:`__init__`; doing so " "will cause a :exc:`TypeError` to be raised at runtime." msgstr "" +"Debido a que :meth:`__new__` y :meth:`__init__` trabajan juntos construyendo " +"objetos (:meth:`__new__` para crearlo y :meth:`__init__` para " +"personalizarlo), ningún valor distinto a ``None`` puede ser retornado por :" +"meth:`__init__`; hacer esto puede causar que se lance una excepción :exc:" +"`TypeError` en tiempo de ejecución." #: ../Doc/reference/datamodel.rst:1216 msgid "" @@ -1719,6 +2108,11 @@ msgid "" "explicitly call it to ensure proper deletion of the base class part of the " "instance." msgstr "" +"Llamado cuando la instancia es a punto de ser destruida. Esto también es " +"llamado finalizador o (indebidamente) destructor. Si una clase base tiene un " +"método :meth:`__del__` el método :meth:`__del__` de la clase derivada, de " +"existir, debe llamarlo explícitamente para asegurar la eliminación adecuada " +"de la parte de la clase base de la instancia." #: ../Doc/reference/datamodel.rst:1222 msgid "" @@ -1729,12 +2123,20 @@ msgid "" "about to be destroyed; the current :term:`CPython` implementation only calls " "it once." msgstr "" +"Es posible (¡aunque no recomendable!) para el método :meth:`__del__` " +"posponer la destrucción de la instancia al crear una nueva referencia hacia " +"ésta. Esto es llamado *resurrección* de objeto. Es dependiente de la " +"implementación si :meth:`__del__` es llamado una segunda vez cuando un " +"objeto resucitado está por ser destruido; la implementación :term:`CPython` " +"actual únicamente lo llama una vez." #: ../Doc/reference/datamodel.rst:1229 msgid "" "It is not guaranteed that :meth:`__del__` methods are called for objects " "that still exist when the interpreter exits." msgstr "" +"No está garantizado que los métodos :meth:`__del__` sean llamados para " +"objetos que aún existen cuando el intérprete se cierra." #: ../Doc/reference/datamodel.rst:1234 msgid "" @@ -1742,6 +2144,9 @@ msgid "" "the reference count for ``x`` by one, and the latter is only called when " "``x``'s reference count reaches zero." msgstr "" +"``del x`` no llama directamente ``x.__del__()`` --- el primero disminuye el " +"conteo de referencia para ``x`` uno por uno, y el segundo es llamado " +"únicamente cuando el conteo de referencias de ``x`` llega a cero." #: ../Doc/reference/datamodel.rst:1249 msgid "Documentation for the :mod:`gc` module." From bc2166b9b9d663f8d1b4dc0e158eeb128c854301 Mon Sep 17 00:00:00 2001 From: Miguel Angel R Date: Tue, 22 Dec 2020 19:41:10 -0600 Subject: [PATCH 02/17] Avance a 50% --- reference/datamodel.po | 113 +++++++++++++++++++++++++++++++++++++++-- 1 file changed, 110 insertions(+), 3 deletions(-) diff --git a/reference/datamodel.po b/reference/datamodel.po index 68b190c3f0..e232446ce3 100644 --- a/reference/datamodel.po +++ b/reference/datamodel.po @@ -11,7 +11,7 @@ msgstr "" "Project-Id-Version: Python 3.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2020-05-05 12:54+0200\n" -"PO-Revision-Date: 2020-12-21 19:07-0600\n" +"PO-Revision-Date: 2020-12-22 19:40-0600\n" "Language-Team: python-doc-es\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" @@ -2150,7 +2150,7 @@ msgstr "" #: ../Doc/reference/datamodel.rst:1249 msgid "Documentation for the :mod:`gc` module." -msgstr "" +msgstr "Documentación para el módulo :mod:`gc`." #: ../Doc/reference/datamodel.rst:1253 msgid "" @@ -2158,6 +2158,10 @@ msgid "" "invoked, exceptions that occur during their execution are ignored, and a " "warning is printed to ``sys.stderr`` instead. In particular:" msgstr "" +"Debido a las circunstancias inciertas bajo las que los métodos :meth:" +"`__del__` son invocados, las excepciones que ocurren durante su ejecución " +"son ignoradas, y una advertencia es mostrada hacia ``sys.stderr``. En " +"particular:" #: ../Doc/reference/datamodel.rst:1257 msgid "" @@ -2167,6 +2171,12 @@ msgid "" "may already be taken by the code that gets interrupted to execute :meth:" "`__del__`." msgstr "" +":meth:`__del__` puede ser invocado cuando código arbitrario es ejecutado, " +"incluyendo el de cualquier hilo arbitrario. Si :meth:`__del__` necesita " +"realizar un cierre de exclusión mutua (*lock*) o invocar cualquier otro " +"recurso que lo esté bloqueando, podría provocar un bloqueo muto (*deadlock*) " +"ya que el recurso podría estar siendo utilizado por el código que se " +"interrumpe al ejecutar :meth:`__del__`." #: ../Doc/reference/datamodel.rst:1263 msgid "" @@ -2178,6 +2188,14 @@ msgid "" "such globals exist, this may help in assuring that imported modules are " "still available at the time when the :meth:`__del__` method is called." msgstr "" +":meth:`__del__` puede ser ejecutado durante el cierre del intérprete. Como " +"consecuencia, las variables globales que necesita para acceder (incluyendo " +"otros módulos) podrían haber sido borradas o establecidas a ``None``. Python " +"garantiza que los globales cuyo nombre comienza con un guión bajo simple " +"sean borrados de su módulo antes que los globales sean borrados; si no " +"existen otras referencias a dichas globales, esto puede ayudar asegurando " +"que los módulos importados aún se encuentren disponibles al momento de " +"llamar al método :meth:`__del__`." #: ../Doc/reference/datamodel.rst:1278 msgid "" @@ -2190,12 +2208,23 @@ msgid "" "`__repr__` but not :meth:`__str__`, then :meth:`__repr__` is also used when " "an \"informal\" string representation of instances of that class is required." msgstr "" +"Llamado por la función incorporada :func:`repr` para calcular la cadena " +"“oficial” de representación de un objeto. Si es posible, esto debería verse " +"como una expresión de Python válida que puede ser utilizada para recrear un " +"objeto con el mismo valor (bajo el ambiente adecuado). Si no es posible, una " +"cadena con la forma ``<…some useful description…>`` debe ser retornada. El " +"valor de retorno debe ser un objeto de cadena (*string*). Si una clase " +"define :meth:`__repr__` pero no :meth:`__str__`, entonces :meth:`__repr__` " +"también es utilizado cuando una cadena “informal” de representación de " +"instancias de esas clases son requeridas." #: ../Doc/reference/datamodel.rst:1287 msgid "" "This is typically used for debugging, so it is important that the " "representation is information-rich and unambiguous." msgstr "" +"Esto es típicamente utilizado para depurar, así que es importante que la " +"representación sea rica en información e inequívoca." #: ../Doc/reference/datamodel.rst:1298 msgid "" @@ -2204,6 +2233,10 @@ msgid "" "string representation of an object. The return value must be a :ref:`string " "` object." msgstr "" +"Llamado por :func:`str(object) ` y las funciones incorporadas :func:" +"`format` y :func:`print` para calcular la “informal” o bien mostrada cadena " +"de representación de un objeto. El valor de retorno debe ser un objeto :ref:" +"`string `." #: ../Doc/reference/datamodel.rst:1303 msgid "" @@ -2211,18 +2244,25 @@ msgid "" "expectation that :meth:`__str__` return a valid Python expression: a more " "convenient or concise representation can be used." msgstr "" +"Este método difiere de :meth:`object.__repr__` en que no hay expectativas de " +"que :meth:`__str__` retorne una expresión de Python válida: una " +"representación más conveniente o concisa pueda ser utilizada." #: ../Doc/reference/datamodel.rst:1307 msgid "" "The default implementation defined by the built-in type :class:`object` " "calls :meth:`object.__repr__`." msgstr "" +"La implementación por defecto definida por el tipo incorporado :class:" +"`object` llama a :meth:`object.__repr__`." #: ../Doc/reference/datamodel.rst:1317 msgid "" "Called by :ref:`bytes ` to compute a byte-string representation " "of an object. This should return a :class:`bytes` object." msgstr "" +"Llamado por :ref:`bytes ` para calcular la representación de la " +"cadena de byte de un objeto. Este deberá retornar un objeto :class:`bytes`." #: ../Doc/reference/datamodel.rst:1328 msgid "" @@ -2235,27 +2275,41 @@ msgid "" "either delegate formatting to one of the built-in types, or use a similar " "formatting option syntax." msgstr "" +"Llamado por la función incorporada :func:`format`, y por extensión, la " +"evaluación de :ref:`formatted string literals ` y el método :meth:" +"`str.format`, para producir la representación “formateada” de un objeto. El " +"argumento *format_spec* es una cadena que contiene una descripción de las " +"opciones de formato deseadas. La interpretación del argumento *format_spec* " +"depende del tipo que implementa :meth:`__format__`, sin embargo, ya sea que " +"la mayoría de las clases deleguen el formato a uno de los tipos " +"incorporados, o utilicen una sintaxis de opción de formato similar." #: ../Doc/reference/datamodel.rst:1338 msgid "" "See :ref:`formatspec` for a description of the standard formatting syntax." msgstr "" +"Ver :ref:`formatspec` para una descripción de la sintaxis de formato " +"estándar." #: ../Doc/reference/datamodel.rst:1340 msgid "The return value must be a string object." -msgstr "" +msgstr "El valor de retorno debe ser un objeto de cadena." #: ../Doc/reference/datamodel.rst:1342 msgid "" "The __format__ method of ``object`` itself raises a :exc:`TypeError` if " "passed any non-empty string." msgstr "" +"El método __format__ del mismo ``object`` lanza un :exc:`TypeError` si se la " +"pasa una cadena no vacía." #: ../Doc/reference/datamodel.rst:1346 msgid "" "``object.__format__(x, '')`` is now equivalent to ``str(x)`` rather than " "``format(str(self), '')``." msgstr "" +"``object.__format__(x, ‘’)`` es ahora equivalente a ``str(x)`` en lugar de " +"``format(str(self), ‘’)``." #: ../Doc/reference/datamodel.rst:1362 msgid "" @@ -2265,6 +2319,11 @@ msgid "" "``x!=y`` calls ``x.__ne__(y)``, ``x>y`` calls ``x.__gt__(y)``, and ``x>=y`` " "calls ``x.__ge__(y)``." msgstr "" +"Estos son los llamados métodos de comparación *rich*. La correspondencia " +"entre símbolos de operador y los nombres de método es de la siguiente " +"manera: ``xy`` " +"llama ``x.__gt__(y)``, y ``x>=y`` llama ``x.__ge__(y)``." #: ../Doc/reference/datamodel.rst:1368 msgid "" @@ -2276,6 +2335,14 @@ msgid "" "statement), Python will call :func:`bool` on the value to determine if the " "result is true or false." msgstr "" +"Un método de comparación *rich* puede retornar el único ``NotImplemented`` " +"si no implementa la operación para un par de argumentos dados. Por " +"convención, ``False`` y ``True`` son retornados para una comparación " +"exitosa. Sin embargo, estos métodos pueden retornar cualquier valor, así que " +"si el operador de comparación es utilizado en un contexto Booleano (p. ej. " +"en la condición de una sentencia ``if``), Python llamará :func:`bool` en " +"dicho valor para determinar si el resultado es verdadero (*true*) o falso " +"(*false*)." #: ../Doc/reference/datamodel.rst:1375 msgid "" @@ -2286,6 +2353,12 @@ msgid "" "ordering operations from a single root operation, see :func:`functools." "total_ordering`." msgstr "" +"Por defecto, :meth:`__ne__` delega a :meth:`__eq__` e invierte el resultado " +"a menos que éste sea ``NotImplemented``. No existen otras relaciones " +"implícitas entre los operadores de comparación, por ejemplo, la verdad de " +"``(x Date: Tue, 22 Dec 2020 19:41:10 -0600 Subject: [PATCH 03/17] Avance a 50% --- reference/datamodel.po | 114 +++++++++++++++++++++++++++++++++++++++-- 1 file changed, 111 insertions(+), 3 deletions(-) diff --git a/reference/datamodel.po b/reference/datamodel.po index 68b190c3f0..e535c89b3c 100644 --- a/reference/datamodel.po +++ b/reference/datamodel.po @@ -11,7 +11,7 @@ msgstr "" "Project-Id-Version: Python 3.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2020-05-05 12:54+0200\n" -"PO-Revision-Date: 2020-12-21 19:07-0600\n" +"PO-Revision-Date: 2020-12-22 19:53-0600\n" "Language-Team: python-doc-es\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" @@ -2150,7 +2150,7 @@ msgstr "" #: ../Doc/reference/datamodel.rst:1249 msgid "Documentation for the :mod:`gc` module." -msgstr "" +msgstr "Documentación para el módulo :mod:`gc`." #: ../Doc/reference/datamodel.rst:1253 msgid "" @@ -2158,6 +2158,10 @@ msgid "" "invoked, exceptions that occur during their execution are ignored, and a " "warning is printed to ``sys.stderr`` instead. In particular:" msgstr "" +"Debido a las circunstancias inciertas bajo las que los métodos :meth:" +"`__del__` son invocados, las excepciones que ocurren durante su ejecución " +"son ignoradas, y una advertencia es mostrada hacia ``sys.stderr``. En " +"particular:" #: ../Doc/reference/datamodel.rst:1257 msgid "" @@ -2167,6 +2171,12 @@ msgid "" "may already be taken by the code that gets interrupted to execute :meth:" "`__del__`." msgstr "" +":meth:`__del__` puede ser invocado cuando código arbitrario es ejecutado, " +"incluyendo el de cualquier hilo arbitrario. Si :meth:`__del__` necesita " +"realizar un cierre de exclusión mutua (*lock*) o invocar cualquier otro " +"recurso que lo esté bloqueando, podría provocar un bloqueo muto (*deadlock*) " +"ya que el recurso podría estar siendo utilizado por el código que se " +"interrumpe al ejecutar :meth:`__del__`." #: ../Doc/reference/datamodel.rst:1263 msgid "" @@ -2178,6 +2188,14 @@ msgid "" "such globals exist, this may help in assuring that imported modules are " "still available at the time when the :meth:`__del__` method is called." msgstr "" +":meth:`__del__` puede ser ejecutado durante el cierre del intérprete. Como " +"consecuencia, las variables globales que necesita para acceder (incluyendo " +"otros módulos) podrían haber sido borradas o establecidas a ``None``. Python " +"garantiza que los globales cuyo nombre comienza con un guión bajo simple " +"sean borrados de su módulo antes que los globales sean borrados; si no " +"existen otras referencias a dichas globales, esto puede ayudar asegurando " +"que los módulos importados aún se encuentren disponibles al momento de " +"llamar al método :meth:`__del__`." #: ../Doc/reference/datamodel.rst:1278 msgid "" @@ -2190,12 +2208,23 @@ msgid "" "`__repr__` but not :meth:`__str__`, then :meth:`__repr__` is also used when " "an \"informal\" string representation of instances of that class is required." msgstr "" +"Llamado por la función incorporada :func:`repr` para calcular la cadena " +"“oficial” de representación de un objeto. Si es posible, esto debería verse " +"como una expresión de Python válida que puede ser utilizada para recrear un " +"objeto con el mismo valor (bajo el ambiente adecuado). Si no es posible, una " +"cadena con la forma ``<…some useful description…>`` debe ser retornada. El " +"valor de retorno debe ser un objeto de cadena (*string*). Si una clase " +"define :meth:`__repr__` pero no :meth:`__str__`, entonces :meth:`__repr__` " +"también es utilizado cuando una cadena “informal” de representación de " +"instancias de esas clases son requeridas." #: ../Doc/reference/datamodel.rst:1287 msgid "" "This is typically used for debugging, so it is important that the " "representation is information-rich and unambiguous." msgstr "" +"Esto es típicamente utilizado para depurar, así que es importante que la " +"representación sea rica en información e inequívoca." #: ../Doc/reference/datamodel.rst:1298 msgid "" @@ -2204,6 +2233,10 @@ msgid "" "string representation of an object. The return value must be a :ref:`string " "` object." msgstr "" +"Llamado por :func:`str(object) ` y las funciones incorporadas :func:" +"`format` y :func:`print` para calcular la “informal” o bien mostrada cadena " +"de representación de un objeto. El valor de retorno debe ser un objeto :ref:" +"`string `." #: ../Doc/reference/datamodel.rst:1303 msgid "" @@ -2211,18 +2244,25 @@ msgid "" "expectation that :meth:`__str__` return a valid Python expression: a more " "convenient or concise representation can be used." msgstr "" +"Este método difiere de :meth:`object.__repr__` en que no hay expectativas de " +"que :meth:`__str__` retorne una expresión de Python válida: una " +"representación más conveniente o concisa pueda ser utilizada." #: ../Doc/reference/datamodel.rst:1307 msgid "" "The default implementation defined by the built-in type :class:`object` " "calls :meth:`object.__repr__`." msgstr "" +"La implementación por defecto definida por el tipo incorporado :class:" +"`object` llama a :meth:`object.__repr__`." #: ../Doc/reference/datamodel.rst:1317 msgid "" "Called by :ref:`bytes ` to compute a byte-string representation " "of an object. This should return a :class:`bytes` object." msgstr "" +"Llamado por :ref:`bytes ` para calcular la representación de la " +"cadena de byte de un objeto. Este deberá retornar un objeto :class:`bytes`." #: ../Doc/reference/datamodel.rst:1328 msgid "" @@ -2235,27 +2275,41 @@ msgid "" "either delegate formatting to one of the built-in types, or use a similar " "formatting option syntax." msgstr "" +"Llamado por la función incorporada :func:`format`, y por extensión, la " +"evaluación de :ref:`formatted string literals ` y el método :meth:" +"`str.format`, para producir la representación “formateada” de un objeto. El " +"argumento *format_spec* es una cadena que contiene una descripción de las " +"opciones de formato deseadas. La interpretación del argumento *format_spec* " +"depende del tipo que implementa :meth:`__format__`, sin embargo, ya sea que " +"la mayoría de las clases deleguen el formato a uno de los tipos " +"incorporados, o utilicen una sintaxis de opción de formato similar." #: ../Doc/reference/datamodel.rst:1338 msgid "" "See :ref:`formatspec` for a description of the standard formatting syntax." msgstr "" +"Ver :ref:`formatspec` para una descripción de la sintaxis de formato " +"estándar." #: ../Doc/reference/datamodel.rst:1340 msgid "The return value must be a string object." -msgstr "" +msgstr "El valor de retorno debe ser un objeto de cadena." #: ../Doc/reference/datamodel.rst:1342 msgid "" "The __format__ method of ``object`` itself raises a :exc:`TypeError` if " "passed any non-empty string." msgstr "" +"El método __format__ del mismo ``object`` lanza un :exc:`TypeError` si se la " +"pasa una cadena no vacía." #: ../Doc/reference/datamodel.rst:1346 msgid "" "``object.__format__(x, '')`` is now equivalent to ``str(x)`` rather than " "``format(str(self), '')``." msgstr "" +"``object.__format__(x, ‘’)`` es ahora equivalente a ``str(x)`` en lugar de " +"``format(str(self), ‘’)``." #: ../Doc/reference/datamodel.rst:1362 msgid "" @@ -2265,6 +2319,11 @@ msgid "" "``x!=y`` calls ``x.__ne__(y)``, ``x>y`` calls ``x.__gt__(y)``, and ``x>=y`` " "calls ``x.__ge__(y)``." msgstr "" +"Estos son los llamados métodos de comparación *rich*. La correspondencia " +"entre símbolos de operador y los nombres de método es de la siguiente " +"manera: ``xy`` " +"llama ``x.__gt__(y)``, y ``x>=y`` llama ``x.__ge__(y)``." #: ../Doc/reference/datamodel.rst:1368 msgid "" @@ -2276,6 +2335,14 @@ msgid "" "statement), Python will call :func:`bool` on the value to determine if the " "result is true or false." msgstr "" +"Un método de comparación *rich* puede retornar el único ``NotImplemented`` " +"si no implementa la operación para un par de argumentos dados. Por " +"convención, ``False`` y ``True`` son retornados para una comparación " +"exitosa. Sin embargo, estos métodos pueden retornar cualquier valor, así que " +"si el operador de comparación es utilizado en un contexto Booleano (p. ej. " +"en la condición de una sentencia ``if``), Python llamará :func:`bool` en " +"dicho valor para determinar si el resultado es verdadero (*true*) o falso " +"(*false*)." #: ../Doc/reference/datamodel.rst:1375 msgid "" @@ -2286,6 +2353,12 @@ msgid "" "ordering operations from a single root operation, see :func:`functools." "total_ordering`." msgstr "" +"Por defecto, :meth:`__ne__` delega a :meth:`__eq__` e invierte el resultado " +"a menos que éste sea ``NotImplemented``. No existen otras relaciones " +"implícitas entre los operadores de comparación, por ejemplo, la verdad de " +"``(x Date: Wed, 23 Dec 2020 13:34:24 -0600 Subject: [PATCH 04/17] Avance a 55% --- reference/datamodel.po | 100 ++++++++++++++++++++++++++++++++++++++--- 1 file changed, 95 insertions(+), 5 deletions(-) diff --git a/reference/datamodel.po b/reference/datamodel.po index e535c89b3c..711e91ed9e 100644 --- a/reference/datamodel.po +++ b/reference/datamodel.po @@ -11,7 +11,7 @@ msgstr "" "Project-Id-Version: Python 3.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2020-05-05 12:54+0200\n" -"PO-Revision-Date: 2020-12-22 19:53-0600\n" +"PO-Revision-Date: 2020-12-23 13:32-0600\n" "Language-Team: python-doc-es\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" @@ -2455,6 +2455,11 @@ msgid "" "``x.__hash__()`` returns an appropriate value such that ``x == y`` implies " "both that ``x is y`` and ``hash(x) == hash(y)``." msgstr "" +"Clases definidas por usuario tienen los métodos :meth:`__eq__` y :meth:" +"`__hash__` por defecto; con ellos, todos los objetos se comparan de manera " +"desigual (excepto con ellos mismos) y ``x.__hash__()`` devuelve un valor " +"apropiado tal que ``x == y`` implique que ``x es y`` y ``hash(x) == " +"hash(y)``." #: ../Doc/reference/datamodel.rst:1438 msgid "" @@ -2465,6 +2470,12 @@ msgid "" "hash value, and will also be correctly identified as unhashable when " "checking ``isinstance(obj, collections.abc.Hashable)``." msgstr "" +"Una clase que anula :meth:`__eq__` y no define :meth:`__hash__` tendrá " +"implícito su :meth:`__hash__` establecido a ``None``. Cuando el método :meth:" +"`__hash__` de una clase es ``None``, instancias de la clase lanzarán un :exc:" +"`TypeError` cuando el programa intente obtener el valor del hash, y también " +"será correctamente identificado como de hash no calculable cuando se " +"verifique ``isinstance(obj, collections.abc.Hashable)``." #: ../Doc/reference/datamodel.rst:1445 msgid "" @@ -2472,6 +2483,9 @@ msgid "" "of :meth:`__hash__` from a parent class, the interpreter must be told this " "explicitly by setting ``__hash__ = .__hash__``." msgstr "" +"Si una clase que anula :meth:`__eq__` necesita conservar la implementación " +"de :meth:`__hash__` de una clase padre, al intérprete se le debe informar " +"explícitamente estableciendo ``__hash__ = .__hash__``." #: ../Doc/reference/datamodel.rst:1449 msgid "" @@ -2481,6 +2495,11 @@ msgid "" "`TypeError` would be incorrectly identified as hashable by an " "``isinstance(obj, collections.abc.Hashable)`` call." msgstr "" +"Si una clase que no anula :meth:`__eq__` desea eliminar el soporte de " +"*hash*, debe incluir ``__hash__ = None`` en la definición de clase. Una " +"clase que define su propio :meth:`__hash__` y que explícitamente lanza un :" +"exc:`TypeError` será identificado de manera incorrecta como de hash " +"calculable por una llamada ``isinstance(obj, collections.abc.Hashable)``." #: ../Doc/reference/datamodel.rst:1458 msgid "" @@ -2489,6 +2508,10 @@ msgid "" "an individual Python process, they are not predictable between repeated " "invocations of Python." msgstr "" +"Por defecto los valores de objetos str y bytes de :meth:`__hash__` son " +"“salados” con un valor aleatorio impredecible. Aunque se mantienen " +"constantes dentro de un proceso Python particular, no son predecibles entre " +"invocaciones repetidas de Python." #: ../Doc/reference/datamodel.rst:1463 msgid "" @@ -2497,6 +2520,10 @@ msgid "" "insertion, O(n^2) complexity. See http://www.ocert.org/advisories/" "ocert-2011-003.html for details." msgstr "" +"Esto tiene la intención de proveer protección contra una negación de " +"servicio causada por entradas cautelosamente elegidas y que explotan el peor " +"caso de rendimiento en la inserción de un diccionario, complejidad O(n^2). " +"Ver http://www.ocert.org/advisories/ocert-2011-003.html para más detalles." #: ../Doc/reference/datamodel.rst:1468 msgid "" @@ -2504,14 +2531,17 @@ msgid "" "made guarantees about this ordering (and it typically varies between 32-bit " "and 64-bit builds)." msgstr "" +"Cambiar los valores hash afectan el orden de la iteración de los sets. " +"Python nunca ha dado garantías en relación a este orden (y típicamente varía " +"entre estructuras de 32-bits y 64-bits)." #: ../Doc/reference/datamodel.rst:1472 msgid "See also :envvar:`PYTHONHASHSEED`." -msgstr "" +msgstr "Ver también :envvar:`PYTHONHASHSEED`." #: ../Doc/reference/datamodel.rst:1474 msgid "Hash randomization is enabled by default." -msgstr "" +msgstr "La aleatorización de hash es habilitada por defecto." #: ../Doc/reference/datamodel.rst:1482 msgid "" @@ -2521,10 +2551,16 @@ msgid "" "considered true if its result is nonzero. If a class defines neither :meth:" "`__len__` nor :meth:`__bool__`, all its instances are considered true." msgstr "" +"Es llamado para implementar pruebas de valores de verdad y la operación " +"incorporada ``bool()``; debe retornar ``False`` o ``True``. Cuando este " +"método no es definido, :meth:`__len__` es llamado, si es definido, y el " +"objeto es considerado verdadero (*true*) si el resultado es diferente de " +"zero. Si la clase no define :meth:`__len__` ni :meth:`__bool__`, todas sus " +"instancias son consideradas verdaderas (*true*)." #: ../Doc/reference/datamodel.rst:1493 msgid "Customizing attribute access" -msgstr "" +msgstr "Personalizando acceso a atributos" #: ../Doc/reference/datamodel.rst:1495 msgid "" @@ -2532,6 +2568,9 @@ msgid "" "access (use of, assignment to, or deletion of ``x.name``) for class " "instances." msgstr "" +"Los siguientes métodos pueden ser definidos para personalizar el significado " +"de acceso a atributos (uso de, asignación a, o borrado de ``x.name``) para " +"instancias de clase." #: ../Doc/reference/datamodel.rst:1503 msgid "" @@ -2542,6 +2581,13 @@ msgid "" "`AttributeError`). This method should either return the (computed) " "attribute value or raise an :exc:`AttributeError` exception." msgstr "" +"Es llamado cuando el acceso a atributos por defecto falla con un :exc:" +"`AttributeError` (ya sea que :meth:`__getattribute__` lanza una excepción :" +"exc:`AttributeError` porque *name* no es un atributo de instancia o un " +"atributo en el árbol de clase para ``self``; o el :meth:`__get__` de la " +"propiedad de *name* lanza una excepción :exc:`AttributeError`). Este método " +"debe retornar el valor de atributo (calculado) o lanzar una excepción :exc:" +"`AttributeError`." #: ../Doc/reference/datamodel.rst:1510 msgid "" @@ -2555,6 +2601,16 @@ msgid "" "object). See the :meth:`__getattribute__` method below for a way to " "actually get total control over attribute access." msgstr "" +"Tome en cuenta que si el atributo es encontrado a través del mecanismo " +"normal, :meth:`__getattr__` no es llamado. (Esto es una asimetría " +"intencional entre :meth:`__getattr__` y :meth:`__setattr__`.) Esto es " +"realizado tanto por motivos de eficiencia y porque de otra manera :meth:" +"`__getattr__` no tendría manera de acceder a otros atributos de la " +"instancia. Tome en cuenta que al menos para variables de instancia, se puede " +"fingir control total al no insertar ningún valor en el diccionario de " +"atributo de instancia (sino insertándolos en otro objeto). Ver el método :" +"meth:`__getattribute__` a continuación para una forma de tener control total " +"sobre el acceso de atributo." #: ../Doc/reference/datamodel.rst:1523 msgid "" @@ -2567,6 +2623,15 @@ msgid "" "base class method with the same name to access any attributes it needs, for " "example, ``object.__getattribute__(self, name)``." msgstr "" +"Es llamado incondicionalmente para implementar acceso de atributo por " +"instancias de clase. Si la clase también define :meth:`__getattr__`, éste no " +"será llamado a menos que :meth:`__getattribute__` lo llame de manera " +"explícita o lance una excepción :exc:`AttributeError`. Este método deberá " +"retornar el valor de atributo (calculado) o lanzar una excepción :exc:" +"`AttributeError`. Para evitar la recursividad infinita en este método, su " +"implementación deberá siempre llamar al método de la clase base con el mismo " +"nombre para acceder cualquier atributo que necesite, por ejemplo, ``object." +"__getattribute__(self, name)``." #: ../Doc/reference/datamodel.rst:1534 msgid "" @@ -2574,6 +2639,9 @@ msgid "" "result of implicit invocation via language syntax or built-in functions. " "See :ref:`special-lookup`." msgstr "" +"Este método aún puede ser sobrepasado cuando se buscan métodos especiales " +"como resultado de una invocación implícita a través de sintaxis de lenguaje " +"o funciones implícitas. Ver :ref:`special-lookup`." #: ../Doc/reference/datamodel.rst:1541 msgid "" @@ -2581,6 +2649,10 @@ msgid "" "the normal mechanism (i.e. store the value in the instance dictionary). " "*name* is the attribute name, *value* is the value to be assigned to it." msgstr "" +"Es llamado cuando se intenta la asignación de atributos. Éste es llamado en " +"lugar del mecanismo normal (p. ej. guardar el valor en el diccionario de " +"instancias). *name* es el nombre de atributo, *value* es el valor que se le " +"asigna." #: ../Doc/reference/datamodel.rst:1545 msgid "" @@ -2588,6 +2660,9 @@ msgid "" "call the base class method with the same name, for example, ``object." "__setattr__(self, name, value)``." msgstr "" +"Si :meth:`__setattr__` quiere asignar a un atributo de instancia, debe " +"llamar al método de la clase base con el mismo nombre, por ejemplo, ``object." +"__setattr__(self, name, value)``." #: ../Doc/reference/datamodel.rst:1552 msgid "" @@ -2595,16 +2670,22 @@ msgid "" "This should only be implemented if ``del obj.name`` is meaningful for the " "object." msgstr "" +"Al igual que :meth:`__setattr__` pero para borrado de atributos en lugar de " +"establecerlos. Esto solo de ser implementado si ``del obj.name`` es " +"significativo para el objeto." #: ../Doc/reference/datamodel.rst:1558 msgid "" "Called when :func:`dir` is called on the object. A sequence must be " "returned. :func:`dir` converts the returned sequence to a list and sorts it." msgstr "" +"Es llamado cuando :func:`dir` es llamado en el objeto. Una secuencia debe " +"ser retornada. :func:`dir` convierte la secuencia retornada a una lista y la " +"ordena." #: ../Doc/reference/datamodel.rst:1563 msgid "Customizing module attribute access" -msgstr "" +msgstr "Personalizando acceso a atributos de módulo" #: ../Doc/reference/datamodel.rst:1570 msgid "" @@ -2617,6 +2698,15 @@ msgid "" "``__dict__`` before raising an :exc:`AttributeError`. If found, it is called " "with the attribute name and the result is returned." msgstr "" +"Nombres especiales ``__getattr__`` y ``__dir__`` también pueden ser " +"utilizados para personalizar acceso a atributos de módulo. La función " +"``__getattr__`` a nivel del módulo debe aceptar un argumento que es el " +"nombre del atributo y retornar el valor calculado o lanzar una excepción :" +"exc:`AttributeError`. Si un atributo no es encontrado en el objeto de módulo " +"a través de una búsqueda normal, p. ej. :meth:`object.__getattribute__`, " +"entonces ``__getattr__`` es buscado en el módulo ``__dict__`` antes de " +"lanzar una excepción :exc:`AttributeError`. Si es encontrado, es llamado con " +"el nombre de atributo y el resultado es retornado." #: ../Doc/reference/datamodel.rst:1579 msgid "" From 5f95111cfcacb8997c60da6b1d83092bf59a2c67 Mon Sep 17 00:00:00 2001 From: Miguel Angel R Date: Mon, 11 Jan 2021 20:13:27 -0600 Subject: [PATCH 05/17] Avance a 60% --- reference/datamodel.po | 67 +++++++++++++++++++++++++++++++++++++----- 1 file changed, 59 insertions(+), 8 deletions(-) diff --git a/reference/datamodel.po b/reference/datamodel.po index 711e91ed9e..c1022a505f 100644 --- a/reference/datamodel.po +++ b/reference/datamodel.po @@ -11,7 +11,7 @@ msgstr "" "Project-Id-Version: Python 3.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2020-05-05 12:54+0200\n" -"PO-Revision-Date: 2020-12-23 13:32-0600\n" +"PO-Revision-Date: 2021-01-11 20:12-0600\n" "Language-Team: python-doc-es\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" @@ -2714,6 +2714,9 @@ msgid "" "of strings that represents the names accessible on module. If present, this " "function overrides the standard :func:`dir` search on a module." msgstr "" +"La función ``__dir__`` debe no aceptar argumentos y retornar una secuencia " +"de cadena de caracteres que representan los nombres accesibles en el módulo. " +"De existir, esta función anula la búsqueda estándar :func:´dir´ en un módulo." #: ../Doc/reference/datamodel.rst:1583 msgid "" @@ -2721,6 +2724,10 @@ msgid "" "attributes, properties, etc.), one can set the ``__class__`` attribute of a " "module object to a subclass of :class:`types.ModuleType`. For example::" msgstr "" +"Para una personalización más precisa sobre el comportamiento del módulo " +"(estableciendo atributos, propiedades, etc.), se puede establecer el " +"atributo ``__class__`` de un objeto de módulo a una subclase de :class:" +"`types.ModuleType`. Por ejemplo::" #: ../Doc/reference/datamodel.rst:1601 msgid "" @@ -2729,26 +2736,31 @@ msgid "" "module globals (whether by code within the module, or via a reference to the " "module's globals dictionary) is unaffected." msgstr "" +"Definiendo un módulo ``__getattr__`` y estableciendo un módulo ``__class__`` " +"solo afecta búsquedas que utilizan la sintaxis de acceso a atributo -- " +"acceder directamente a las globales del módulo (ya sea por código dentro del " +"módulo, o a través de una referencia al diccionario de globales del módulo) " +"no se ve afectado." #: ../Doc/reference/datamodel.rst:1606 msgid "``__class__`` module attribute is now writable." -msgstr "" +msgstr "El atributo de módulo ``__class__`` es ahora escribible." #: ../Doc/reference/datamodel.rst:1609 msgid "``__getattr__`` and ``__dir__`` module attributes." -msgstr "" +msgstr "Atributos de módulo ``__getattr__`` y ``__dir__``" #: ../Doc/reference/datamodel.rst:1614 msgid ":pep:`562` - Module __getattr__ and __dir__" -msgstr "" +msgstr ":pep:`562` - Módulos __getattr__ y __dir__" #: ../Doc/reference/datamodel.rst:1615 msgid "Describes the ``__getattr__`` and ``__dir__`` functions on modules." -msgstr "" +msgstr "Describe las funciones ``__getattr__`` y ``__dir__`` en módulos." #: ../Doc/reference/datamodel.rst:1621 msgid "Implementing Descriptors" -msgstr "" +msgstr "Implementando Descriptores" #: ../Doc/reference/datamodel.rst:1623 msgid "" @@ -2759,6 +2771,12 @@ msgid "" "\" refers to the attribute whose name is the key of the property in the " "owner class' :attr:`~object.__dict__`." msgstr "" +"Los siguientes métodos solo aplican cuando una instancia de clase que " +"contiene el método (llamado clase *descriptora*) aparece en una clase " +"*propietaria* (el descriptor debe estar en el diccionario de clase del " +"propietario o en el diccionario de clase de alguno de sus padres). En los " +"ejemplos a continuación, “el atributo” se refiere al atributo cuyo nombre es " +"la llave de la propiedad en la clase propietaria :attr:`~object.__dict__`." #: ../Doc/reference/datamodel.rst:1633 msgid "" @@ -2768,12 +2786,19 @@ msgid "" "the attribute was accessed through, or ``None`` when the attribute is " "accessed through the *owner*." msgstr "" +"Es llamado para obtener el atributo de la clase propietaria (acceso a " +"atributos de clase) o de una instancia de dicha clase (acceso a atributos de " +"instancia). El argumento opcional *owner* es la clase propietaria, mientras " +"que *instance* es la instancia a través de la cual el atributo fue accedido, " +"o ``None`` cuando el atributo es accedido a través de *owner*." #: ../Doc/reference/datamodel.rst:1639 msgid "" "This method should return the computed attribute value or raise an :exc:" "`AttributeError` exception." msgstr "" +"Este método debe retornar el valor de atributo calculado o lanzar una " +"excepción :exc:`AttributeError`." #: ../Doc/reference/datamodel.rst:1642 msgid "" @@ -2784,12 +2809,20 @@ msgid "" "implementation always passes in both arguments whether they are required or " "not." msgstr "" +":PEP:`252` especifica que :meth:`__get__` puede ser llamado con uno o dos " +"argumentos. Los propios descriptores incorporados de Python soportan esta " +"especificación; sin embargo, es probable que algunas herramientas de " +"terceros tengan descriptores que requieran ambos argumentos. La propia " +"implementación de :meth:`__getattribute__` en Python siempre pasa ambos " +"argumentos si son requeridos o no." #: ../Doc/reference/datamodel.rst:1651 msgid "" "Called to set the attribute on an instance *instance* of the owner class to " "a new value, *value*." msgstr "" +"Es llamado para establecer el atributo en una instancia *instance* de la " +"clase propietaria a un nuevo valor *value*." #: ../Doc/reference/datamodel.rst:1654 msgid "" @@ -2797,17 +2830,24 @@ msgid "" "descriptor to a \"data descriptor\". See :ref:`descriptor-invocation` for " "more details." msgstr "" +"Nota, agregar :meth:`__set__` o :meth:`__delete__` cambia el tipo de " +"descriptor a un “descriptor de datos”. Ver :ref:`descriptor-invocation` para " +"más detalles." #: ../Doc/reference/datamodel.rst:1660 msgid "" "Called to delete the attribute on an instance *instance* of the owner class." msgstr "" +"Es llamado para borrar el atributo en una instancia *instance* de la clase " +"propietaria." #: ../Doc/reference/datamodel.rst:1665 msgid "" "Called at the time the owning class *owner* is created. The descriptor has " "been assigned to *name*." msgstr "" +"Es llamado al momento en el que se crea la clase propietaria *owner*. El " +"descriptor es asignado a *name*." #: ../Doc/reference/datamodel.rst:1670 msgid "" @@ -2815,10 +2855,14 @@ msgid "" "constructor, so it will need to be called explicitly with the appropriate " "parameters when a descriptor is added to a class after initial creation::" msgstr "" +":meth:`__set_name__` solo es llamado implícitamente como parte del " +"constructor :class:`type`, así que será necesario llamarlo explícitamente " +"con los parámetros apropiados cuando un descriptor se agrega a la clase " +"después de su creación inicial::" #: ../Doc/reference/datamodel.rst:1681 msgid "See :ref:`class-object-creation` for more details." -msgstr "" +msgstr "Ver :ref:`class-object-creation` para más detalles." #: ../Doc/reference/datamodel.rst:1685 msgid "" @@ -2830,10 +2874,17 @@ msgid "" "argument (for example, CPython sets this attribute for unbound methods that " "are implemented in C)." msgstr "" +"El atributo :attr:`__objclass__` es interpretado por el módulo :mod:" +"`inspect` como la especificación de la clase donde el objeto fue definido " +"(establecer esto adecuadamente puede ayudar en introspección de atributos " +"dinámicos de clases en tiempo de ejecución). Para llamables, puede indicar " +"que una instancia de un tipo (o subclase) dado es esperado o requerido como " +"el primero argumento posicional (por ejemplo, CPython establece este " +"atributo para métodos independientes que son implementados en C)." #: ../Doc/reference/datamodel.rst:1696 msgid "Invoking Descriptors" -msgstr "" +msgstr "Invocando Descriptores" #: ../Doc/reference/datamodel.rst:1698 msgid "" From 3d10fa24a0b492ecb6e645076719d82ce67653fa Mon Sep 17 00:00:00 2001 From: Miguel Angel R Date: Thu, 14 Jan 2021 18:51:04 -0600 Subject: [PATCH 06/17] Avance a 65% --- reference/datamodel.po | 87 ++++++++++++++++++++++++++++++++++++++---- 1 file changed, 79 insertions(+), 8 deletions(-) diff --git a/reference/datamodel.po b/reference/datamodel.po index c1022a505f..05f3a4a72d 100644 --- a/reference/datamodel.po +++ b/reference/datamodel.po @@ -11,7 +11,7 @@ msgstr "" "Project-Id-Version: Python 3.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2020-05-05 12:54+0200\n" -"PO-Revision-Date: 2021-01-11 20:12-0600\n" +"PO-Revision-Date: 2021-01-14 18:46-0600\n" "Language-Team: python-doc-es\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" @@ -2748,7 +2748,7 @@ msgstr "El atributo de módulo ``__class__`` es ahora escribible." #: ../Doc/reference/datamodel.rst:1609 msgid "``__getattr__`` and ``__dir__`` module attributes." -msgstr "Atributos de módulo ``__getattr__`` y ``__dir__``" +msgstr "Atributos de módulo ``__getattr__`` y ``__dir__``." #: ../Doc/reference/datamodel.rst:1614 msgid ":pep:`562` - Module __getattr__ and __dir__" @@ -2893,6 +2893,11 @@ msgid "" "protocol: :meth:`__get__`, :meth:`__set__`, and :meth:`__delete__`. If any " "of those methods are defined for an object, it is said to be a descriptor." msgstr "" +"De manera general, un descriptor es un atributo de objeto con " +"“comportamiento enlazado”, cuyo atributo de acceso ha sido anulado por " +"métodos en el protocolo del descriptor: :meth:`__get__`, :meth:`__set__`, y :" +"meth:`__delete__`. Si cualquiera de esos métodos son definidos por un " +"objeto, se dice que es un descriptor." #: ../Doc/reference/datamodel.rst:1703 msgid "" @@ -2901,6 +2906,11 @@ msgid "" "chain starting with ``a.__dict__['x']``, then ``type(a).__dict__['x']``, and " "continuing through the base classes of ``type(a)`` excluding metaclasses." msgstr "" +"El comportamiento por defecto para atributos de acceso es obtener (*get*), " +"establecer (*set*) o borrar (*delete*) el atributo del diccionario del " +"objeto. Por ejemplo, ``a.x`` tiene una cadena de búsqueda que comienza con " +"``a.__dict__[‘x’]``, luego ``type(a).__dict__[‘x’]``, y continúa por las " +"clases base de ``type(a)`` excluyendo meta clases." #: ../Doc/reference/datamodel.rst:1708 msgid "" @@ -2909,46 +2919,59 @@ msgid "" "descriptor method instead. Where this occurs in the precedence chain " "depends on which descriptor methods were defined and how they were called." msgstr "" +"Sin embargo, si el valor buscado es un objeto definiendo uno de los métodos " +"del descriptor, entonces Python puede anular el comportamiento por defecto e " +"invocar al método del descriptor en su lugar. Dónde ocurre esto en la cadena " +"de precedencia depende de qué métodos de descriptor fueron definidos y cómo " +"son llamados." #: ../Doc/reference/datamodel.rst:1713 msgid "" "The starting point for descriptor invocation is a binding, ``a.x``. How the " "arguments are assembled depends on ``a``:" msgstr "" +"El punto de inicio por invocación de descriptor es un enlace ``a.x``. Cómo " +"los argumentos son ensamblados dependen de ``a``:" #: ../Doc/reference/datamodel.rst:1718 msgid "Direct Call" -msgstr "" +msgstr "Llamado Directo" #: ../Doc/reference/datamodel.rst:1717 msgid "" "The simplest and least common call is when user code directly invokes a " "descriptor method: ``x.__get__(a)``." msgstr "" +"El llamado más simple y menos común es cuando el código de usuario invoca " +"directamente un método descriptor: ``x.__get__(a)``." #: ../Doc/reference/datamodel.rst:1722 msgid "Instance Binding" -msgstr "" +msgstr "Enlace de Instancia" #: ../Doc/reference/datamodel.rst:1721 msgid "" "If binding to an object instance, ``a.x`` is transformed into the call: " "``type(a).__dict__['x'].__get__(a, type(a))``." msgstr "" +"Al enlazar a una instancia de objeto, ``a`` es transformado en un llamado: " +"``type(a).__dict__[‘x’].__get__(a, type(a))``." #: ../Doc/reference/datamodel.rst:1726 msgid "Class Binding" -msgstr "" +msgstr "Enlace de Clase" #: ../Doc/reference/datamodel.rst:1725 msgid "" "If binding to a class, ``A.x`` is transformed into the call: ``A." "__dict__['x'].__get__(None, A)``." msgstr "" +"Al enlazar a una clase, ``A.x`` es transformado en un llamado: ``A." +"__dict__[‘x’].__get__(None, A)``." #: ../Doc/reference/datamodel.rst:1732 msgid "Super Binding" -msgstr "" +msgstr "Súper Enlace" #: ../Doc/reference/datamodel.rst:1729 msgid "" @@ -2957,6 +2980,10 @@ msgid "" "immediately preceding ``B`` and then invokes the descriptor with the call: " "``A.__dict__['m'].__get__(obj, obj.__class__)``." msgstr "" +"Si ``a`` es una instancia de :class:`super`, entonces el enlace ``super(B, " +"obj).m()`` busca ``obj.__class__.__mro__`` la clase base ``A`` que precede " +"inmediatamente ``B`` y luego invoca al descriptor con el llamado: ``A." +"__dict__[‘m’].__get__(obj, obj.__class__)``." #: ../Doc/reference/datamodel.rst:1734 msgid "" @@ -2973,6 +3000,19 @@ msgid "" "defined always override a redefinition in an instance dictionary. In " "contrast, non-data descriptors can be overridden by instances." msgstr "" +"Para enlace de instancias, la precedencia de la invocación de descriptor " +"depende de qué métodos de descriptor son definidos. Un descriptor puede " +"definir cualquier combinación de :meth:`__get__`, :meth:`__set__` y :meth:" +"`__delete__`. Si no define :meth:`__get__`, entonces el acceso al atributo " +"retornará el objeto de descriptor a menos que exista un valor en el " +"diccionario de instancias del objeto. Si el descriptor define :meth:" +"`__set__` y/o :meth:`__delete__`, es un descriptor de datos; si no define " +"alguno, es un descriptor sin datos. Normalmente los descriptores de datos " +"definen ambos :meth:`__get__` y :meth:`__set__`, mientras que los " +"descriptores sin datos solo tienen el método :meth:`__get__`. Descriptores " +"de datos con :meth:`__set__` y :meth:`__get__` definidos siempre anulan una " +"redefinición en el diccionario de instancias. Por el contrario, los " +"descriptores sin datos pueden ser anulados por instancias." #: ../Doc/reference/datamodel.rst:1747 msgid "" @@ -2981,16 +3021,23 @@ msgid "" "and override methods. This allows individual instances to acquire behaviors " "that differ from other instances of the same class." msgstr "" +"Métodos de Python (que incluyen :func:`staticmethod` y :func:`classmethod`) " +"son implementados como descriptores sin datos. Por consiguiente, las " +"instancias pueden redefinir y anular métodos. Esto permite que instancias " +"individuales adquieran comportamientos que pueden diferir de otras " +"instancias de la misma clase." #: ../Doc/reference/datamodel.rst:1752 msgid "" "The :func:`property` function is implemented as a data descriptor. " "Accordingly, instances cannot override the behavior of a property." msgstr "" +"La función :func:`property` es implementada como un descriptor de datos. Por " +"lo tanto, las instancias no pueden anular el comportamiento de una propiedad." #: ../Doc/reference/datamodel.rst:1759 msgid "__slots__" -msgstr "" +msgstr "__slots__" #: ../Doc/reference/datamodel.rst:1761 msgid "" @@ -2998,12 +3045,18 @@ msgid "" "and deny the creation of *__dict__* and *__weakref__* (unless explicitly " "declared in *__slots__* or available in a parent.)" msgstr "" +"*__slots__* nos permiten declarar de manera explícita miembros de datos " +"(como propiedades) y negar la creación de *__dict__* y *__weakref__* (a " +"menos que se declare explícitamente en *__slots__* o se encuentre disponible " +"en un elemento padre.)" #: ../Doc/reference/datamodel.rst:1765 msgid "" "The space saved over using *__dict__* can be significant. Attribute lookup " "speed can be significantly improved as well." msgstr "" +"El espacio ganado al usar *__dict__* puede ser importante. La velocidad de " +"búsqueda de atributos también puede mejorar significativamente." #: ../Doc/reference/datamodel.rst:1770 msgid "" @@ -3012,16 +3065,23 @@ msgid "" "for the declared variables and prevents the automatic creation of *__dict__* " "and *__weakref__* for each instance." msgstr "" +"Esta variable de clase se le puede asignar una cadena de caracteres, un " +"elemento iterable o una secuencia de cadena de caracteres con nombres de " +"variables utilizados por instancias. *__slots__* reserva espacio para las " +"variables declaradas y previene la creación automática de *__dict__* y " +"*__weakref__* para cada instancia." #: ../Doc/reference/datamodel.rst:1777 msgid "Notes on using *__slots__*" -msgstr "" +msgstr "Notas sobre el uso de *__slots__*" #: ../Doc/reference/datamodel.rst:1779 msgid "" "When inheriting from a class without *__slots__*, the *__dict__* and " "*__weakref__* attribute of the instances will always be accessible." msgstr "" +"Cuando se hereda de una clase sin *__slots__*, los atributos *__dict__* y " +"*__weakref__* de las instancias siempre serán accesibles." #: ../Doc/reference/datamodel.rst:1782 msgid "" @@ -3031,6 +3091,12 @@ msgid "" "variables is desired, then add ``'__dict__'`` to the sequence of strings in " "the *__slots__* declaration." msgstr "" +"Sin una variable *__dict__*, no se puede asignar a instancias nuevas " +"variables que no se encuentren listadas en la definición de *__slots__*. " +"Intentos de asignación a una variable no listada lanza una excepción :exc:" +"`AttributeError`. Si se desea hacer una asignación dinámica a variables " +"nuevas, se debe agregar ``’__dict__’`` a la secuencia de cadena de " +"caracteres en la declaración de *__slots__*." #: ../Doc/reference/datamodel.rst:1788 msgid "" @@ -3039,6 +3105,11 @@ msgid "" "reference support is needed, then add ``'__weakref__'`` to the sequence of " "strings in the *__slots__* declaration." msgstr "" +"Sin una variable *__weakref__* por cada instancia, las clases que definen " +"*__slots__* no soportan “referencias débiles” (*weak references*) a sus " +"instancias. Si se desea el soporte de dichas referencias, se debe agregar " +"``’__weakref__’`` a la secuencia de cadena de caracteres en la declaración " +"de *__slots__*." #: ../Doc/reference/datamodel.rst:1793 msgid "" From fc405980de9f51d07e157c188bd2bb61b752b9a9 Mon Sep 17 00:00:00 2001 From: Miguel Angel R Date: Fri, 15 Jan 2021 18:04:37 -0600 Subject: [PATCH 07/17] Avance a 70% --- reference/datamodel.po | 85 ++++++++++++++++++++++++++++++++++++------ 1 file changed, 74 insertions(+), 11 deletions(-) diff --git a/reference/datamodel.po b/reference/datamodel.po index 05f3a4a72d..f02c3de081 100644 --- a/reference/datamodel.po +++ b/reference/datamodel.po @@ -11,7 +11,7 @@ msgstr "" "Project-Id-Version: Python 3.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2020-05-05 12:54+0200\n" -"PO-Revision-Date: 2021-01-14 18:46-0600\n" +"PO-Revision-Date: 2021-01-15 18:04-0600\n" "Language-Team: python-doc-es\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" @@ -2910,7 +2910,7 @@ msgstr "" "establecer (*set*) o borrar (*delete*) el atributo del diccionario del " "objeto. Por ejemplo, ``a.x`` tiene una cadena de búsqueda que comienza con " "``a.__dict__[‘x’]``, luego ``type(a).__dict__[‘x’]``, y continúa por las " -"clases base de ``type(a)`` excluyendo meta clases." +"clases base de ``type(a)`` excluyendo metaclases." #: ../Doc/reference/datamodel.rst:1708 msgid "" @@ -3011,7 +3011,7 @@ msgstr "" "definen ambos :meth:`__get__` y :meth:`__set__`, mientras que los " "descriptores sin datos solo tienen el método :meth:`__get__`. Descriptores " "de datos con :meth:`__set__` y :meth:`__get__` definidos siempre anulan una " -"redefinición en el diccionario de instancias. Por el contrario, los " +"re-definición en el diccionario de instancias. Por el contrario, los " "descriptores sin datos pueden ser anulados por instancias." #: ../Doc/reference/datamodel.rst:1747 @@ -3118,6 +3118,11 @@ msgid "" "be used to set default values for instance variables defined by *__slots__*; " "otherwise, the class attribute would overwrite the descriptor assignment." msgstr "" +"*__slots__* son implementados a nivel de clase al crear descriptores (:ref:" +"`descriptors`) para cada nombre de variable. Como resultado, los atributos " +"de clase no pueden ser utilizados para establecer valores por defecto a " +"variables de instancia definidos por *__slots__*; de lo contrario, el " +"atributo de clase sobrescribirá la asignación del descriptor." #: ../Doc/reference/datamodel.rst:1799 msgid "" @@ -3127,6 +3132,11 @@ msgid "" "they also define *__slots__* (which should only contain names of any " "*additional* slots)." msgstr "" +"La acción de una declaración *__slots__* no está limitada a la clase donde " +"fue definida. *__slots__* declarado en padres, se vuelven disponibles en " +"clases hijas. Sin embargo, subclases hijas tendrán un *__dict__* y " +"*__weakref__* a menos que también se defina *__slots__* (el cual solo debe " +"contener nombres de espacios o *slots* *adicionales*)." #: ../Doc/reference/datamodel.rst:1805 msgid "" @@ -3136,12 +3146,20 @@ msgid "" "meaning of the program undefined. In the future, a check may be added to " "prevent this." msgstr "" +"Si una clase define un espacio (*slot*) también definido en una clase base, " +"la variable de instancia definida por el espacio de la clase base es " +"inaccesible (excepto al obtener su descriptor directamente de la clase " +"base). Esto hace que el significado del programa sea indefinido. En el " +"futuro se podría agregar una verificación para prevenir esto." #: ../Doc/reference/datamodel.rst:1810 msgid "" "Nonempty *__slots__* does not work for classes derived from \"variable-length" "\" built-in types such as :class:`int`, :class:`bytes` and :class:`tuple`." msgstr "" +"*__slots__* no vacíos no funcionan para clases derivadas de tipos " +"incorporados de “longitud variable” como :class:`int`, :class:`bytes` y :" +"class:`tuple`." #: ../Doc/reference/datamodel.rst:1813 msgid "" @@ -3149,11 +3167,17 @@ msgid "" "used; however, in the future, special meaning may be assigned to the values " "corresponding to each key." msgstr "" +"Cualquier iterable sin cadena de caracteres puede ser asignado a " +"*__slots__*. Mapeos también pueden ser utilizados; sin embargo, en el " +"futuro, un significado especial puede ser asignado a los valores " +"correspondientes para cada llave." #: ../Doc/reference/datamodel.rst:1817 msgid "" "*__class__* assignment works only if both classes have the same *__slots__*." msgstr "" +"La asignación *__class__* funciona solo si ambas clases tienen el mismo " +"*__slots__*." #: ../Doc/reference/datamodel.rst:1819 msgid "" @@ -3161,6 +3185,10 @@ msgid "" "only one parent is allowed to have attributes created by slots (the other " "bases must have empty slot layouts) - violations raise :exc:`TypeError`." msgstr "" +"Herencia múltiple con múltiples clases de padres con espacios (*slots*) " +"puede ser utilizada, pero solo un padre es permitido que tenga atributos " +"creados por espacios (las otras bases deben tener diseños de espacios " +"vacíos) - violaciones lanzan una excepción :exc:`TypeError`." #: ../Doc/reference/datamodel.rst:1824 msgid "" @@ -3168,10 +3196,13 @@ msgid "" "of the iterator's values. However, the *__slots__* attribute will be an " "empty iterator." msgstr "" +"Si un iterados es utilizado por *__slots__*, entonces un descriptor es " +"creado para cada uno de los valores del iterador. Sin embargo, el atributo " +"*__slots__* será un iterador vacío." #: ../Doc/reference/datamodel.rst:1831 msgid "Customizing class creation" -msgstr "" +msgstr "Personalización de creación de clases" #: ../Doc/reference/datamodel.rst:1833 msgid "" @@ -3182,6 +3213,12 @@ msgid "" "``__init_subclass__`` solely applies to future subclasses of the class " "defining the method." msgstr "" +"Siempre que una clase hereda de otra clase, *__init_subclass__* es llamado " +"en esa clase. De esta manera, es posible escribir clases que cambian el " +"comportamiento de las subclases. Esto está estrechamente relacionado con los " +"decoradores de clase, pero solo donde los decoradores de clase afectan a la " +"clase específica a la que son aplicados, ``__init_subclass__`` solo aplica a " +"futuras subclases de la clase que define el método." #: ../Doc/reference/datamodel.rst:1842 msgid "" @@ -3189,6 +3226,10 @@ msgid "" "then the new subclass. If defined as a normal instance method, this method " "is implicitly converted to a class method." msgstr "" +"Este método es llamado siempre que la clase que lo contiene sea heredada. " +"*cls* es entonces, la nueva subclase. Si se define como un método de " +"instancia normal, éste es convertido de manera implícita a un método de " +"clase." #: ../Doc/reference/datamodel.rst:1846 msgid "" @@ -3197,12 +3238,19 @@ msgid "" "``__init_subclass__``, one should take out the needed keyword arguments and " "pass the others over to the base class, as in::" msgstr "" +"Los argumentos de palabra clave que fueron dados a una nueva clase, son " +"pasados a la clase ``__init_subclass__`` del padre. Por temas de " +"compatibilidad con otras clases que usan ``__init_subclass__``, uno debería " +"quitar los argumentos de palabra clave y pasar los otros a la clase base, " +"como en::" #: ../Doc/reference/datamodel.rst:1860 msgid "" "The default implementation ``object.__init_subclass__`` does nothing, but " "raises an error if it is called with any arguments." msgstr "" +"La implementación por defecto ``object.__init_subclass__`` no hace nada, " +"pero lanza un error si es llamado con cualquier argumento." #: ../Doc/reference/datamodel.rst:1865 msgid "" @@ -3211,10 +3259,14 @@ msgid "" "actual metaclass (rather than the explicit hint) can be accessed as " "``type(cls)``." msgstr "" +"La sugerencia de metaclase ``metaclass`` es consumido por el resto de la " +"maquinaria de tipos, y nunca se pasa a las implementaciones " +"``__init_subclass__``. La clase meta actual (más que la sugerencia " +"explícita) puede ser accedida como ``type(cls)``." #: ../Doc/reference/datamodel.rst:1876 msgid "Metaclasses" -msgstr "" +msgstr "Metaclases" #: ../Doc/reference/datamodel.rst:1883 msgid "" @@ -3222,6 +3274,9 @@ msgid "" "executed in a new namespace and the class name is bound locally to the " "result of ``type(name, bases, namespace)``." msgstr "" +"Por defecto, las clases son construidas usando :func:`type`. El cuerpo de la " +"clase es ejecutado en un nuevo espacio de nombres y el nombre de la clase es " +"ligado de forma local al resultado de ``type(name, bases, namespace)``." #: ../Doc/reference/datamodel.rst:1887 msgid "" @@ -3230,40 +3285,48 @@ msgid "" "existing class that included such an argument. In the following example, " "both ``MyClass`` and ``MySubclass`` are instances of ``Meta``::" msgstr "" +"El proceso de creación de clase puede ser personalizado pasando el argumento " +"de palabra clave ``metaclass`` en la línea de definición de la clase, o al " +"heredar de una clase existente que incluya dicho argumento. En el siguiente " +"ejemplo, ambos ``MyClass`` y ``MySubclass`` son instancias de ``Meta``::" #: ../Doc/reference/datamodel.rst:1901 msgid "" "Any other keyword arguments that are specified in the class definition are " "passed through to all metaclass operations described below." msgstr "" +"Cualquier otro argumento de palabra clave que sea especificado en la " +"definición de clase es pasado mediante todas las operaciones de metaclase " +"descritas a continuación." #: ../Doc/reference/datamodel.rst:1904 msgid "When a class definition is executed, the following steps occur:" msgstr "" +"Cuando una definición de clase es ejecutada, los siguientes pasos ocurren:" #: ../Doc/reference/datamodel.rst:1906 msgid "MRO entries are resolved;" -msgstr "" +msgstr "Entradas de la Orden de Resolución de Método (MRU) son resueltas;" #: ../Doc/reference/datamodel.rst:1907 msgid "the appropriate metaclass is determined;" -msgstr "" +msgstr "se determina la metaclase adecuada;" #: ../Doc/reference/datamodel.rst:1908 msgid "the class namespace is prepared;" -msgstr "" +msgstr "se prepara el espacio de nombres de clase;" #: ../Doc/reference/datamodel.rst:1909 msgid "the class body is executed;" -msgstr "" +msgstr "se ejecuta el cuerpo de la clase;" #: ../Doc/reference/datamodel.rst:1910 msgid "the class object is created." -msgstr "" +msgstr "se crea el objeto de clase." #: ../Doc/reference/datamodel.rst:1914 msgid "Resolving MRO entries" -msgstr "" +msgstr "Resolviendo entradas de la Orden de Resolución de Métodos (MRU)" #: ../Doc/reference/datamodel.rst:1916 msgid "" From ec454da3dea477e0df3ef0ec7cf10984e8a09161 Mon Sep 17 00:00:00 2001 From: Miguel Angel R Date: Thu, 21 Jan 2021 19:59:46 -0600 Subject: [PATCH 08/17] Avance a 75% --- reference/datamodel.po | 69 +++++++++++++++++++++++++++++++++++++----- 1 file changed, 62 insertions(+), 7 deletions(-) diff --git a/reference/datamodel.po b/reference/datamodel.po index f02c3de081..1a09271642 100644 --- a/reference/datamodel.po +++ b/reference/datamodel.po @@ -11,7 +11,7 @@ msgstr "" "Project-Id-Version: Python 3.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2020-05-05 12:54+0200\n" -"PO-Revision-Date: 2021-01-15 18:04-0600\n" +"PO-Revision-Date: 2021-01-21 19:59-0600\n" "Language-Team: python-doc-es\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" @@ -3336,36 +3336,50 @@ msgid "" "classes that will be used instead of this base. The tuple may be empty, in " "such case the original base is ignored." msgstr "" +"Si una base que aparece en la definición de una clase no es una instancia " +"de :class:`type`, entonces el método ``__mro_entries__`` se busca en ella. " +"Si es encontrado, se llama con la tupla de bases originales. Este método " +"debe retornar una tupla de clases que será utilizado en lugar de esta base. " +"La tupla puede estar vacía, en cuyo caso la base original es ignorada." #: ../Doc/reference/datamodel.rst:1924 ../Doc/reference/datamodel.rst:2114 msgid ":pep:`560` - Core support for typing module and generic types" msgstr "" +":pep:`560` - Soporte central para módulos de clasificación y tipos genéricos" #: ../Doc/reference/datamodel.rst:1928 msgid "Determining the appropriate metaclass" -msgstr "" +msgstr "Determinando la metaclase adecuada" #: ../Doc/reference/datamodel.rst:1932 msgid "" "The appropriate metaclass for a class definition is determined as follows:" msgstr "" +"La metaclase adecuada para la definición de una clase es determinada de la " +"siguiente manera:" #: ../Doc/reference/datamodel.rst:1934 msgid "" "if no bases and no explicit metaclass are given, then :func:`type` is used;" msgstr "" +"si no se dan bases ni metaclases explícitas, entonces se utiliza :func:" +"`type`;" #: ../Doc/reference/datamodel.rst:1935 msgid "" "if an explicit metaclass is given and it is *not* an instance of :func:" "`type`, then it is used directly as the metaclass;" msgstr "" +"si se da una metaclase explícita y *no* es una instancia de :func:`type`, " +"entonces se utiliza directamente como la metaclase;" #: ../Doc/reference/datamodel.rst:1937 msgid "" "if an instance of :func:`type` is given as the explicit metaclass, or bases " "are defined, then the most derived metaclass is used." msgstr "" +"si se da una instancia de :func:`type` como la metaclase explícita, o se " +"definen bases, entonces se utiliza la metaclase más derivada." #: ../Doc/reference/datamodel.rst:1940 msgid "" @@ -3375,10 +3389,13 @@ msgid "" "of these candidate metaclasses. If none of the candidate metaclasses meets " "that criterion, then the class definition will fail with ``TypeError``." msgstr "" +"La metaclase más derivada es elegida de la metaclase especificada " +"explícitamente (si existe) y de la metaclase (p. ej. ``type(cls)``) de todas " +"las clases base especificadas." #: ../Doc/reference/datamodel.rst:1950 msgid "Preparing the class namespace" -msgstr "" +msgstr "Preparando el espacio de nombres de la clase" #: ../Doc/reference/datamodel.rst:1955 msgid "" @@ -3391,24 +3408,34 @@ msgid "" "the final class object is created the namespace is copied into a new " "``dict``." msgstr "" +"Una vez que se ha identificado la metaclase apropiada, entonces se prepara " +"el espacio de nombres de la clase. Si la metaclase tiene un atributo " +"``__prepare__``, es llamado como ``namespace = metaclass.__prepare__(name, " +"bases, **kwds)`` (donde los argumentos de palabra clave adicionales, de " +"existir, provienen de la definición de la clase). El método ``__prepare__`` " +"debe ser implementado como :func:`classmethod`. El espacio de nombres " +"retornado por ``__prepare__`` es pasado a ``__new__``, pero cuando el objeto " +"de clase final es creado, el espacio de nombres es copiado en un ``dict``." #: ../Doc/reference/datamodel.rst:1963 msgid "" "If the metaclass has no ``__prepare__`` attribute, then the class namespace " "is initialised as an empty ordered mapping." msgstr "" +"Si la metaclase no tiene atributo ``__prepare__``, entonces el espacio de " +"nombres de clase es iniciado como un mapeo vacío ordenado." #: ../Doc/reference/datamodel.rst:1968 msgid ":pep:`3115` - Metaclasses in Python 3000" -msgstr "" +msgstr ":pep:`3115` - Metaclases en Python 3000" #: ../Doc/reference/datamodel.rst:1969 msgid "Introduced the ``__prepare__`` namespace hook" -msgstr "" +msgstr "Introduce el enlace de espacio de nombres ``__prepare__``" #: ../Doc/reference/datamodel.rst:1973 msgid "Executing the class body" -msgstr "" +msgstr "Ejecutando el cuerpo de la clase" #: ../Doc/reference/datamodel.rst:1978 msgid "" @@ -3418,6 +3445,11 @@ msgid "" "names from the current and outer scopes when the class definition occurs " "inside a function." msgstr "" +"El cuerpo de la clase es ejecutado como ``exec(body, globals(), namespace)`` " +"(aproximadamente). La diferencia clave con un llamado normal a :func:`exec` " +"es que el alcance léxico permite que el cuerpo de la clase (incluyendo " +"cualquier método) haga referencia a nombres de los alcances actuales y " +"externos cuando la definición de clase sucede dentro de la función." #: ../Doc/reference/datamodel.rst:1984 msgid "" @@ -3427,10 +3459,16 @@ msgid "" "class methods, or through the implicit lexically scoped ``__class__`` " "reference described in the next section." msgstr "" +"Sin embargo, aún cuando la definición de clase sucede dentro de la función, " +"los métodos definidos dentro de la clase aún no pueden ver nombres definidos " +"dentro del alcance de la clase. Variables de clase deben ser accedidas a " +"través del primer parámetro de instancia o métodos de clase, o a través de " +"la referencia al léxico implícito ``__class__`` descrita en la siguiente " +"sección." #: ../Doc/reference/datamodel.rst:1993 msgid "Creating the class object" -msgstr "" +msgstr "Creando el objeto de clase" #: ../Doc/reference/datamodel.rst:2000 msgid "" @@ -3439,6 +3477,10 @@ msgid "" "**kwds)`` (the additional keywords passed here are the same as those passed " "to ``__prepare__``)." msgstr "" +"Una vez que el espacio de nombres de la clase ha sido poblado al ejecutar el " +"cuerpo de la clase, el objeto de clase es creado al llamar ``metaclass(name, " +"bases, namespace, **kwds)`` (las palabras clave adicionales que se pasan " +"aquí, son las mismas que aquellas pasadas en ``__prepare__``)." #: ../Doc/reference/datamodel.rst:2005 msgid "" @@ -3450,6 +3492,14 @@ msgid "" "scoping, while the class or instance that was used to make the current call " "is identified based on the first argument passed to the method." msgstr "" +"Este objeto de clase es el que será referenciado por la forma sin argumentos " +"de :func:`super`. ``__class__`` es una referencia de cierre implícita creada " +"por el compilador si cualquier método en el cuerpo de una clase se refiere " +"tanto a ``__class__`` o ``super``. Esto permite que la forma sin argumentos " +"de :func:`super` identifique correctamente la clase definida en base al " +"alcance léxico, mientras la clase o instancia que fue utilizada para hacer " +"el llamado actual es identificado en base al primer argumento que se pasa al " +"método." #: ../Doc/reference/datamodel.rst:2015 msgid "" @@ -3459,6 +3509,11 @@ msgid "" "initialised correctly. Failing to do so will result in a :exc:`RuntimeError` " "in Python 3.8." msgstr "" +"En CPython 3.6 y posterior, la celda ``__class__`` se pasa a la metaclase " +"como una entrada ``__classcell__`` en el espacio de nombres de la clase. En " +"caso de existir, esto debe ser propagado hacia el llamado ``type.__new__`` " +"para que la clase se inicie correctamente. No hacerlo resultará en un error :" +"exc:`RuntimeError` en Python 3.8." #: ../Doc/reference/datamodel.rst:2021 msgid "" From 161ab3bd28ef11781419da23ed729817aac8f26c Mon Sep 17 00:00:00 2001 From: Miguel Angel R Date: Thu, 21 Jan 2021 20:09:10 -0600 Subject: [PATCH 09/17] =?UTF-8?q?Se=20reemplaza=20'asimetr=C3=ADa=20con=20?= =?UTF-8?q?'desigualdad'.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- reference/datamodel.po | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/reference/datamodel.po b/reference/datamodel.po index 1a09271642..8e6a57e3af 100644 --- a/reference/datamodel.po +++ b/reference/datamodel.po @@ -11,7 +11,7 @@ msgstr "" "Project-Id-Version: Python 3.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2020-05-05 12:54+0200\n" -"PO-Revision-Date: 2021-01-21 19:59-0600\n" +"PO-Revision-Date: 2021-01-21 20:07-0600\n" "Language-Team: python-doc-es\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" @@ -2602,7 +2602,7 @@ msgid "" "actually get total control over attribute access." msgstr "" "Tome en cuenta que si el atributo es encontrado a través del mecanismo " -"normal, :meth:`__getattr__` no es llamado. (Esto es una asimetría " +"normal, :meth:`__getattr__` no es llamado. (Esto es una desigualdad " "intencional entre :meth:`__getattr__` y :meth:`__setattr__`.) Esto es " "realizado tanto por motivos de eficiencia y porque de otra manera :meth:" "`__getattr__` no tendría manera de acceder a otros atributos de la " From 6112ccc959c9d540cfad0d685356a75a4d653283 Mon Sep 17 00:00:00 2001 From: Miguel Angel R Date: Thu, 21 Jan 2021 20:19:04 -0600 Subject: [PATCH 10/17] =?UTF-8?q?Correcci=C3=B3n=20de=20tildes=20invertida?= =?UTF-8?q?s=20en=20:func:?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- reference/datamodel.po | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/reference/datamodel.po b/reference/datamodel.po index 8e6a57e3af..8e63ca833b 100644 --- a/reference/datamodel.po +++ b/reference/datamodel.po @@ -11,7 +11,7 @@ msgstr "" "Project-Id-Version: Python 3.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2020-05-05 12:54+0200\n" -"PO-Revision-Date: 2021-01-21 20:07-0600\n" +"PO-Revision-Date: 2021-01-21 20:17-0600\n" "Language-Team: python-doc-es\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" @@ -2716,7 +2716,7 @@ msgid "" msgstr "" "La función ``__dir__`` debe no aceptar argumentos y retornar una secuencia " "de cadena de caracteres que representan los nombres accesibles en el módulo. " -"De existir, esta función anula la búsqueda estándar :func:´dir´ en un módulo." +"De existir, esta función anula la búsqueda estándar :func:`dir` en un módulo." #: ../Doc/reference/datamodel.rst:1583 msgid "" From c2c54e19d4fa32b024f591c7b706ade854175321 Mon Sep 17 00:00:00 2001 From: Miguel Angel R Date: Fri, 29 Jan 2021 21:18:04 -0600 Subject: [PATCH 11/17] Avance a 80% --- reference/datamodel.po | 76 +++++++++++++++++++++++++++++++++++++----- 1 file changed, 67 insertions(+), 9 deletions(-) diff --git a/reference/datamodel.po b/reference/datamodel.po index 8e63ca833b..32222eebee 100644 --- a/reference/datamodel.po +++ b/reference/datamodel.po @@ -11,7 +11,7 @@ msgstr "" "Project-Id-Version: Python 3.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2020-05-05 12:54+0200\n" -"PO-Revision-Date: 2021-01-21 20:17-0600\n" +"PO-Revision-Date: 2021-01-29 21:17-0600\n" "Language-Team: python-doc-es\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" @@ -3521,24 +3521,34 @@ msgid "" "ultimately calls ``type.__new__``, the following additional customisation " "steps are invoked after creating the class object:" msgstr "" +"Cuando se utiliza la metaclase por defecto :class:`type`, o cualquier otra " +"metaclase que finalmente llama a ``type.__new__``, los siguientes pasos de " +"personalización adicional son invocados después de crear el objeto de clase:" #: ../Doc/reference/datamodel.rst:2025 msgid "" "first, ``type.__new__`` collects all of the descriptors in the class " "namespace that define a :meth:`~object.__set_name__` method;" msgstr "" +"primero, ``type.__new__`` recolecta todos los descriptores en el espacio de " +"nombres de la clase que definen un método :meth:`~object.__set_name__`;" #: ../Doc/reference/datamodel.rst:2027 msgid "" "second, all of these ``__set_name__`` methods are called with the class " "being defined and the assigned name of that particular descriptor;" msgstr "" +"segundo, todos esos métodos ``__set_name__`` son llamados con la clase " +"definida y el nombre de un descriptor particular asignado;" #: ../Doc/reference/datamodel.rst:2029 +#, fuzzy msgid "" "finally, the :meth:`~object.__init_subclass__` hook is called on the " "immediate parent of the new class in its method resolution order." msgstr "" +"finalmente, el enlace :meth:`~object.__init_subclass__` llama al padre " +"inmediato de la nueva clase en su orden de resolución del método." #: ../Doc/reference/datamodel.rst:2032 msgid "" @@ -3546,6 +3556,9 @@ msgid "" "included in the class definition (if any) and the resulting object is bound " "in the local namespace as the defined class." msgstr "" +"Después de que el objeto de clase es creado, se pasa al decorador de clase " +"incluido en su definición (si existe) y el objeto resultante es enlazado en " +"el espacio de nombres local como la clase definida." #: ../Doc/reference/datamodel.rst:2036 msgid "" @@ -3554,18 +3567,23 @@ msgid "" "object is discarded. The new copy is wrapped in a read-only proxy, which " "becomes the :attr:`~object.__dict__` attribute of the class object." msgstr "" +"Cuando una nueva clase es creada por ``type.__new__``, el objeto " +"proporcionado como el parámetro de espacio de nombres es copiado a un " +"trazado ordenado y el objeto original es descartado. La nueva copia es " +"*envuelta* en un proxy de solo lectura, que se convierte en el atributo :" +"attr:`~object.__dict__` del objeto de clase." #: ../Doc/reference/datamodel.rst:2043 msgid ":pep:`3135` - New super" -msgstr "" +msgstr ":pep:`3135` - Nuevo súper" #: ../Doc/reference/datamodel.rst:2044 msgid "Describes the implicit ``__class__`` closure reference" -msgstr "" +msgstr "Describe la referencia de cierre implícita ``__class__``" #: ../Doc/reference/datamodel.rst:2048 msgid "Uses for metaclasses" -msgstr "" +msgstr "Usos para metaclases" #: ../Doc/reference/datamodel.rst:2050 msgid "" @@ -3574,16 +3592,23 @@ msgid "" "automatic property creation, proxies, frameworks, and automatic resource " "locking/synchronization." msgstr "" +"Los usos potenciales para metaclases son ilimitados. Algunas ideas que ya " +"han sido exploradas incluyen enumeración, registros, revisión de interface, " +"delegación automática, creación de propiedades automática, proxy, " +"infraestructuras, y bloqueo/sincronización automática de recursos." #: ../Doc/reference/datamodel.rst:2057 msgid "Customizing instance and subclass checks" -msgstr "" +msgstr "Personalizando revisiones de instancia y subclase" #: ../Doc/reference/datamodel.rst:2059 msgid "" "The following methods are used to override the default behavior of the :func:" "`isinstance` and :func:`issubclass` built-in functions." msgstr "" +"Los siguientes métodos son utilizados para anular el comportamiento por " +"defecto de las funciones incorporadas :func:`isinstance` y :func:" +"`issubclass`." #: ../Doc/reference/datamodel.rst:2062 msgid "" @@ -3592,6 +3617,10 @@ msgid "" "base classes\" to any class or type (including built-in types), including " "other ABCs." msgstr "" +"En particular, la metaclase :class:`abc.ABCMeta` implementa estos métodos " +"para permitir la adición de Clases Base Abstractas (ABCs, por su nombre en " +"inglés *Abstract Base Clases*) como “clases base virtuales” a cualquier " +"clase o tipo (incluyendo tipos incorporados), incluyendo otros ABCs." #: ../Doc/reference/datamodel.rst:2069 msgid "" @@ -3599,6 +3628,9 @@ msgid "" "instance of *class*. If defined, called to implement ``isinstance(instance, " "class)``." msgstr "" +"Devuelve *true* si la instancia *instance* debe ser considerada una " +"instancia (directa o indirecta) de clase *class*. De ser definida, es " +"llamado para implementar ``isinstance(instance, class)``." #: ../Doc/reference/datamodel.rst:2076 msgid "" @@ -3606,6 +3638,9 @@ msgid "" "subclass of *class*. If defined, called to implement ``issubclass(subclass, " "class)``." msgstr "" +"Devuelve *true* si la subclase *subclass* debe ser considerada una subclase " +"(directa o indirecta) de clase *class*. De ser definida, es llamado para " +"implementar ``issubclass(subclass, class)``." #: ../Doc/reference/datamodel.rst:2081 msgid "" @@ -3614,10 +3649,15 @@ msgid "" "consistent with the lookup of special methods that are called on instances, " "only in this case the instance is itself a class." msgstr "" +"Tome en cuenta que estos métodos son buscados en el tipo (metaclase) de una " +"clase. No pueden ser definidos como métodos de clase en la clase actual. " +"Esto es consistente con la búsqueda de métodos especiales que son llamados " +"en instancias, solo en este caso la instancia es por sí misma una clase." #: ../Doc/reference/datamodel.rst:2092 msgid ":pep:`3119` - Introducing Abstract Base Classes" msgstr "" +":pep:`3119` - Introducción a Clases Base Abstractas (*Abstract Base Classes*)" #: ../Doc/reference/datamodel.rst:2089 msgid "" @@ -3627,22 +3667,31 @@ msgid "" "context of adding Abstract Base Classes (see the :mod:`abc` module) to the " "language." msgstr "" +"Incluye la especificación para personalizar el comportamiento de :func:" +"`isinstance` y :func:`issubclass` a través de :meth:`~class." +"__instancecheck__` y :meth:`~class.__subclasscheck__`, con motivación para " +"esta funcionalidad en el contexto de agregar Clases Base Abstractas (ver el " +"módulo :mod:`abc`) al lenguaje." #: ../Doc/reference/datamodel.rst:2097 msgid "Emulating generic types" -msgstr "" +msgstr "Emulando tipos genéricos" #: ../Doc/reference/datamodel.rst:2099 msgid "" "One can implement the generic class syntax as specified by :pep:`484` (for " "example ``List[int]``) by defining a special method:" msgstr "" +"Uno puede implementar la sintaxis de clase genérica como lo especifica :pep:" +"`484` (por ejemplo ``List[int]``) definiendo un método especial:" #: ../Doc/reference/datamodel.rst:2104 msgid "" "Return an object representing the specialization of a generic class by type " "arguments found in *key*." msgstr "" +"Retornar un objeto representando la especialización de una clase genérica " +"por argumentos de tipo encontrados en *key*." #: ../Doc/reference/datamodel.rst:2107 msgid "" @@ -3651,10 +3700,14 @@ msgid "" "is primarily reserved for use with static type hints, other usage is " "discouraged." msgstr "" +"Este método es buscado en el objeto de clase mismo, y cuando es definido en " +"el cuerpo de la clase, este método es un método de clase implícito. Tome en " +"cuenta que este mecanismo es ante todo reservado para su uso con sugerencias " +"de tipo (*type hints*), no se aconseja otro uso." #: ../Doc/reference/datamodel.rst:2120 msgid "Emulating callable objects" -msgstr "" +msgstr "Emulando objetos que se pueden llamar" #: ../Doc/reference/datamodel.rst:2127 msgid "" @@ -3662,10 +3715,13 @@ msgid "" "defined, ``x(arg1, arg2, ...)`` is a shorthand for ``x.__call__(arg1, " "arg2, ...)``." msgstr "" +"Es llamado cuando la instancia es “llamada” como una función; si este método " +"es definido, ``x(arg1, arg2, …)`` es una clave corta para ``x.__call__(arg1, " +"arg2, …)``." #: ../Doc/reference/datamodel.rst:2134 msgid "Emulating container types" -msgstr "" +msgstr "Emulando tipos de contenedores" #: ../Doc/reference/datamodel.rst:2136 msgid "" @@ -3731,10 +3787,12 @@ msgstr "" msgid "" "Slicing is done exclusively with the following three methods. A call like ::" msgstr "" +"La segmentación se hace exclusivamente con los siguientes tres métodos. Un " +"llamado como ::" #: ../Doc/reference/datamodel.rst:2205 msgid "is translated to ::" -msgstr "" +msgstr "es traducido a ::" #: ../Doc/reference/datamodel.rst:2209 msgid "and so forth. Missing slice items are always filled in with ``None``." From a32723f97bfbd31f5091cb79d1d403131274bae2 Mon Sep 17 00:00:00 2001 From: Miguel Angel R Date: Tue, 16 Feb 2021 17:16:36 -0600 Subject: [PATCH 12/17] Avance a 85% --- reference/datamodel.po | 117 ++++++++++++++++++++++++++++++++++++++++- 1 file changed, 115 insertions(+), 2 deletions(-) diff --git a/reference/datamodel.po b/reference/datamodel.po index 32222eebee..b5279d25e4 100644 --- a/reference/datamodel.po +++ b/reference/datamodel.po @@ -11,7 +11,7 @@ msgstr "" "Project-Id-Version: Python 3.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2020-05-05 12:54+0200\n" -"PO-Revision-Date: 2021-01-29 21:17-0600\n" +"PO-Revision-Date: 2021-02-16 17:13-0600\n" "Language-Team: python-doc-es\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" @@ -3755,6 +3755,36 @@ msgid "" "`__iter__` should iterate through the object's keys; for sequences, it " "should iterate through the values." msgstr "" +"Los siguientes métodos pueden ser definidos para implementar objetos " +"contenedores. Los contenedores son generalmente secuencias (como listas o " +"tuplas) o mapeos (como diccionarios), pero también pueden representar otros " +"contenedores. La primera colección de métodos es utilizada ya sea para " +"emular una secuencia o para emular un mapeo; la diferencia es que para una " +"secuencia, las llaves permitidas deben ser los enteros *k* por lo que ``0 <= " +"k < N`` donde *N* es la longitud de la secuencia, o secciones de objetos, " +"los cuales definen un rango de elementos. También es recomendado que los " +"mapeos proporcionen los métodos :meth:`keys`, :meth:`values`, :meth:" +"`items`, :meth:`get`, :meth:`clear`, :meth:`setdefault`, :meth:`pop`, :meth:" +"`popitem`, :meth:`!copy`, y :meth:`update` comportándose de manera similar a " +"aquellos para los objetos de diccionario estándar de Python. El módulo :mod:" +"`collections.abc` proporciona una clase base abstracta :class:`~collections." +"abc.MutableMapping` que ayuda a crear aquellos métodos desde un conjunto " +"base de :meth:`__getitem__`, :meth:`__setitem__`, :meth:`__delitem__`, y :" +"meth:`keys`. Secuencias mutables deben proporcionar métodos :meth:`append`, :" +"meth:`count`, :meth:`index`, :meth:`extend`, :meth:`insert`, :meth:`pop`, :" +"meth:`remove`, :meth:`reverse` y :meth:`sort`, como objetos de lista " +"estándar de Python. Por último, tipos de secuencia deben implementar adición " +"(concatenación) y multiplicación (repetición) al definir los métodos :meth:" +"`__add__`, :meth:`__radd__`, :meth:`__iadd__`, :meth:`__mul__`, :meth:" +"`__rmul__` y :meth:`__imul__` descritos a continuación; no deben definir " +"otros operadores numéricos. Es recomendado que ambos mapeos y secuencias " +"implementen el método :meth:`__contains__` para permitir el uso eficiente " +"del operador ``in``; para mapeos, ``in`` debe buscar las llaves de los " +"mapeos; para secuencias, debe buscar a través de los valores. Además es " +"recomendado que tanto mapeos como secuencias implementen el método :meth:" +"`__iter__` para permitir una iteración eficiente por el contenedor; para " +"mapeos, :meth:`__iter__` debe iterar a través de las llaves del objeto; para " +"secuencias, debe iterar a través de los valores." #: ../Doc/reference/datamodel.rst:2171 msgid "" @@ -3763,6 +3793,10 @@ msgid "" "define a :meth:`__bool__` method and whose :meth:`__len__` method returns " "zero is considered to be false in a Boolean context." msgstr "" +"Es llamado para implementar la función incorporada :func:`len`. Debe " +"retornar la longitud del objeto, un entero ``>=`` 0. También, un objeto que " +"no define un método :meth:`__bool__` y cuyo método :meth:`__len__` retorna " +"cero, es considerado como falso en un contexto booleano." #: ../Doc/reference/datamodel.rst:2178 msgid "" @@ -3772,6 +3806,12 @@ msgid "" "OverflowError` by truth value testing, an object must define a :meth:" "`__bool__` method." msgstr "" +"En CPython, se requiere que la longitud sea como mucho :attr:`sys.maxsize`. " +"Si la longitud es más grande que :attr:`!sys.maxsize` algunas " +"características (como :func:`len`) pueden lanzar una excepción :exc:" +"`OverflowError`. Para prevenir lanzar una excepción :exc:`!OverflowError` al " +"validar la verdad de un valor, un objeto debe definir un método :meth:" +"`__bool__`." #: ../Doc/reference/datamodel.rst:2187 msgid "" @@ -3782,6 +3822,12 @@ msgid "" "method didn't exist at all. This method is purely an optimization and is " "never required for correctness." msgstr "" +"Es llamado para implementar :func:`operator.length_hint`. Debe retornar una " +"longitud estimada para el objeto (que puede ser mayor o menor que la " +"longitud actual). La longitud debe ser un entero ``>=`` 0. El valor de " +"retorno también debe ser :const:`NotImplemented` el cual es tratado de igual " +"forma a que si el método ``__length_hint__`` no existiera en absoluto. Este " +"método es puramente una optimización y nunca es requerido para precisión." #: ../Doc/reference/datamodel.rst:2201 msgid "" @@ -3797,6 +3843,7 @@ msgstr "es traducido a ::" #: ../Doc/reference/datamodel.rst:2209 msgid "and so forth. Missing slice items are always filled in with ``None``." msgstr "" +"etcétera. Elementos faltantes de segmentos siempre son llenados con ``None``." #: ../Doc/reference/datamodel.rst:2214 msgid "" @@ -3809,12 +3856,25 @@ msgid "" "negative values), :exc:`IndexError` should be raised. For mapping types, if " "*key* is missing (not in the container), :exc:`KeyError` should be raised." msgstr "" +"Es llamado para implementar la evaluación de ``self[key]``. Para tipos de " +"secuencia, las llaves aceptadas deben ser enteros y objetos de segmento. Se " +"debe tomar en cuenta que la interpretación especial de índices negativos (si " +"la clase desea emular un tipo de secuencia) depende del método :meth:" +"`__getitem__`. Si *key* es de un tipo apropiado, se puede lanzar una " +"excepción :exc:`TypeError`; si es de un valor afuera de la colección de " +"índices para la secuencia (después de alguna interpretación especial de " +"valores negativos), se debe lanzar una excepción :exc:`IndexError`. Para " +"tipos de mapeos, si falta *key* (no en el contenedor), la excepción :exc:" +"`KeyError` debe ser lanzada." #: ../Doc/reference/datamodel.rst:2225 msgid "" ":keyword:`for` loops expect that an :exc:`IndexError` will be raised for " "illegal indexes to allow proper detection of the end of the sequence." msgstr "" +"ciclos :keyword:`for` esperan que una excepción :exc:`IndexError` sea " +"lanzada para que índices ilegales permitan la detección adecuada del fin de " +"una secuencia." #: ../Doc/reference/datamodel.rst:2231 msgid "" @@ -3824,6 +3884,12 @@ msgid "" "sequences if elements can be replaced. The same exceptions should be raised " "for improper *key* values as for the :meth:`__getitem__` method." msgstr "" +"Es llamado para implementar la asignación a ``self[key]``. Lo mismo con " +"respecto a :meth:`__getitem__`. Esto solo debe ser implementado para mapeos " +"si los objetos permiten cambios a los valores de las llaves, o si nuevas " +"llaves pueden ser añadidas, o para secuencias si los elementos pueden ser " +"reemplazados. Las mismas excepciones deben ser lanzadas para valores de " +"*key* inadecuados con respecto al método :meth:`__getitem__`." #: ../Doc/reference/datamodel.rst:2240 msgid "" @@ -3833,12 +3899,21 @@ msgid "" "the sequence. The same exceptions should be raised for improper *key* " "values as for the :meth:`__getitem__` method." msgstr "" +"Es llamado para implementar el borrado de ``self[key]``. Lo mismo con " +"respecto a :meth:`__getitem__`. Esto solo debe ser implementado para mapeos " +"si los objetos permiten el borrado de llaves, o para secuencias si los " +"elementos pueden ser eliminados de la secuencia. Las mismas excepciones " +"deben ser lanzadas por valores de *key* inapropiados con respecto al método :" +"meth:`__getitem__`." #: ../Doc/reference/datamodel.rst:2249 msgid "" "Called by :class:`dict`\\ .\\ :meth:`__getitem__` to implement ``self[key]`` " "for dict subclasses when key is not in the dictionary." msgstr "" +"Es llamado por :class:`dict`\\ .\\ :meth:`__getitem__` para implementar " +"``self[key]`` para subclases de diccionarios cuando la llave no se encuentra " +"en el diccionario." #: ../Doc/reference/datamodel.rst:2255 msgid "" @@ -3847,6 +3922,10 @@ msgid "" "objects in the container. For mappings, it should iterate over the keys of " "the container." msgstr "" +"Este método es llamado cuando se requiere un iterador para un contenedor. " +"Este método debe retornar un nuevo objeto iterador que pueda iterar todos " +"los objetos del contenedor. Para mapeos, debe iterar sobre las llaves del " +"contenedor." #: ../Doc/reference/datamodel.rst:2259 msgid "" @@ -3854,6 +3933,9 @@ msgid "" "return themselves. For more information on iterator objects, see :ref:" "`typeiter`." msgstr "" +"Objetos iteradores también necesitan implementar este método; son requeridos " +"para retornarse a sí mismos. Para mayor información sobre objetos " +"iteradores, ver :ref:`typeiter`." #: ../Doc/reference/datamodel.rst:2265 msgid "" @@ -3861,6 +3943,9 @@ msgid "" "iteration. It should return a new iterator object that iterates over all " "the objects in the container in reverse order." msgstr "" +"Es llamado (si existe) por la función incorporada :func:`reversed` para " +"implementar una interacción invertida. Debe retornar un nuevo objeto " +"iterador que itere sobre todos los objetos en el contenedor en orden inverso." #: ../Doc/reference/datamodel.rst:2269 msgid "" @@ -3870,6 +3955,12 @@ msgid "" "provide :meth:`__reversed__` if they can provide an implementation that is " "more efficient than the one provided by :func:`reversed`." msgstr "" +"Si el método :meth:`__reversed__` no es proporcionado, la función " +"incorporada :func:`reversed` recurrirá a utilizar el protocolo de secuencia " +"(:meth:`__len__` y :meth:`__getitem__`). Objetos que permiten el protocolo " +"de secuencia deben únicamente proporcionar :meth:`__reversed__` si no pueden " +"proporcionar una implementación que sea más eficiente que la proporcionada " +"por :func:`reversed`." #: ../Doc/reference/datamodel.rst:2276 msgid "" @@ -3878,6 +3969,11 @@ msgid "" "objects can supply the following special method with a more efficient " "implementation, which also does not require the object be iterable." msgstr "" +"Los operadores de prueba de pertenencia (:keyword:`in` and :keyword:`not " +"in`) son normalmente implementados como una iteración sobre un contenedor. " +"Sin embargo, los objetos de contenedor pueden proveer el siguiente método " +"especial con una implementación más eficiente, que tampoco requiere que el " +"objeto sea iterable." #: ../Doc/reference/datamodel.rst:2283 msgid "" @@ -3885,6 +3981,10 @@ msgid "" "is in *self*, false otherwise. For mapping objects, this should consider " "the keys of the mapping rather than the values or the key-item pairs." msgstr "" +"Es llamado para implementar operadores de prueba de pertenencia. Deben " +"retornar *true* si *item* se encuentra en *self*, de lo contrario *false*. " +"Para objetos de mapeo, estos debe considerar las llaves del mapeo en lugar " +"de los valores o los pares de llave-valor." #: ../Doc/reference/datamodel.rst:2287 msgid "" @@ -3893,10 +3993,15 @@ msgid "" "protocol via :meth:`__getitem__`, see :ref:`this section in the language " "reference `." msgstr "" +"Para objetos que no definen :meth:`__contains__`, la prueba de pertenencia " +"primero intenta la iteración a través de :meth:`__iter__`, y luego el " +"antiguo protocolo de iteración de secuencia a través de :meth:`__getitem__`, " +"ver :ref:`esta sección en la referencia del lenguaje `." #: ../Doc/reference/datamodel.rst:2296 msgid "Emulating numeric types" -msgstr "" +msgstr "Emulando tipos numéricos" #: ../Doc/reference/datamodel.rst:2298 msgid "" @@ -3905,6 +4010,10 @@ msgid "" "number implemented (e.g., bitwise operations for non-integral numbers) " "should be left undefined." msgstr "" +"Los siguientes métodos pueden ser definidos para emular objetos numéricos. " +"Métodos que corresponden a operaciones que no son permitidas por el número " +"particular implementado (por ejemplo, operaciones bit a bit para números no " +"enteros) se deben dejar sin definir." #: ../Doc/reference/datamodel.rst:2324 msgid "" @@ -3924,6 +4033,8 @@ msgid "" "If one of those methods does not support the operation with the supplied " "arguments, it should return ``NotImplemented``." msgstr "" +"Si alguno de esos métodos no permiten la operación con los argumentos " +"suministrados, debe retornar ``NotImplemented``." #: ../Doc/reference/datamodel.rst:2358 msgid "" @@ -3942,6 +4053,8 @@ msgid "" "Note that ternary :func:`pow` will not try calling :meth:`__rpow__` (the " "coercion rules would become too complicated)." msgstr "" +"Tomar en cuenta que la función ternaria :func:`pow` no intentará llamar a :" +"meth:`__rpow__` (las reglas de coerción se volverían demasiado complicadas)." #: ../Doc/reference/datamodel.rst:2374 msgid "" From 194c138456e60931953f1be730bd93babadd825a Mon Sep 17 00:00:00 2001 From: Miguel Angel R Date: Fri, 26 Feb 2021 21:03:08 -0600 Subject: [PATCH 13/17] Avance a 90% --- reference/datamodel.po | 97 +++++++++++++++++++++++++++++++++++++++--- 1 file changed, 91 insertions(+), 6 deletions(-) diff --git a/reference/datamodel.po b/reference/datamodel.po index b5279d25e4..e0c094ce6e 100644 --- a/reference/datamodel.po +++ b/reference/datamodel.po @@ -11,7 +11,7 @@ msgstr "" "Project-Id-Version: Python 3.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2020-05-05 12:54+0200\n" -"PO-Revision-Date: 2021-02-16 17:13-0600\n" +"PO-Revision-Date: 2021-02-26 21:07-0600\n" "Language-Team: python-doc-es\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" @@ -4027,6 +4027,16 @@ msgid "" "should be defined to accept an optional third argument if the ternary " "version of the built-in :func:`pow` function is to be supported." msgstr "" +"Estos métodos son llamados para implementar las operaciones aritméticas " +"binarias (``+``, ``-``, ``*``, ``@``, ``/``, ``//``, ``%``, :func:`divmod`, :" +"func:`pow`, ``**``, ``<<``, ``>>``, ``&``, ``^``, ``|``). Por ejemplo, para " +"evaluar la expresión ``x + y``, donde *x* es instancia de una clase que " +"tiene un método :meth:`__add__`, ``x.__add__(y)`` es llamado. El método :" +"meth:`__divmod__` debe ser el equivalente a usar :meth:`__floordiv__` y :" +"meth:`__mod__`; no debe ser relacionado a :meth:`__truediv__`. Se debe tomar " +"en cuenta que :meth:`__pow__` debe ser definido para aceptar un tercer " +"argumento opcional si la versión ternaria de la función incorporada :func:" +"`pow` es soportada." #: ../Doc/reference/datamodel.rst:2335 msgid "" @@ -4047,14 +4057,24 @@ msgid "" "an instance of a class that has an :meth:`__rsub__` method, ``y." "__rsub__(x)`` is called if ``x.__sub__(y)`` returns *NotImplemented*." msgstr "" +"Estos métodos son llamados para implementar las operaciones aritméticas " +"binarias (``+``, ``-``, ``*``, ``@``, ``/``, ``//``, ``%``, :func:`divmod`, :" +"func:`pow`, ``**``, ``<<``, ``>>``, ``&``, ``^``, ``|``) con operandos " +"reflejados (intercambiados). Estas funciones son llamadas únicamente si el " +"operando izquierdo no soporta la operación correspondiente [#]_ y los " +"operandos son de tipos diferentes. [#]_ Por ejemplo, para evaluar la " +"expresión ``x - y``, donde *y* es instancia de una clase que tiene un " +"método :meth:`__rsub__`, ``y.__rsub__(x)`` es llamado si ``x.__sub__(y)`` " +"retorna *NotImplemented*." #: ../Doc/reference/datamodel.rst:2369 msgid "" "Note that ternary :func:`pow` will not try calling :meth:`__rpow__` (the " "coercion rules would become too complicated)." msgstr "" -"Tomar en cuenta que la función ternaria :func:`pow` no intentará llamar a :" -"meth:`__rpow__` (las reglas de coerción se volverían demasiado complicadas)." +"Se debe tomar en cuenta que la función ternaria :func:`pow` no intentará " +"llamar a :meth:`__rpow__` (las reglas de coerción se volverían demasiado " +"complicadas)." #: ../Doc/reference/datamodel.rst:2374 msgid "" @@ -4063,6 +4083,11 @@ msgid "" "will be called before the left operand's non-reflected method. This " "behavior allows subclasses to override their ancestors' operations." msgstr "" +"Si el tipo del operando de la derecha es una subclase del tipo del operando " +"de la izquierda y esa subclase proporciona el método reflejado para la " +"operación, este método será llamado antes del método no reflejado del " +"operando izquierdo. Este comportamiento permite que las subclases anulen las " +"operaciones de sus predecesores." #: ../Doc/reference/datamodel.rst:2394 msgid "" @@ -4079,18 +4104,35 @@ msgid "" "(see :ref:`faq-augmented-assignment-tuple-error`), but this behavior is in " "fact part of the data model." msgstr "" +"Estos métodos son llamados para implementar las asignaciones aritméticas " +"aumentadas (``+=``, ``-=``, ``*=``, ``@=``, ``/=``, ``//=``, ``%=``, " +"``**=``, ``<<=``, ``>>=``, ``&=``, ``^=``, ``|=``). Estos métodos deben " +"intentar realizar la operación *in-place* (modificando *self*) y retornar el " +"resultado (que puede, pero no tiene que ser *self*). Si un método específico " +"no es definido, la asignación aumentada regresa a los métodos normales. Por " +"ejemplo, si *x* es la instancia de una clase con el método :meth:`__iadd__`, " +"``x += y`` es equivalente a ``x = x.__iadd__(y)``. De lo contrario ``x." +"__add__(y)`` y ``y.__radd__(x)`` se consideran al igual que con la " +"evaluación de ``x + y``. En ciertas situaciones, asignaciones aumentadas " +"pueden resultar en errores no esperados (ver :ref:`faq-augmented-assignment-" +"tuple-error`), pero este comportamiento es en realidad parte del modelo de " +"datos." #: ../Doc/reference/datamodel.rst:2415 msgid "" "Called to implement the unary arithmetic operations (``-``, ``+``, :func:" "`abs` and ``~``)." msgstr "" +"Es llamado para implementar las operaciones aritméticas unarias (``-``, ``" +"+``, :func:`abs` and ``~``)." #: ../Doc/reference/datamodel.rst:2428 msgid "" "Called to implement the built-in functions :func:`complex`, :func:`int` and :" "func:`float`. Should return a value of the appropriate type." msgstr "" +"Es llamado para implementar las funciones incorporadas :func:`complex`, :" +"func:`int` y :func:`float`. Debe retornar un valor del tipo apropiado." #: ../Doc/reference/datamodel.rst:2435 msgid "" @@ -4100,6 +4142,11 @@ msgid "" "functions). Presence of this method indicates that the numeric object is an " "integer type. Must return an integer." msgstr "" +"Es llamado para implementar :func:`operator.index`, y cuando sea que Python " +"necesite convertir sin pérdidas el objeto numérico a un objeto entero (tal " +"como en la segmentación o *slicing*, o las funciones incorporadas :func:" +"`bin`, :func:`hex` y :func:`oct`). La presencia de este método indica que el " +"objeto numérico es un tipo entero. Debe retornar un entero." #: ../Doc/reference/datamodel.rst:2441 msgid "" @@ -4107,6 +4154,9 @@ msgid "" "defined then corresponding built-in functions :func:`int`, :func:`float` " "and :func:`complex` fall back to :meth:`__index__`." msgstr "" +"Si :meth:`__int__`, :meth:`__float__` y :meth:`__complex__` no son " +"definidos, entonces todas las funciones incorporadas correspondientes :func:" +"`int`, :func:`float` y :func:`complex` vuelven a :meth:`__index__`." #: ../Doc/reference/datamodel.rst:2453 msgid "" @@ -4116,16 +4166,23 @@ msgid "" "return the value of the object truncated to an :class:`~numbers.Integral` " "(typically an :class:`int`)." msgstr "" +"Es llamado para implementar la función incorporada :func:`round` y las " +"funciones :mod:`math` :func:`~math.trunc`, :func:`~math.floor` y :func:" +"`~math.ceil`. A menos que *ndigits* sea pasado a :meth:`!__round__` todos " +"estos métodos deben retornar el valor del objeto truncado a :class:`~numbers." +"Integral` (normalmente :class:`int`)." #: ../Doc/reference/datamodel.rst:2459 msgid "" "If :meth:`__int__` is not defined then the built-in function :func:`int` " "falls back to :meth:`__trunc__`." msgstr "" +"Si :meth:`__int__` no es definido, entonces la función incorporada :func:" +"`int` regresa a :meth:`__trunc__`." #: ../Doc/reference/datamodel.rst:2466 msgid "With Statement Context Managers" -msgstr "" +msgstr "Gestores de Contexto en la Declaración *with*" #: ../Doc/reference/datamodel.rst:2468 msgid "" @@ -4136,17 +4193,29 @@ msgid "" "using the :keyword:`!with` statement (described in section :ref:`with`), but " "can also be used by directly invoking their methods." msgstr "" +"Un :dfn:`context manager` es un objeto que define el contexto en tiempo de " +"ejecución a ser establecido cuando se ejecuta una declaración :keyword:" +"`with`. El gestor de contexto maneja la entrada y la salida del contexto en " +"tiempo de ejecución deseado para la ejecución del bloque de código. Los " +"gestores de contexto son normalmente invocados utilizando la declaración :" +"keyword:`!with` (descritos en la sección :ref:`with`), pero también pueden " +"ser utilizados al invocar directamente sus métodos." #: ../Doc/reference/datamodel.rst:2479 msgid "" "Typical uses of context managers include saving and restoring various kinds " "of global state, locking and unlocking resources, closing opened files, etc." msgstr "" +"Usos típicos de los gestores de contexto incluyen guardar y restablecer " +"diversos tipos de declaraciones globales, bloquear y desbloquear recursos, " +"cerrar archivos abiertos, etc." #: ../Doc/reference/datamodel.rst:2482 msgid "" "For more information on context managers, see :ref:`typecontextmanager`." msgstr "" +"Para más información sobre gestores de contexto, ver :ref:" +"`typecontextmanager`." #: ../Doc/reference/datamodel.rst:2487 msgid "" @@ -4154,6 +4223,10 @@ msgid "" "statement will bind this method's return value to the target(s) specified in " "the :keyword:`!as` clause of the statement, if any." msgstr "" +"Ingresa al contexto en tiempo de ejecución relacionado con este objeto. La " +"declaración :keyword:`with` ligará el valor de retorno de este método al " +"objetivo especificado en cláusula :keyword:`!as` de la declaración, en caso " +"de existir." #: ../Doc/reference/datamodel.rst:2494 msgid "" @@ -4161,6 +4234,9 @@ msgid "" "exception that caused the context to be exited. If the context was exited " "without an exception, all three arguments will be :const:`None`." msgstr "" +"Sale del contexto en tiempo de ejecución relacionado a este objeto. Los " +"parámetros describen la excepción que causa la salida del contexto. Si éste " +"se termina sin excepción, los tres argumentos serán :const:`None`." #: ../Doc/reference/datamodel.rst:2498 msgid "" @@ -4169,26 +4245,35 @@ msgid "" "Otherwise, the exception will be processed normally upon exit from this " "method." msgstr "" +"Si se proporciona una excepción, y el método desea eliminarla (por ejemplo, " +"prevenir que sea propagada), debe retornar un valor verdadero. De lo " +"contrario, la excepción será procesada de forma normal al salir de este " +"método." #: ../Doc/reference/datamodel.rst:2502 msgid "" "Note that :meth:`__exit__` methods should not reraise the passed-in " "exception; this is the caller's responsibility." msgstr "" +"Se debe tomar en cuenta que los métodos :meth:`__exit__` no deben lanzar de " +"nuevo la excepción que se pasa; esto es la responsabilidad de quien hace el " +"llamado." #: ../Doc/reference/datamodel.rst:2509 msgid ":pep:`343` - The \"with\" statement" -msgstr "" +msgstr ":pep:`343` - La declaración “with”" #: ../Doc/reference/datamodel.rst:2509 msgid "" "The specification, background, and examples for the Python :keyword:`with` " "statement." msgstr "" +"La especificación, el antecedente, y los ejemplos para la declaración de " +"Python :keyword:`with`." #: ../Doc/reference/datamodel.rst:2516 msgid "Special method lookup" -msgstr "" +msgstr "Búsqueda de método especial" #: ../Doc/reference/datamodel.rst:2518 msgid "" From 3d68cc279e1eb34c71d13dd193eb453670578328 Mon Sep 17 00:00:00 2001 From: Miguel Angel R Date: Tue, 2 Mar 2021 18:10:57 -0600 Subject: [PATCH 14/17] Avance a 95% --- reference/datamodel.po | 91 ++++++++++++++++++++++++++++++++++++++---- 1 file changed, 83 insertions(+), 8 deletions(-) diff --git a/reference/datamodel.po b/reference/datamodel.po index e0c094ce6e..c640485b56 100644 --- a/reference/datamodel.po +++ b/reference/datamodel.po @@ -11,7 +11,7 @@ msgstr "" "Project-Id-Version: Python 3.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2020-05-05 12:54+0200\n" -"PO-Revision-Date: 2021-02-26 21:07-0600\n" +"PO-Revision-Date: 2021-03-02 18:09-0600\n" "Language-Team: python-doc-es\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" @@ -4282,6 +4282,11 @@ msgid "" "object's instance dictionary. That behaviour is the reason why the " "following code raises an exception::" msgstr "" +"Para clases personalizadas, invocaciones implícitas de métodos especiales " +"solo están garantizados para trabajar correctamente si son definidos en un " +"tipo de objeto, no en el diccionario de instancia del objeto. Ese " +"comportamiento es la razón por la que el siguiente código lanza una " +"excepción::" #: ../Doc/reference/datamodel.rst:2533 msgid "" @@ -4291,6 +4296,11 @@ msgid "" "used the conventional lookup process, they would fail when invoked on the " "type object itself::" msgstr "" +"La razón fundamental detrás de este comportamiento yace en una serie de " +"métodos especiales como :meth:`__hash__` y :meth:`__repr__` que son " +"implementados por todos los objetos, incluyendo objetos de tipo. Si la " +"búsqueda implícita de estos métodos usaran el proceso de búsqueda " +"convencional, fallarían al ser invocados en el objeto de tipo mismo::" #: ../Doc/reference/datamodel.rst:2546 msgid "" @@ -4298,6 +4308,9 @@ msgid "" "sometimes referred to as 'metaclass confusion', and is avoided by bypassing " "the instance when looking up special methods::" msgstr "" +"Intentar invocar de manera incorrecta el método no ligado de una clase de " +"esta forma a veces es denominado como ‘confusión de metaclase’, y se evita " +"sobrepasando la instancia al buscar métodos especiales::" #: ../Doc/reference/datamodel.rst:2555 msgid "" @@ -4305,6 +4318,10 @@ msgid "" "correctness, implicit special method lookup generally also bypasses the :" "meth:`__getattribute__` method even of the object's metaclass::" msgstr "" +"Además de sobrepasar cualquier atributo de instancia en aras de lo " +"apropiado, la búsqueda implícita del método especial generalmente también " +"sobrepasa al método :meth:`__getattribute__` incluso de la metaclase del " +"objeto::" #: ../Doc/reference/datamodel.rst:2581 msgid "" @@ -4314,14 +4331,19 @@ msgid "" "method *must* be set on the class object itself in order to be consistently " "invoked by the interpreter)." msgstr "" +"Sobrepasar el mecanismo de :meth:`__getattribute__` de esta forma " +"proporciona un alcance importante para optimizaciones de velocidad dentro " +"del intérprete, a costa de cierta flexibilidad en el manejo de métodos " +"especiales (el método especial *debe* ser establecido en el objeto de clase " +"mismo para ser invocado consistentemente por el intérprete)." #: ../Doc/reference/datamodel.rst:2592 msgid "Coroutines" -msgstr "" +msgstr "Corrutinas" #: ../Doc/reference/datamodel.rst:2596 msgid "Awaitable Objects" -msgstr "" +msgstr "Objetos Esperables" #: ../Doc/reference/datamodel.rst:2598 msgid "" @@ -4329,6 +4351,9 @@ msgid "" "method. :term:`Coroutine` objects returned from :keyword:`async def` " "functions are awaitable." msgstr "" +"Un objeto :term:`awaitable` generalmente implementa a un método :meth:" +"`__await__`. Objetos :term:`Coroutine` retornados a partir de funciones :" +"keyword:`async def` son esperables." #: ../Doc/reference/datamodel.rst:2604 msgid "" @@ -4336,6 +4361,9 @@ msgid "" "with :func:`types.coroutine` or :func:`asyncio.coroutine` are also " "awaitable, but they do not implement :meth:`__await__`." msgstr "" +"Los objetos :term:`generator iterator` retornados a partir de generadores " +"decorados con :func:`types.coroutine` o :func:`asyncio.coroutine` también " +"son esperables, pero no implementan :meth:`__await__`." #: ../Doc/reference/datamodel.rst:2610 msgid "" @@ -4343,14 +4371,17 @@ msgid "" "`awaitable` objects. For instance, :class:`asyncio.Future` implements this " "method to be compatible with the :keyword:`await` expression." msgstr "" +"Debe retornar un :term:`iterator`. Debe ser utilizado para implementar " +"objetos :term:`awaitable`. Por ejemplo, :class:`asyncio.Future` implementa " +"este método para ser compatible con la expresión :keyword:`await`." #: ../Doc/reference/datamodel.rst:2616 msgid ":pep:`492` for additional information about awaitable objects." -msgstr "" +msgstr ":pep:`492` para información adicional sobre objetos esperables." #: ../Doc/reference/datamodel.rst:2622 msgid "Coroutine Objects" -msgstr "" +msgstr "Objetos de Corrutina" #: ../Doc/reference/datamodel.rst:2624 msgid "" @@ -4362,6 +4393,14 @@ msgid "" "raises an exception, it is propagated by the iterator. Coroutines should " "not directly raise unhandled :exc:`StopIteration` exceptions." msgstr "" +"Objetos :term:`Coroutine` son objetos :term:`awaitable`. La ejecución de una " +"corrutina puede ser controlada llamando :meth:`__await__` e iterando sobre " +"el resultado. Cuando la corrutina ha terminado de ejecutar y retorna, el " +"iterados levanta una excepción :exc:`StopIteration`, y el atributo :attr:" +"`~StopIteration.value` de dicha excepción mantiene el valor de retorno. Si " +"la corrutina lanza una excepción, ésta es propagada por el iterador. Las " +"corrutinas no deben lanzar directamente excepciones :exc:`StopIteration` no " +"manejadas." #: ../Doc/reference/datamodel.rst:2632 msgid "" @@ -4369,10 +4408,15 @@ msgid "" "of generators (see :ref:`generator-methods`). However, unlike generators, " "coroutines do not directly support iteration." msgstr "" +"Las corrutinas también tienen los métodos mencionados a continuación, los " +"cuales son análogos a los de los generadores. (ver :ref:`generator-" +"methods`). Sin embargo, a diferencia de los generadores, las corrutinas no " +"soportan directamente iteración." #: ../Doc/reference/datamodel.rst:2636 msgid "It is a :exc:`RuntimeError` to await on a coroutine more than once." msgstr "" +"Es un error :exc:`RuntimeError` esperar a una corrutina más de una vez." #: ../Doc/reference/datamodel.rst:2642 msgid "" @@ -4383,6 +4427,13 @@ msgid "" "result (return value, :exc:`StopIteration`, or other exception) is the same " "as when iterating over the :meth:`__await__` return value, described above." msgstr "" +"Inicia o continua la ejecución de una corrutina. Si *value* es ``None``, " +"esto es equivalente a avanzar al iterador retornado por :meth:`__await__`. " +"Si *value* no es ``None``, este método delega al método :meth:`~generator." +"send` del iterador que causó la suspensión de la corrutina. El resultado (el " +"valor de retorno, :exc:`StopIteration`, u otra excepción) es el mismo que " +"cuando se itera sobre el valor de retorno de :meth:`__await__`, descrito " +"anteriormente." #: ../Doc/reference/datamodel.rst:2652 msgid "" @@ -4394,6 +4445,13 @@ msgid "" "meth:`__await__` return value, described above. If the exception is not " "caught in the coroutine, it propagates back to the caller." msgstr "" +"Lanza la excepción especificada en la corrutina. Este método delega a :meth:" +"`~generator.throw` del iterador que causó la suspensión de la corrutina, si " +"dicho método existe. De lo contrario, la excepción es lanzada al punto de la " +"suspensión. El resultado (valor de retorno, :exc:`StopIteration`, u otra " +"excepción) es el mismo que cuando se itera sobre el valor de retorno de :" +"meth:`__await__` descrito anteriormente. Si la excepción no es obtenida en " +"la corrutina, ésta se propaga de regreso a quien realizó el llamado." #: ../Doc/reference/datamodel.rst:2663 msgid "" @@ -4404,47 +4462,64 @@ msgid "" "causing the coroutine to immediately clean itself up. Finally, the coroutine " "is marked as having finished executing, even if it was never started." msgstr "" +"Causa que la corrutina misma se borre a sí misma y termine su ejecución. Si " +"la corrutina es suspendida, este método primero delega a :meth:`~generator." +"close`, si existe, del iterador que causó la suspensión de la corrutina. " +"Luego lanza una excepción :exc:`GeneratorExit` en el punto de suspensión, " +"causando que la corrutina se borre a sí misma. Finalmente, la corrutina es " +"marcada como completada, aún si nunca inició." #: ../Doc/reference/datamodel.rst:2671 msgid "" "Coroutine objects are automatically closed using the above process when they " "are about to be destroyed." msgstr "" +"Objetos de corrutina son cerrados automáticamente utilizando el proceso " +"anterior cuando están a punto de ser destruidos." #: ../Doc/reference/datamodel.rst:2677 msgid "Asynchronous Iterators" -msgstr "" +msgstr "Iteradores asíncronos" #: ../Doc/reference/datamodel.rst:2679 msgid "" "An *asynchronous iterator* can call asynchronous code in its ``__anext__`` " "method." msgstr "" +"Un *iterador asíncrono* puede llamar código asíncrono en su método " +"``__anext__``." #: ../Doc/reference/datamodel.rst:2682 msgid "" "Asynchronous iterators can be used in an :keyword:`async for` statement." msgstr "" +"Iteradores asíncronos pueden ser utilizados en la declaración :keyword:" +"`async for`." #: ../Doc/reference/datamodel.rst:2686 msgid "Must return an *asynchronous iterator* object." -msgstr "" +msgstr "Debe retornar un objeto de *iterador asíncrono*." #: ../Doc/reference/datamodel.rst:2690 msgid "" "Must return an *awaitable* resulting in a next value of the iterator. " "Should raise a :exc:`StopAsyncIteration` error when the iteration is over." msgstr "" +"Debe retornar un *esperable* (awaitable) resultante en el siguiente valor " +"del iterador. Debe levantar una excepción :exc:`StopAsyncIteration` cuando " +"la iteración termina." #: ../Doc/reference/datamodel.rst:2693 msgid "An example of an asynchronous iterable object::" -msgstr "" +msgstr "Un ejemplo de objeto iterable asíncrono::" #: ../Doc/reference/datamodel.rst:2710 msgid "" "Prior to Python 3.7, ``__aiter__`` could return an *awaitable* that would " "resolve to an :term:`asynchronous iterator `." msgstr "" +"Antes de Python 3.7, ``__aiter__`` podía retornar un *esperable* que se " +"resolvería en un :term:`asynchronous iterator `." #: ../Doc/reference/datamodel.rst:2715 msgid "" From 6a03b5793f26f776ebe47243a203e06b7c121491 Mon Sep 17 00:00:00 2001 From: Miguel Angel R Date: Wed, 10 Mar 2021 17:20:13 -0600 Subject: [PATCH 15/17] Avance a 100% --- reference/datamodel.po | 39 ++++++++++++++++++++++++++++++--------- 1 file changed, 30 insertions(+), 9 deletions(-) diff --git a/reference/datamodel.po b/reference/datamodel.po index c640485b56..8ce3770970 100644 --- a/reference/datamodel.po +++ b/reference/datamodel.po @@ -11,7 +11,7 @@ msgstr "" "Project-Id-Version: Python 3.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2020-05-05 12:54+0200\n" -"PO-Revision-Date: 2021-03-02 18:09-0600\n" +"PO-Revision-Date: 2021-03-10 17:19-0600\n" "Language-Team: python-doc-es\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" @@ -800,7 +800,6 @@ msgid "User-defined functions" msgstr "Funciones definidas por el usuario" #: ../Doc/reference/datamodel.rst:460 -#, fuzzy msgid "" "A user-defined function object is created by a function definition (see " "section :ref:`function`). It should be called with an argument list " @@ -962,7 +961,6 @@ msgstr "" "valor asignado." #: ../Doc/reference/datamodel.rst:542 -#, fuzzy msgid "" "Function objects also support getting and setting arbitrary attributes, " "which can be used, for example, to attach metadata to functions. Regular " @@ -1003,7 +1001,6 @@ msgid "Instance methods" msgstr "Métodos de instancia" #: ../Doc/reference/datamodel.rst:562 -#, fuzzy msgid "" "An instance method object combines a class, a class instance and any " "callable object (normally a user-defined function)." @@ -2087,7 +2084,6 @@ msgstr "" "ejemplo: ``super().__init__([args…])``." #: ../Doc/reference/datamodel.rst:1203 -#, fuzzy msgid "" "Because :meth:`__new__` and :meth:`__init__` work together in constructing " "objects (:meth:`__new__` to create it, and :meth:`__init__` to customize " @@ -3542,7 +3538,6 @@ msgstr "" "definida y el nombre de un descriptor particular asignado;" #: ../Doc/reference/datamodel.rst:2029 -#, fuzzy msgid "" "finally, the :meth:`~object.__init_subclass__` hook is called on the " "immediate parent of the new class in its method resolution order." @@ -4526,42 +4521,53 @@ msgid "" "Starting with Python 3.7, ``__aiter__`` must return an asynchronous iterator " "object. Returning anything else will result in a :exc:`TypeError` error." msgstr "" +"A partir de Python 3.7, ``__aiter__`` debe retornar un objeto iterador " +"asíncrono. Retornar cualquier otra cosa resultará en un error :exc:" +"`TypeError`." #: ../Doc/reference/datamodel.rst:2723 msgid "Asynchronous Context Managers" -msgstr "" +msgstr "Gestores de Contexto Asíncronos" #: ../Doc/reference/datamodel.rst:2725 msgid "" "An *asynchronous context manager* is a *context manager* that is able to " "suspend execution in its ``__aenter__`` and ``__aexit__`` methods." msgstr "" +"Un *gestor de contexto asíncrono* es un *gestor de contexto* que puede " +"suspender la ejecución en sus métodos ``__aenter__`` y ``__aexit__``." #: ../Doc/reference/datamodel.rst:2728 msgid "" "Asynchronous context managers can be used in an :keyword:`async with` " "statement." msgstr "" +"Los gestores de contexto asíncronos pueden ser utilizados en una " +"declaración :keyword:`async with`." #: ../Doc/reference/datamodel.rst:2732 msgid "" "Semantically similar to :meth:`__enter__`, the only difference being that it " "must return an *awaitable*." msgstr "" +"Semánticamente similar a :meth:`__enter__`, siendo la única diferencia que " +"debe retorna un *esperable*." #: ../Doc/reference/datamodel.rst:2737 msgid "" "Semantically similar to :meth:`__exit__`, the only difference being that it " "must return an *awaitable*." msgstr "" +"Semánticamente similar a :meth:`__exit__`, siendo la única diferencia que " +"debe retornar un *esperable*." #: ../Doc/reference/datamodel.rst:2740 msgid "An example of an asynchronous context manager class::" -msgstr "" +msgstr "Un ejemplo de una clase de gestor de contexto asíncrono::" #: ../Doc/reference/datamodel.rst:2753 msgid "Footnotes" -msgstr "" +msgstr "Notas a pie de página" #: ../Doc/reference/datamodel.rst:2754 msgid "" @@ -4569,6 +4575,9 @@ msgid "" "controlled conditions. It generally isn't a good idea though, since it can " "lead to some very strange behaviour if it is handled incorrectly." msgstr "" +"Es posible cambiar en algunos casos un tipo de objeto bajo ciertas " +"circunstancias controladas. Generalmente no es buena idea, ya que esto puede " +"llevar a un comportamiento bastante extraño de no ser tratado correctamente." #: ../Doc/reference/datamodel.rst:2758 msgid "" @@ -4577,6 +4586,10 @@ msgid "" "raise a :exc:`TypeError`, but may do so by relying on the behavior that " "``None`` is not callable." msgstr "" +"Los métodos :meth:`__hash__`, :meth:`__iter__`, :meth:`__reversed__`, y :" +"meth:`__contains__` tienen manejo especial para esto; otros lanzarán un " +"error :exc:`TypeError`, pero lo harán dependiendo del comportamiento de que " +"``None`` no se puede llamar." #: ../Doc/reference/datamodel.rst:2763 msgid "" @@ -4585,6 +4598,11 @@ msgid "" "want to force fallback to the right operand's reflected method—that will " "instead have the opposite effect of explicitly *blocking* such fallback." msgstr "" +"“No soporta” aquí significa que la clase no tiene tal método, o el método " +"retorna ``NotImplemented``. No establecer el método a ``None`` si se quiere " +"forzar el retroceso al método reflejado del operando correcto—eso, por el " +"contrario, tendrá un efecto opuesto de bloquear explícitamente dicho " +"retroceso." #: ../Doc/reference/datamodel.rst:2769 msgid "" @@ -4592,3 +4610,6 @@ msgid "" "method (such as :meth:`__add__`) fails the operation is not supported, which " "is why the reflected method is not called." msgstr "" +"Para operandos del mismo tipo, se asume que si el método no reflejado (como :" +"meth:`__add__`) falla, la operación no es soportada, por lo cual el método " +"reflejado no es llamado." From 64314b24077755a4194c85a28b0c5f0a62b7f8ad Mon Sep 17 00:00:00 2001 From: Cristian Maureira-Fredes Date: Fri, 19 Mar 2021 22:58:32 +0100 Subject: [PATCH 16/17] =?UTF-8?q?Traducidas=20=C3=BAltimas=20entradas?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- reference/datamodel.po | 73 ++++++++++++++++++++++++++++++------------ 1 file changed, 53 insertions(+), 20 deletions(-) diff --git a/reference/datamodel.po b/reference/datamodel.po index ca02a4a14f..cd6fae651a 100644 --- a/reference/datamodel.po +++ b/reference/datamodel.po @@ -11,15 +11,16 @@ msgstr "" "Project-Id-Version: Python 3.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2021-03-19 11:16+0100\n" -"PO-Revision-Date: 2020-06-09 20:48-0500\n" -"Last-Translator: Carlos Joel Delgado Pizarro \n" +"PO-Revision-Date: 2021-03-19 22:57+0100\n" +"Last-Translator: Cristián Maureira-Fredes \n" "Language: es\n" "Language-Team: python-doc-es\n" -"Plural-Forms: nplurals=2; plural=(n != 1)\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.8.0\n" +"X-Generator: Poedit 2.4.1\n" #: ../Doc/reference/datamodel.rst:6 msgid "Data model" @@ -295,6 +296,10 @@ msgid "" "currently evaluates as true, it will emit a :exc:`DeprecationWarning`. It " "will raise a :exc:`TypeError` in a future version of Python." msgstr "" +"La evaluación de ``NotImplemented`` en un contexto booleano está en desuso. " +"Si bien actualmente se evalúa como verdadero, lanzará un :exc:" +"`DeprecationWarning`. Lanzará un :exc:`TypeError` en una versión futura de " +"Python." #: ../Doc/reference/datamodel.rst:179 msgid "Ellipsis" @@ -334,32 +339,40 @@ msgid "" "The string representations of the numeric classes, computed by :meth:" "`__repr__` and :meth:`__str__`, have the following properties:" msgstr "" +"Las representaciones de cadena de las clases numéricas, calculadas por :meth:" +"`__repr__` y :meth:`__str__`, tienen las siguientes propiedades:" #: ../Doc/reference/datamodel.rst:194 msgid "" "They are valid numeric literals which, when passed to their class " "constructor, produce an object having the value of the original numeric." msgstr "" +"Son literales numéricos válidos que, cuando se pasan a su constructor de " +"clase, producen un objeto que tiene el valor del numérico original." #: ../Doc/reference/datamodel.rst:198 msgid "The representation is in base 10, when possible." -msgstr "" +msgstr "La representación está en base 10, cuando sea posible." #: ../Doc/reference/datamodel.rst:200 msgid "" "Leading zeros, possibly excepting a single zero before a decimal point, are " "not shown." msgstr "" +"Los ceros iniciales, posiblemente excepto un solo cero antes de un punto " +"decimal, no se muestran." #: ../Doc/reference/datamodel.rst:203 msgid "" "Trailing zeros, possibly excepting a single zero after a decimal point, are " "not shown." msgstr "" +"Los ceros finales, posiblemente excepto un solo cero después de un punto " +"decimal, no se muestran." #: ../Doc/reference/datamodel.rst:206 msgid "A sign is shown only when the number is negative." -msgstr "" +msgstr "Solo se muestra un signo cuando el número es negativo." #: ../Doc/reference/datamodel.rst:208 msgid "" @@ -839,16 +852,15 @@ msgid "User-defined functions" msgstr "Funciones definidas por el usuario" #: ../Doc/reference/datamodel.rst:482 -#, fuzzy msgid "" "A user-defined function object is created by a function definition (see " "section :ref:`function`). It should be called with an argument list " "containing the same number of items as the function's formal parameter list." msgstr "" -"Una objeto del tipo función, definida por el usuario, es creado por un " -"definición de función (vea la sección :ref:`function`). Debe llamarse con " -"una lista de argumentos que contenga el mismo número de elementos que la " -"lista de parámetros formales de la función." +"Un objeto función definido por el usuario, es creado por un definición de " +"función (vea la sección :ref:`function`). Debe llamarse con una lista de " +"argumentos que contenga el mismo número de elementos que la lista de " +"parámetros formales de la función." #: ../Doc/reference/datamodel.rst:487 msgid "Special attributes:" @@ -1042,7 +1054,6 @@ msgid "Instance methods" msgstr "Métodos de instancia" #: ../Doc/reference/datamodel.rst:584 -#, fuzzy msgid "" "An instance method object combines a class, a class instance and any " "callable object (normally a user-defined function)." @@ -2393,12 +2404,15 @@ msgid "" "``x<=y``. To automatically generate ordering operations from a single root " "operation, see :func:`functools.total_ordering`." msgstr "" -"Por defecto, :meth:`__ne__` delega a :meth:`__eq__` e invierte el resultado " -"a menos que éste sea ``NotImplemented``. No existen otras relaciones " -"implícitas entre los operadores de comparación, por ejemplo, la verdad de " -"``(x` ``object.__getattr__`` with " "arguments ``obj``, ``name``." msgstr "" +"Lanza un :ref:`evento de auditoría ` ``object.__getattr__`` con " +"argumentos ``obj``, ``name``." #: ../Doc/reference/datamodel.rst:1564 msgid "" "For certain sensitive attribute accesses, raises an :ref:`auditing event " "` ``object.__getattr__`` with arguments ``obj`` and ``name``." msgstr "" +"Para ciertos accesos a atributos sensibles, lanza un :ref:`evento de " +"auditoría ` ``object.__getattr__`` con los argumentos ``obj`` y " +"``name``." #: ../Doc/reference/datamodel.rst:1571 msgid "" @@ -2721,6 +2740,8 @@ msgid "" "Raises an :ref:`auditing event ` ``object.__setattr__`` with " "arguments ``obj``, ``name``, ``value``." msgstr "" +"Lanza un :ref:`evento de auditoría ` ``object.__setattr__`` con " +"argumentos ``obj``, ``name``, ``value``." #: ../Doc/reference/datamodel.rst:1581 msgid "" @@ -2728,6 +2749,9 @@ msgid "" "` ``object.__setattr__`` with arguments ``obj``, ``name``, " "``value``." msgstr "" +"Para ciertas asignaciones de atributos sensibles, genera un :ref:`evento de " +"auditoría ` ``object.__setattr__`` con argumentos ``obj``, " +"``name``, ``value``." #: ../Doc/reference/datamodel.rst:1588 msgid "" @@ -2744,12 +2768,17 @@ msgid "" "Raises an :ref:`auditing event ` ``object.__delattr__`` with " "arguments ``obj``, ``name``." msgstr "" +"Lanza un :ref:`evento de auditoría ` ``object.__delattr__`` con " +"argumentos ``obj``, ``name``." #: ../Doc/reference/datamodel.rst:1593 msgid "" "For certain sensitive attribute deletions, raises an :ref:`auditing event " "` ``object.__delattr__`` with arguments ``obj`` and ``name``." msgstr "" +"Para ciertas eliminaciones de atributos sensibles, genera un :ref:`evento de " +"auditoría ` ``object.__delattr__`` con argumentos ``obj`` y " +"``name``." #: ../Doc/reference/datamodel.rst:1600 msgid "" @@ -3088,9 +3117,10 @@ msgstr "" "alguno, es un descriptor sin datos. Normalmente los descriptores de datos " "definen ambos :meth:`__get__` y :meth:`__set__`, mientras que los " "descriptores sin datos solo tienen el método :meth:`__get__`. Descriptores " -"de datos con :meth:`__set__` y :meth:`__get__` definidos siempre anulan una " -"re-definición en el diccionario de instancias. Por el contrario, los " -"descriptores sin datos pueden ser anulados por instancias." +"de datos con :meth:`__set__` y :meth:`__get__` (o :meth:`__delete__`) " +"definidos siempre anulan una re-definición en el diccionario de instancias. " +"Por el contrario, los descriptores sin datos pueden ser anulados por " +"instancias." #: ../Doc/reference/datamodel.rst:1789 msgid "" @@ -4202,6 +4232,9 @@ msgid "" "meth:`__ipow__` but returns ``NotImplemented`` would fail to fall back to " "``x.__pow__(y)`` and ``y.__rpow__(x)``. This bug is fixed in Python 3.10." msgstr "" +"Debido a un error en el mecanismo de envío de ``**=``, una clase que define :" +"meth:`__ipow__` pero retorna ``NotImplemented`` no podría volver a ``x." +"__pow__(y)`` y ``y.__rpow__(x)``. Este error se corrigió en Python 3.10." #: ../Doc/reference/datamodel.rst:2465 msgid "" From 2380de12be7155f68939534d001d160867cefe79 Mon Sep 17 00:00:00 2001 From: Cristian Maureira-Fredes Date: Fri, 19 Mar 2021 23:02:13 +0100 Subject: [PATCH 17/17] Devolver -> Retornar, Generar -> Lanzar --- reference/datamodel.po | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/reference/datamodel.po b/reference/datamodel.po index cd6fae651a..f393d3ffeb 100644 --- a/reference/datamodel.po +++ b/reference/datamodel.po @@ -1189,13 +1189,13 @@ msgid "" msgstr "" "Una función o método que utiliza la declaración :keyword:`yield` (ver " "sección :ref:`yield`) se llama :dfn:`generator function`. Dicha función, " -"cuando es invocada, siempre devuelve un objeto iterador que puede ser " +"cuando es invocada, siempre retorna un objeto iterador que puede ser " "utilizado para ejecutar el cuerpo de la función: invocando el método " "iterador :meth:`iterator.__next__` hará que la función se ejecute hasta " "proporcionar un valor utilizando la declaración :keyword:`!yield`. Cuando " "la función ejecuta una declaración :keyword:`return` o llega hasta el final, " "una excepción :exc:`StopIteration` es lanzada y el iterador habrá llegado al " -"final del conjunto de valores a ser devueltos." +"final del conjunto de valores a ser retornados." #: ../Doc/reference/datamodel.rst:664 msgid "Coroutine functions" @@ -1842,7 +1842,7 @@ msgstr "" "en cada nivel de desenvolvimiento se inserta un objeto de rastreo al frente " "del rastreo actual. Cuando se entra a un manejo de excepción, la pila de " "rastreo se vuelve disponible para el programa. (Ver sección :ref:`try`.) Es " -"accesible como el tercer elemento de la tupla devuelta por ``sys." +"accesible como el tercer elemento de la tupla retornada por ``sys." "exc_info()``, y como el atributo ``__traceback__`` de la excepción capturada." #: ../Doc/reference/datamodel.rst:1068 @@ -1941,7 +1941,7 @@ msgid "" msgstr "" "Este método toma un argumento *length* de entero simple y calcula " "información relacionada con el segmento que el mismo describiría si fuera " -"aplicado a una secuencia de elementos *length*. Devuelve una tupla de tres " +"aplicado a una secuencia de elementos *length*. Retorna una tupla de tres " "enteros; respectivamente estos son los índices *start* y *stop* y el *step* " "o longitud del paso del segmento. Índices faltantes o fuera de los límites " "son manipulados de manera consistente con segmentos regulares." @@ -2104,7 +2104,7 @@ msgid "" "If :meth:`__new__` does not return an instance of *cls*, then the new " "instance's :meth:`__init__` method will not be invoked." msgstr "" -"Si :meth:`__new__` no devuelve una instancia de *cls*, entonces el nuevo " +"Si :meth:`__new__` no retorna una instancia de *cls*, entonces el nuevo " "método :meth:`__init__` de la instancia no será invocado." #: ../Doc/reference/datamodel.rst:1209 @@ -2511,7 +2511,7 @@ msgid "" msgstr "" "Clases definidas por usuario tienen los métodos :meth:`__eq__` y :meth:" "`__hash__` por defecto; con ellos, todos los objetos se comparan de manera " -"desigual (excepto con ellos mismos) y ``x.__hash__()`` devuelve un valor " +"desigual (excepto con ellos mismos) y ``x.__hash__()`` retorna un valor " "apropiado tal que ``x == y`` implique que ``x es y`` y ``hash(x) == " "hash(y)``." @@ -2749,7 +2749,7 @@ msgid "" "` ``object.__setattr__`` with arguments ``obj``, ``name``, " "``value``." msgstr "" -"Para ciertas asignaciones de atributos sensibles, genera un :ref:`evento de " +"Para ciertas asignaciones de atributos sensibles, lanza un :ref:`evento de " "auditoría ` ``object.__setattr__`` con argumentos ``obj``, " "``name``, ``value``." @@ -2776,7 +2776,7 @@ msgid "" "For certain sensitive attribute deletions, raises an :ref:`auditing event " "` ``object.__delattr__`` with arguments ``obj`` and ``name``." msgstr "" -"Para ciertas eliminaciones de atributos sensibles, genera un :ref:`evento de " +"Para ciertas eliminaciones de atributos sensibles, lanza un :ref:`evento de " "auditoría ` ``object.__delattr__`` con argumentos ``obj`` y " "``name``." @@ -3735,9 +3735,9 @@ msgid "" "instance of *class*. If defined, called to implement ``isinstance(instance, " "class)``." msgstr "" -"Devuelve *true* si la instancia *instance* debe ser considerada una " -"instancia (directa o indirecta) de clase *class*. De ser definida, es " -"llamado para implementar ``isinstance(instance, class)``." +"Retorna *true* si la instancia *instance* debe ser considerada una instancia " +"(directa o indirecta) de clase *class*. De ser definida, es llamado para " +"implementar ``isinstance(instance, class)``." #: ../Doc/reference/datamodel.rst:2118 msgid "" @@ -3745,7 +3745,7 @@ msgid "" "subclass of *class*. If defined, called to implement ``issubclass(subclass, " "class)``." msgstr "" -"Devuelve *true* si la subclase *subclass* debe ser considerada una subclase " +"Retorna *true* si la subclase *subclass* debe ser considerada una subclase " "(directa o indirecta) de clase *class*. De ser definida, es llamado para " "implementar ``issubclass(subclass, class)``."