From 3783579568acd202b837632c8c4ef0ee2943a464 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cristi=C3=A1n=20Maureira-Fredes?= Date: Sat, 23 Nov 2024 22:51:20 +0100 Subject: [PATCH 1/3] Translate whatsnew/2.2 Closes #3183 --- dictionaries/whatsnew_2.2.txt | 148 +++--- whatsnew/2.2.po | 854 ++++++++++++++++++++-------------- 2 files changed, 593 insertions(+), 409 deletions(-) diff --git a/dictionaries/whatsnew_2.2.txt b/dictionaries/whatsnew_2.2.txt index 948f4e3e15..649d60a9fd 100644 --- a/dictionaries/whatsnew_2.2.txt +++ b/dictionaries/whatsnew_2.2.txt @@ -1,61 +1,87 @@ -An -Baxter -Bolen -Bremmer -Briggs -Carel -Common -Corp -Donnell -Edward -Eiffel -Fellinger -Gerhard -Hagino -Hansen -Hetland -Häring -Icon -Itamar -Jens -Joonas -Jun -Keith -Labs -Language -Lauder -Magnus -Mathewson -Michel -Moore -Overview -Paalasma -Pelletier -Piers -Programming -Quade -Reinhardt -Romberg -Shtull -Solutions -Stephen -Stolk -Tom -Trauring -Ward -What -Wise -descomentarlos -desocuparlos -dev -generización -hackeando -ichiro -itojun -memberst -must -ndiff -of -reanudables -subclasificarse -uu +Abr +Ago +An +Baxter +Bolen +Bremmer +Briggs +Carel +Common +Corp +Daily +Dic +Donnell +Edward +Eiffel +Feb +Fellinger +Freshmeat +Gerhard +Hagino +Hansen +Hetland +Häring +Icon +Itamar +Jens +Joonas +Jul +Jun +Keith +Labs +Language +Lauder +Magnus +Mathewson +Michel +Moore +Nov +Oct +Overview +Paalasma +Pelletier +Piers +Programming +Quade +Reinhardt +Romberg +Shtull +Solutions +Stephen +Stolk +Tom +Trauring +Ul +Ward +What +Wise +channel +channels +computation +descomentarlos +desocuparlos +dev +eiffel +eiffelmethod +filter +furrfu +generización +getChannels +getItems +hackeando +ichiro +inorder +itojun +meerkat +memberst +must +ndiff +newattr +ny +of +pseudosecuencias +reanudables +save +subclasificarse +uu +xc diff --git a/whatsnew/2.2.po b/whatsnew/2.2.po index 45081c5b23..b2a69166f9 100644 --- a/whatsnew/2.2.po +++ b/whatsnew/2.2.po @@ -13,12 +13,12 @@ msgstr "" "POT-Creation-Date: 2024-11-21 16:38-0300\n" "PO-Revision-Date: 2024-01-21 18:26+0100\n" "Last-Translator: Claudia Millan \n" -"Language: es\n" "Language-Team: python-doc-es\n" -"Plural-Forms: nplurals=2; plural=(n != 1);\n" +"Language: es\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" "Generated-By: Babel 2.16.0\n" #: ../Doc/whatsnew/2.2.rst:3 @@ -101,7 +101,6 @@ msgstr "" "algunos comentarios." #: ../Doc/whatsnew/2.2.rst:52 -#, fuzzy msgid "" "A long time ago I wrote a web page listing flaws in Python's design. One of " "the most significant flaws was that it's impossible to subclass Python types " @@ -112,15 +111,15 @@ msgid "" "there's lots of C code that expects a regular Python list and won't accept " "a :class:`~collections.UserList` instance." msgstr "" -"Hace mucho tiempo escribí una página web que enumeraba los defectos en el " -"diseño de Python. Una de las fallas más importantes fue que es imposible " -"subclasificar tipos de Python implementados en C. En particular, no es " -"posible subclasificar tipos incorporados, por lo que no se puede solo " -"subclasificar, digamos, listas para agregar un solo método útil para ellos. " -"El módulo :mod:`UserList` proporciona una clase que admite todos los métodos " -"de listas y que puede subclasificarse aún más, pero hay mucho código C que " -"espera una lista normal de Python y no aceptará una instancia :class:" -"`UserList`." +"Hace mucho tiempo escribí una página web en la que enumeraba los defectos de " +"diseño de Python. Uno de los defectos más importantes era que resulta " +"imposible crear subclases de los tipos de Python implementados en C. En " +"particular, no es posible crear subclases de los tipos integrados, por lo " +"que no se pueden crear subclases de, por ejemplo, listas para añadirles un " +"único método útil. El módulo :mod:`!UserList` proporciona una clase que " +"admite todos los métodos de las listas y que se puede subclasificar aún más, " +"pero hay mucho código C que espera una lista de Python normal y no acepta " +"una instancia de :class:`~collections.UserList`." #: ../Doc/whatsnew/2.2.rst:61 msgid "" @@ -148,7 +147,6 @@ msgstr "" "de instancia disponibles en versiones anteriores de Python." #: ../Doc/whatsnew/2.2.rst:70 -#, fuzzy msgid "" "It's also possible to automatically call methods on accessing or setting an " "instance attribute by using a new mechanism called :dfn:`properties`. Many " @@ -156,12 +154,12 @@ msgid "" "instead, making the resulting code simpler and faster. As a small side " "benefit, attributes can now have docstrings, too." msgstr "" -"También es posible llamar automáticamente métodos al acceder o configurar un " -"atributo de instancia mediante el uso de un nuevo mecanismo llamado :dfn:" -"`properties`. Muchos usos de :meth:`__getattr__` se pueden reescribir para " -"usar propiedades en su lugar, haciendo que el código resultante sea más " -"simple y rápido. Como un pequeño beneficio secundario, ahora también los " -"atributos pueden tener docstrings." +"También es posible llamar automáticamente a métodos al acceder o configurar " +"un atributo de instancia mediante un nuevo mecanismo llamado :dfn:" +"`properties`. Muchos usos de :meth:`~object.__getattr__` se pueden " +"reescribir para utilizar propiedades en su lugar, lo que hace que el código " +"resultante sea más simple y rápido. Como pequeño beneficio adicional, los " +"atributos ahora también pueden tener cadenas de documentación." #: ../Doc/whatsnew/2.2.rst:76 msgid "" @@ -267,9 +265,12 @@ msgid "" " ...\n" " ..." msgstr "" +"clase C(objeto):\n" +"def __init__(self):\n" +"...\n" +"..." #: ../Doc/whatsnew/2.2.rst:121 -#, fuzzy msgid "" "This means that :keyword:`class` statements that don't have any base classes " "are always classic classes in Python 2.2. (Actually you can also change " @@ -277,11 +278,11 @@ msgid "" "see :pep:`253` for the details --- but it's easier to just subclass :class:" "`object`.)" msgstr "" -"Esto significa que las declaraciones :keyword:`class` que no tienen ninguna " -"clase base siempre son clases clásicas en Python 2.2. (Realmente también " -"puedes cambiar esto configurando una variable de nivel de módulo llamada :" -"attr:`__metaclass__` --- consultar :pep:`253` para más detalles --- pero es " -"más fácil solo subclasificar :class:`object`.)" +"Esto significa que las instrucciones :keyword:`class` que no tienen ninguna " +"clase base siempre son clases clásicas en Python 2.2. (En realidad, también " +"puede cambiar esto configurando una variable a nivel de módulo llamada :attr:" +"`!__metaclass__` --- consulte :pep:`253` para obtener más detalles --- pero " +"es más fácil simplemente subclasificar :class:`object`)." #: ../Doc/whatsnew/2.2.rst:126 msgid "" @@ -303,17 +304,21 @@ msgid "" ">>> int('123')\n" "123" msgstr "" +">>> int\n" +"\n" +">>> int('123')\n" +"123" #: ../Doc/whatsnew/2.2.rst:136 -#, fuzzy msgid "" "To make the set of types complete, new type objects such as :func:`dict` " "and :func:`!file` have been added. Here's a more interesting example, " "adding a :meth:`!lock` method to file objects::" msgstr "" -"Para completar el conjunto de tipos, se agregaron nuevos objetos de tipo " -"como :func:`dict` y :func:`file`. Aquí hay un ejemplo más interesante, " -"agregando un método :meth:`lock` a los objetos de archivo::" +"Para completar el conjunto de tipos, se han añadido nuevos objetos de tipo, " +"como :func:`dict` y :func:`!file`. A continuación, se muestra un ejemplo más " +"interesante, en el que se añade un método :meth:`!lock` a los objetos de " +"archivo:" #: ../Doc/whatsnew/2.2.rst:140 msgid "" @@ -323,27 +328,30 @@ msgid "" " return fcntl.lockf(self.fileno(), operation,\n" " length, start, whence)" msgstr "" +"clase LockableFile(archivo):\n" +"def lock (self, operación, longitud=0, inicio=0, origen=0):\n" +"import fcntl\n" +"return fcntl.lockf(self.fileno(), operación,\n" +"longitud, inicio, origen)" #: ../Doc/whatsnew/2.2.rst:146 -#, fuzzy msgid "" "The now-obsolete :mod:`!posixfile` module contained a class that emulated " "all of a file object's methods and also added a :meth:`!lock` method, but " "this class couldn't be passed to internal functions that expected a built-in " "file, something which is possible with our new :class:`!LockableFile`." msgstr "" -"El módulo ahora obsoleto :mod:`posixfile` contenía una clase que emulaba " +"El módulo :mod:`!posixfile`, ahora obsoleto, contenía una clase que emulaba " "todos los métodos de un objeto de archivo y también agregaba un método :meth:" -"`lock`, pero esta clase no podía pasarse a funciones internas que esperaban " -"un archivo incorporado, algo que es posible con nuestra nueva clase :class:" -"`LockableFile`." +"`!lock`, pero esta clase no podía pasarse a funciones internas que esperaban " +"un archivo integrado, algo que es posible con nuestro nuevo :class:`!" +"LockableFile`." #: ../Doc/whatsnew/2.2.rst:153 msgid "Descriptors" msgstr "Descriptores" #: ../Doc/whatsnew/2.2.rst:155 -#, fuzzy msgid "" "In previous versions of Python, there was no consistent way to discover what " "attributes and methods were supported by an object. There were some informal " @@ -355,13 +363,13 @@ msgid "" "still be inaccurate." msgstr "" "En versiones anteriores de Python, no había una forma consistente de " -"descubrir qué atributos y métodos eran compatibles con un objeto. Había " -"algunas convenciones informales, como definir atributos :attr:`__members__` " -"y :attr:`__methods__` que eran listas de nombres, pero a menudo el autor de " -"un tipo de extensión o una clase no se molestaría en definirlos. Podrías " -"recurrir a inspeccionar el :attr:`~object.__dict__` de un objeto, pero " -"cuando la herencia de una clase o un gancho arbitrario :meth:`__getattr__` " -"estuvieran en uso, esto podría ser inexacto." +"descubrir qué atributos y métodos eran compatibles con un objeto. Existían " +"algunas convenciones informales, como definir los atributos :attr:`!" +"__members__` y :attr:`!__methods__` que eran listas de nombres, pero a " +"menudo el autor de un tipo de extensión o una clase no se molestaba en " +"definirlos. Se podía recurrir a inspeccionar el :attr:`~object.__dict__` de " +"un objeto, pero cuando se utilizaba la herencia de clase o un gancho :meth:`!" +"__getattr__` arbitrario, esto podía seguir siendo inexacto." #: ../Doc/whatsnew/2.2.rst:163 msgid "" @@ -391,9 +399,8 @@ msgid ":attr:`~definition.__name__` is the attribute's name." msgstr ":attr:`~definition.__name__` es el nombre del atributo." #: ../Doc/whatsnew/2.2.rst:174 -#, fuzzy msgid ":attr:`~definition.__doc__` is the attribute's docstring." -msgstr ":attr:`__doc__` es el docstring del atributo." +msgstr ":attr:`~definition.__doc__` es el docstring del atributo." #: ../Doc/whatsnew/2.2.rst:176 msgid "" @@ -426,9 +433,10 @@ msgid "" "descriptor = obj.__class__.x\n" "descriptor.__get__(obj)" msgstr "" +"descriptor = obj.__class__.x\n" +"descriptor.__get__(obj)" #: ../Doc/whatsnew/2.2.rst:189 -#, fuzzy msgid "" "For methods, :meth:`descriptor.__get__ ` returns a temporary " "object that's callable, and wraps up the instance and the method to be " @@ -439,14 +447,15 @@ msgid "" "functions. Class methods are passed the class of the object, but not the " "object itself. Static and class methods are defined like this::" msgstr "" -"Para los métodos, :meth:`descriptor.__get__` retorna un objeto temporal que " -"se puede llamar y contiene la instancia y el método que se llamará en él. " -"También esto es el por qué los métodos estáticos y de clase ahora son " -"posibles; tienen descriptores que contienen solo el método o el método y la " -"clase. Como una breve explicación de estos tipos nuevos de métodos, los " -"métodos estáticos no se pasan a la instancia y, por lo tanto, se asemejan a " -"funciones regulares. Los métodos de clase se pasan a la clase del objeto, " -"pero no al objeto en sí. Los métodos estáticos y de clase se definen así::" +"Para los métodos, :meth:`descriptor.__get__ ` devuelve un " +"objeto temporal que se puede llamar y envuelve la instancia y el método que " +"se llamará en él. Esta es también la razón por la que ahora son posibles los " +"métodos estáticos y los métodos de clase; tienen descriptores que envuelven " +"solo el método, o el método y la clase. Como breve explicación de estos " +"nuevos tipos de métodos, los métodos estáticos no se pasan a la instancia y, " +"por lo tanto, se parecen a las funciones normales. A los métodos de clase se " +"les pasa la clase del objeto, pero no el objeto en sí. Los métodos estáticos " +"y de clase se definen de la siguiente manera:" #: ../Doc/whatsnew/2.2.rst:199 msgid "" @@ -459,9 +468,16 @@ msgid "" " ...\n" " g = classmethod(g)" msgstr "" +"clase C(objeto):\n" +"def f(arg1, arg2):\n" +"...\n" +"f = método estático(f)\n" +"\n" +"def g(cls, arg1, arg2):\n" +"...\n" +"g = método de clase(g)" #: ../Doc/whatsnew/2.2.rst:208 -#, fuzzy msgid "" "The :func:`staticmethod` function takes the function :func:`!f`, and returns " "it wrapped up in a descriptor so it can be stored in the class object. You " @@ -469,11 +485,12 @@ msgid "" "static f``, ``defstatic f()``, or something like that) but no such syntax " "has been defined yet; that's been left for future versions of Python." msgstr "" -"La función :func:`staticmethod` toma la función :func:`f` y la retorna en un " -"descriptor para que pueda almacenarse en el objeto de clase. Puedes esperar " -"que haya una sintaxis especial para crear tales métodos (``def static f``, " -"``defstatic f()`` o algo así) pero aún no se ha definido dicha sintaxis; que " -"se ha dejado para versiones futuras de Python." +"La función :func:`staticmethod` toma la función :func:`!f` y la devuelve " +"envuelta en un descriptor para que pueda almacenarse en el objeto de clase. " +"Se podría esperar que existiera una sintaxis especial para crear dichos " +"métodos (``def static f``, ``defstatic f()`` o algo similar), pero aún no se " +"ha definido dicha sintaxis; eso se ha dejado para futuras versiones de " +"Python." #: ../Doc/whatsnew/2.2.rst:214 msgid "" @@ -508,9 +525,22 @@ msgid "" "\n" " f = eiffelmethod(f, pre_f, post_f)" msgstr "" +"from eiffel import eiffelmethod\n" +"\n" +"class C(object):\n" +"def f(self, arg1, arg2):\n" +"# La función actual\n" +"...\n" +"def pre_f(self):\n" +"# Verificar condiciones previas\n" +"...\n" +"def post_f(self):\n" +"# Verificar condiciones posteriores\n" +"...\n" +"\n" +"f = eiffelmethod(f, pre_f, post_f)" #: ../Doc/whatsnew/2.2.rst:236 -#, fuzzy msgid "" "Note that a person using the new :func:`!eiffelmethod` doesn't have to " "understand anything about descriptors. This is why I think the new features " @@ -519,13 +549,13 @@ msgid "" "the ZODB or whatever, but most users will just write code on top of the " "resulting libraries and ignore the implementation details." msgstr "" -"Toma en cuenta que una persona que usa la nueva función :func:`eiffelmethod` " -"no tiene que entender nada sobre descriptores. Esta es la razón por la que " -"creo que las nuevas características no incrementan la complejidad básica del " -"lenguaje. Habrá algunos asistentes que necesitarán conocerlo para escribir :" -"func:`eiffelmethod` o la ZODB o lo que sea, pero la mayoría de los usuarios " -"solo escribirán código sobre las bibliotecas resultantes e ignorarán los " -"detalles de implementación." +"Tenga en cuenta que una persona que utilice el nuevo :func:`!eiffelmethod` " +"no tiene por qué entender nada sobre descriptores. Por eso creo que las " +"nuevas características no aumentan la complejidad básica del lenguaje. Habrá " +"algunos expertos que necesitarán saber sobre él para escribir :func:`!" +"eiffelmethod` o ZODB o lo que sea, pero la mayoría de los usuarios " +"simplemente escribirán código sobre las bibliotecas resultantes e ignorarán " +"los detalles de implementación." #: ../Doc/whatsnew/2.2.rst:245 msgid "Multiple Inheritance: The Diamond Rule" @@ -557,9 +587,21 @@ msgid "" " \\ /\n" " class D" msgstr "" +"clase A:\n" +"^ ^ def save(self): ...\n" +"/ \\\n" +"/ \\\n" +"/ \\\n" +"/ \\\n" +"clase B clase C:\n" +"^ ^ def save(self): ...\n" +"\\ /\n" +"\\ /\n" +"\\ /\n" +"\\ /\n" +"clase D" #: ../Doc/whatsnew/2.2.rst:265 -#, fuzzy msgid "" "The lookup rule for classic classes is simple but not very smart; the base " "classes are searched depth-first, going from left to right. A reference to :" @@ -569,14 +611,13 @@ msgid "" "meth:`!save` method is saving some internal state specific to :class:`!C`, " "not calling it will result in that state never getting saved." msgstr "" -"La regla de búsqueda para clases clásicas es simple pero no muy inteligente; " -"se buscan las clases base primero en profundidad, yendo de izquierda a " -"derecha. Una referencia a :meth:`D.save` buscará las clases :class:`D`, :" -"class:`B` y luego :class:`A`, donde :meth:`save` se encontraría y " -"retornaría. :meth:`C.save` nunca se encontraría en absoluto. Esto es malo, " -"porque si el método :meth:`save` de :class:`C` está guardando algún estado " -"interno específico de :class:`C`, no llamarlo resultará en que este estado " -"nunca se guardará." +"La regla de búsqueda para las clases clásicas es simple pero no muy " +"inteligente; las clases base se buscan primero en profundidad, de izquierda " +"a derecha. Una referencia a :meth:`!D.save` buscará las clases :class:`!D`, :" +"class:`!B` y luego :class:`!A`, donde se encontraría y devolvería :meth:`!" +"save`. :meth:`!C.save` nunca se encontraría. Esto es malo, porque si el " +"método :meth:`!save` de :class:`!C` está guardando algún estado interno " +"específico de :class:`!C`, no llamarlo hará que ese estado nunca se guarde." #: ../Doc/whatsnew/2.2.rst:273 msgid "" @@ -593,33 +634,30 @@ msgstr "" "para gráficos de herencia realmente complicados.)" #: ../Doc/whatsnew/2.2.rst:278 -#, fuzzy msgid "" "List all the base classes, following the classic lookup rule and include a " "class multiple times if it's visited repeatedly. In the above example, the " "list of visited classes is [:class:`!D`, :class:`!B`, :class:`!A`, :class:`!" "C`, :class:`!A`]." msgstr "" -"Enumera todas las clases base, siguiendo la regla de búsqueda clásica e " -"incluye una clase varias veces si se visita repetidamente. En el ejemplo " -"anterior, la lista de clases visitadas es [:class:`D`, :class:`B`, :class:" -"`A`, :class:`C`, :class:`A`]." +"Enumere todas las clases base siguiendo la regla de búsqueda clásica e " +"incluya una clase varias veces si se la visita repetidamente. En el ejemplo " +"anterior, la lista de clases visitadas es [:class:`!D`, :class:`!B`, :class:" +"`!A`, :class:`!C`, :class:`!A`]." #: ../Doc/whatsnew/2.2.rst:283 -#, fuzzy msgid "" "Scan the list for duplicated classes. If any are found, remove all but one " "occurrence, leaving the *last* one in the list. In the above example, the " "list becomes [:class:`!D`, :class:`!B`, :class:`!C`, :class:`!A`] after " "dropping duplicates." msgstr "" -"Escanea la lista en busca de clases duplicadas. Si encuentra alguna, elimina " -"todas menos una, dejando la *última* en la lista. En el ejemplo anterior, la " -"lista se convierte en [:class:`D`, :class:`B`, :class:`C`, :class:`A`] " -"después de eliminar las duplicadas." +"Examine la lista en busca de clases duplicadas. Si encuentra alguna, elimine " +"todas las instancias excepto una y deje la *last* en la lista. En el ejemplo " +"anterior, la lista se convierte en [:class:`!D`, :class:`!B`, :class:`!C`, :" +"class:`!A`] después de eliminar los duplicados." #: ../Doc/whatsnew/2.2.rst:288 -#, fuzzy msgid "" "Following this rule, referring to :meth:`!D.save` will return :meth:`!C." "save`, which is the behaviour we're after. This lookup rule is the same as " @@ -631,15 +669,15 @@ msgid "" "the superclass; for example, :class:`!D`'s :meth:`!save` method would look " "like this::" msgstr "" -"Siguiendo esta regla, refiriéndose a :meth:`D.save` retornará :meth:`C." -"save`, el cual es el comportamiento que buscamos. Esta regla de búsqueda es " -"la misma que sigue Common Lisp. Una nueva función incorporada, :func:" -"`super`, proporciona una forma de acceder a las superclases de una clase sin " -"tener que volver a implementar el algoritmo de Python. La forma más " -"utilizada será ``super(class, obj)``, la cual retorna un objeto de " -"superclase vinculado. Esta forma se usará en métodos para llamar a un método " -"en la superclase; por ejemplo, el método :meth:`save` de :class:`D` se vería " -"así::" +"Siguiendo esta regla, al hacer referencia a :meth:`!D.save` se devolverá :" +"meth:`!C.save`, que es el comportamiento que buscamos. Esta regla de " +"búsqueda es la misma que sigue Common Lisp. Una nueva función incorporada, :" +"func:`super`, proporciona una forma de acceder a las superclases de una " +"clase sin tener que volver a implementar el algoritmo de Python. La forma " +"más utilizada será ``super(class, obj)``, que devuelve un objeto de " +"superclase enlazado (no el objeto de clase real). Esta forma se utilizará en " +"métodos para llamar a un método en la superclase; por ejemplo, el método :" +"meth:`!save` de :class:`!D` se vería así:" #: ../Doc/whatsnew/2.2.rst:297 msgid "" @@ -650,6 +688,12 @@ msgid "" " # Save D's private information here\n" " ..." msgstr "" +"clase D (B,C):\n" +"def save (self):\n" +"# Llamar a la superclase .save()\n" +"super(D, self).save()\n" +"# Guardar la información privada de D aquí\n" +"..." #: ../Doc/whatsnew/2.2.rst:304 msgid "" @@ -666,7 +710,6 @@ msgid "Attribute Access" msgstr "Acceso a atributos" #: ../Doc/whatsnew/2.2.rst:312 -#, fuzzy msgid "" "A fair number of sophisticated Python classes define hooks for attribute " "access using :meth:`~object.__getattr__`; most commonly this is done for " @@ -674,12 +717,12 @@ msgid "" "attribute access such as ``obj.parent`` into a method call such as ``obj." "get_parent``. Python 2.2 adds some new ways of controlling attribute access." msgstr "" -"Un buen número de clases sofisticadas de Python definen ganchos para el " -"acceso de atributos usando :meth:`__getattr__`; más comúnmente, esto se hace " -"por conveniencia, para hacer que el código sea más legible al mapear " -"automáticamente un acceso de atributo como ``obj.parent`` en una llamada de " +"Una buena cantidad de clases sofisticadas de Python definen ganchos para el " +"acceso a atributos mediante :meth:`~object.__getattr__`; lo más común es que " +"esto se haga por conveniencia, para que el código sea más legible al asignar " +"automáticamente un acceso a atributos como ``obj.parent`` a una llamada de " "método como ``obj.get_parent``. Python 2.2 agrega algunas formas nuevas de " -"controlar el acceso de atributos." +"controlar el acceso a atributos." #: ../Doc/whatsnew/2.2.rst:318 msgid "" @@ -694,7 +737,6 @@ msgstr "" "``foo`` en el diccionario de la instancia." #: ../Doc/whatsnew/2.2.rst:323 -#, fuzzy msgid "" "New-style classes also support a new method, " "``__getattribute__(attr_name)``. The difference between the two methods is " @@ -704,12 +746,11 @@ msgid "" msgstr "" "Las clases de nuevo estilo también admiten un nuevo método, " "``__getattribute__(attr_name)``. La diferencia entre los dos métodos es que :" -"meth:`__getattribute__` *siempre* se llama cada vez que se accede a " -"cualquier atributo, mientras que el antiguo :meth:`__getattr__` se llama " -"solo si no se encuentra ``foo`` en el diccionario de la instancia." +"meth:`~object.__getattribute__` se llama *always* siempre que se accede a un " +"atributo, mientras que el antiguo :meth:`~object.__getattr__` solo se llama " +"si ``foo`` no se encuentra en el diccionario de la instancia." #: ../Doc/whatsnew/2.2.rst:329 -#, fuzzy msgid "" "However, Python 2.2's support for :dfn:`properties` will often be a simpler " "way to trap attribute references. Writing a :meth:`!__getattr__` method is " @@ -722,28 +763,27 @@ msgid "" "in a sizable performance loss." msgstr "" "Sin embargo, el soporte de Python 2.2 para :dfn:`properties` será a menudo " -"una forma más simple de atrapar referencias de atributos. Escribir un " -"método :meth:`__getattr__` es complicado porque para evitar la recursividad " -"no puedes usar accesos regulares a atributos dentro de ellos, y en su lugar " -"tienes que jugar con el contenido de :attr:`~object.__dict__`. Los métodos :" -"meth:`__getattr__` también terminan siendo llamados por Python cuando busca " -"otros métodos como :meth:`__repr__` o :meth:`__coerce__`, por lo que se " -"tienen que escribirse teniendo esto en cuenta. Finalmente, llamar una " -"función en cada acceso de atributo resulta en una pérdida de rendimiento " -"considerable." +"una forma más sencilla de atrapar referencias de atributos. Escribir un " +"método :meth:`!__getattr__` es complicado porque para evitar la recursión no " +"se pueden utilizar accesos a atributos regulares dentro de ellos, y en su " +"lugar hay que jugar con el contenido de :attr:`~object.__dict__`. Los " +"métodos :meth:`~object.__getattr__` también terminan siendo llamados por " +"Python cuando comprueba otros métodos como :meth:`~object.__repr__` o :meth:" +"`!__coerce__`, y por lo tanto tienen que ser escritos con esto en mente. " +"Finalmente, llamar a una función en cada acceso a un atributo da como " +"resultado una pérdida de rendimiento considerable." #: ../Doc/whatsnew/2.2.rst:338 -#, fuzzy msgid "" ":class:`property` is a new built-in type that packages up three functions " "that get, set, or delete an attribute, and a docstring. For example, if you " "want to define a :attr:`!size` attribute that's computed, but also settable, " "you could write::" msgstr "" -":class:`property` es un nuevo tipo integrado que empaqueta tres funciones " -"obtienen, establecen o eliminan un atributo y una docstring. Por ejemplo, si " -"quieres definir un atributo :attr:`size` que se calcula, pero que también se " -"puede configurar, puedes escribir::" +":class:`property` es un nuevo tipo integrado que incluye tres funciones que " +"obtienen, establecen o eliminan un atributo y una cadena de documentación. " +"Por ejemplo, si desea definir un atributo :attr:`!size` que se calcule, pero " +"que también se pueda configurar, puede escribir:" #: ../Doc/whatsnew/2.2.rst:343 msgid "" @@ -762,9 +802,22 @@ msgid "" " None,\n" " \"Storage size of this instance\")" msgstr "" +"clase C(objeto):\n" +"def get_size (self):\n" +"result = ... computation ...\n" +"return result\n" +"def set_size (self, size):\n" +"... calcula algo en función del tamaño\n" +"y establece el estado interno de forma adecuada ...\n" +"\n" +"# Define una propiedad. El método 'eliminar este atributo'\n" +"# se define como None, por lo que el atributo\n" +"# no se puede eliminar.\n" +"size = property(get_size, set_size,\n" +"None,\n" +"\"Tamaño de almacenamiento de esta instancia\")" #: ../Doc/whatsnew/2.2.rst:358 -#, fuzzy msgid "" "That is certainly clearer and easier to write than a pair of :meth:`!" "__getattr__`/:meth:`!__setattr__` methods that check for the :attr:`!size` " @@ -773,12 +826,13 @@ msgid "" "the only ones which have to perform the work of calling a function, so " "references to other attributes run at their usual speed." msgstr "" -"Eso es ciertamente más claro y fácil de escribir que un par de métodos :meth:" -"`__getattr__`/:meth:`__setattr__` que verifican el atributo :attr:`size` y " -"lo manejan especialmente mientras recuperan todos los demás atributos :attr:" -"`~object.__dict__` de la instancia. Los accesos a :attr:`size` también son " -"los únicos que tienen que realizar el trabajo de llamar a una función, por " -"lo que las referencias a otros atributos se ejecutan a su velocidad habitual." +"Sin duda, esto es más claro y más fácil de escribir que un par de métodos :" +"meth:`!__getattr__`/:meth:`!__setattr__` que comprueban el atributo :attr:`!" +"size` y lo gestionan de forma especial mientras recuperan todos los demás " +"atributos del :attr:`~object.__dict__` de la instancia. Los accesos a :attr:" +"`!size` también son los únicos que tienen que realizar el trabajo de llamar " +"a una función, por lo que las referencias a otros atributos se ejecutan a su " +"velocidad habitual." #: ../Doc/whatsnew/2.2.rst:365 msgid "" @@ -815,6 +869,19 @@ msgid "" " File \"\", line 1, in ?\n" "AttributeError: 'C' object has no attribute 'newattr'" msgstr "" +">>> class C(object):\n" +"... __slots__ = ('template', 'name')\n" +"...\n" +">>> obj = C()\n" +">>> print obj.template\n" +"None\n" +">>> obj.template = 'Test'\n" +">>> print obj.template\n" +"Test\n" +">>> obj.newattr = None\n" +"Traceback (última llamada más reciente):\n" +"Archivo \"\", línea 1, en ?\n" +"AttributeError: el objeto 'C' no tiene el atributo 'newattr'" #: ../Doc/whatsnew/2.2.rst:386 msgid "" @@ -841,18 +908,17 @@ msgstr "" "deberías ir para obtener una imagen más completa?" #: ../Doc/whatsnew/2.2.rst:399 -#, fuzzy msgid "" "The :ref:`descriptorhowto` is a lengthy tutorial introduction to the " "descriptor features, written by Guido van Rossum. If my description has " "whetted your appetite, go read this tutorial next, because it goes into much " "more detail about the new features while still remaining quite easy to read." msgstr "" -"https://docs.python.org/dev/howto/descriptor.html es un extenso tutorial de " -"introducción a las características del descriptor, escrito por Guido van " -"Rossum. Si mi descripción te despertó el apetito, lee este tutorial a " -"continuación, porque entra en mucho más detalle sobre las nuevas " -"características sin dejar de ser bastante fácil de leer." +":ref:`descriptorhowto` es una introducción extensa y tutorial a las " +"características del descriptor, escrita por Guido van Rossum. Si mi " +"descripción le ha abierto el apetito, lea este tutorial a continuación, " +"porque brinda mucho más detalle sobre las nuevas características y sigue " +"siendo bastante fácil de leer." #: ../Doc/whatsnew/2.2.rst:404 msgid "" @@ -903,24 +969,24 @@ msgstr "" "ser iterados por quienes los llaman." #: ../Doc/whatsnew/2.2.rst:427 -#, fuzzy msgid "" "In Python versions up to 2.1, the usual way to make ``for item in obj`` work " "is to define a :meth:`~object.__getitem__` method that looks something like " "this::" msgstr "" "En las versiones de Python hasta la 2.1, la forma habitual de hacer que " -"funcione ``for item in obj`` es definir un método :meth:`__getitem__` que se " -"parezca a esto::" +"funcione ``for item in obj`` es definir un método :meth:`~object." +"__getitem__` que se parezca a esto::" #: ../Doc/whatsnew/2.2.rst:430 msgid "" "def __getitem__(self, index):\n" " return " msgstr "" +"def __getitem__(self, index):\n" +"return " #: ../Doc/whatsnew/2.2.rst:433 -#, fuzzy msgid "" ":meth:`~object.__getitem__` is more properly used to define an indexing " "operation on an object so that you can write ``obj[5]`` to retrieve the " @@ -933,19 +999,19 @@ msgid "" "using ``file[5]`` to randomly access the sixth element will work, though it " "really should." msgstr "" -":meth:`__getitem__` se utiliza más adecuadamente para definir una operación " -"de indexación en un objeto, de modo que se puede escribir ``obj[5]`` para " -"recuperar el sexto elemento. Es un poco engañoso cuando se utiliza esto " -"sólo para soportar bucles :keyword:`for`. Considere algún objeto tipo " -"archivo que quiera ser revisado en bucle; el parámetro *index* no tiene " -"sentido, ya que la clase probablemente asume que se hará una serie de " -"llamadas a :meth:`__getitem__` con *index* incrementándose en uno cada vez. " -"En otras palabras, la presencia del método :meth:`__getitem__` no significa " -"que el uso de ``file[5]`` para acceder al azar al sexto elemento vaya a " -"funcionar, aunque realmente debería hacerlo." +":meth:`~object.__getitem__` se utiliza de forma más adecuada para definir " +"una operación de indexación en un objeto, de modo que pueda escribir " +"``obj[5]`` para recuperar el sexto elemento. Es un poco engañoso cuando se " +"utiliza esto solo para admitir bucles :keyword:`for`. Considere un objeto " +"similar a un archivo que desea ser recorrido en bucle; el parámetro *index* " +"esencialmente no tiene sentido, ya que la clase probablemente asume que se " +"realizará una serie de llamadas :meth:`~object.__getitem__` con *index* " +"incrementándose en uno cada vez. En otras palabras, la presencia del método :" +"meth:`~object.__getitem__` no significa que el uso de ``file[5]`` para " +"acceder aleatoriamente al sexto elemento funcionará, aunque realmente " +"debería funcionar." #: ../Doc/whatsnew/2.2.rst:443 -#, fuzzy msgid "" "In Python 2.2, iteration can be implemented separately, and :meth:`~object." "__getitem__` methods can be limited to classes that really do support random " @@ -955,17 +1021,16 @@ msgid "" "sentinel)`` returns an iterator that will invoke the callable object *C* " "until it returns *sentinel* to signal that the iterator is done." msgstr "" -"En Python 2.2, la iteración puede implementarse por separado, y los métodos :" -"meth:`__getitem__` pueden limitarse a las clases que realmente soportan el " -"acceso aleatorio. La idea básica de los iteradores es simple. Una nueva " -"función incorporada, ``iter(obj)`` o ``iter(C, sentinel)``, se utiliza para " -"obtener un iterador. ``iter(obj)`` retorna un iterador para el objeto *obj*, " -"mientras que ``iter(C, sentinel)`` retorna un iterador que invocará al " -"objeto invocable *C* hasta que retorne *sentinel* para señalar que el " -"iterador ha terminado." +"En Python 2.2, la iteración se puede implementar por separado y los métodos :" +"meth:`~object.__getitem__` se pueden limitar a las clases que realmente " +"admiten el acceso aleatorio. La idea básica de los iteradores es simple. Se " +"utiliza una nueva función incorporada, ``iter(obj)`` o ``iter(C, " +"sentinel)``, para obtener un iterador. ``iter(obj)`` devuelve un iterador " +"para el objeto *obj*, mientras que ``iter(C, sentinel)`` devuelve un " +"iterador que invocará el objeto invocable *C* hasta que devuelva *sentinel* " +"para indicar que el iterador ha finalizado." #: ../Doc/whatsnew/2.2.rst:451 -#, fuzzy msgid "" "Python classes can define an :meth:`!__iter__` method, which should create " "and return a new iterator for the object; if the object is its own iterator, " @@ -975,13 +1040,13 @@ msgid "" "extension types that want to behave as iterators can define a :c:member:" "`~PyTypeObject.tp_iternext` function." msgstr "" -"Las clases de Python pueden definir un método :meth:`__iter__`, que debe " -"crear y retornar un nuevo iterador para el objeto; si el objeto es su propio " -"iterador, este método puede simplemente retornar ``self``. En particular, " -"los iteradores suelen ser sus propios iteradores. Los tipos de extensión " -"implementados en C pueden implementar una función :c:member:`~PyTypeObject." -"tp_iter` para retornar un iterador, y los tipos de extensión que quieran " -"comportarse como iteradores pueden definir una función :c:member:" +"Las clases de Python pueden definir un método :meth:`!__iter__`, que debe " +"crear y devolver un nuevo iterador para el objeto; si el objeto es su propio " +"iterador, este método puede devolver simplemente ``self``. En particular, " +"los iteradores normalmente serán sus propios iteradores. Los tipos de " +"extensión implementados en C pueden implementar una función :c:member:" +"`~PyTypeObject.tp_iter` para devolver un iterador, y los tipos de extensión " +"que quieran comportarse como iteradores pueden definir una función :c:member:" "`~PyTypeObject.tp_iternext`." #: ../Doc/whatsnew/2.2.rst:458 @@ -1014,9 +1079,23 @@ msgid "" "StopIteration\n" ">>>" msgstr "" +">>> L = [1,2,3]\n" +">>> i = iter(L)\n" +">>> print i\n" +"\n" +">>> i.next()\n" +"1\n" +">>> i.next()\n" +"2\n" +">>> i.next()\n" +"3\n" +">>> i.next()\n" +"Traceback (última llamada más reciente):\n" +"Archivo \"\", línea 1, en ?\n" +"StopIteration\n" +">>>" #: ../Doc/whatsnew/2.2.rst:479 -#, fuzzy msgid "" "In 2.2, Python's :keyword:`for` statement no longer expects a sequence; it " "expects something for which :func:`iter` will return an iterator. For " @@ -1027,14 +1106,14 @@ msgid "" "changed to use the iterator protocol. This means you can do things like " "this::" msgstr "" -"En 2.2, la sentencia :keyword:`for` de Python ya no espera una secuencia; " -"espera algo para lo que :func:`iter` retornará un iterador. Por " -"compatibilidad y comodidad, se construye automáticamente un iterador para " -"las secuencias que no implementan :meth:`__iter__` o una ranura :c:member:" -"`~PyTypeObject.tp_iter`, por lo que ``for i in [1,2,3]`` seguirá " -"funcionando. Dondequiera que el intérprete de Python haga un bucle sobre " -"una secuencia, se ha cambiado para utilizar el protocolo de los iteradores. " -"Esto significa que puedes hacer cosas como esta::" +"En la versión 2.2, la declaración :keyword:`for` de Python ya no espera una " +"secuencia, sino algo para lo que :func:`iter` devolverá un iterador. Para " +"mayor comodidad y compatibilidad con versiones anteriores, se construye " +"automáticamente un iterador para las secuencias que no implementan :meth:`!" +"__iter__` o una ranura :c:member:`~PyTypeObject.tp_iter`, por lo que ``for i " +"in [1,2,3]`` seguirá funcionando. Siempre que el intérprete de Python " +"recorra una secuencia, se ha modificado para utilizar el protocolo de " +"iterador. Esto significa que puede hacer cosas como esta:" #: ../Doc/whatsnew/2.2.rst:487 msgid "" @@ -1044,6 +1123,11 @@ msgid "" ">>> a,b,c\n" "(1, 2, 3)" msgstr "" +">>> L = [1,2,3]\n" +">>> i = iter(L)\n" +">>> a,b,c = i\n" +">>> a,b,c\n" +"(1, 2, 3)" #: ../Doc/whatsnew/2.2.rst:493 msgid "" @@ -1074,9 +1158,24 @@ msgid "" "Dec 12\n" "Oct 10" msgstr "" +">>> m = {'Ene': 1, 'Feb': 2, 'Mar': 3, 'Abr': 4, 'May': 5, 'Jun': 6,\n" +"... 'Jul': 7, 'Ago': 8, 'Sep': ​​9, 'Oct': 10, 'Nov': 11, 'Dic': 12}\n" +">>> para clave en m: print clave, m[clave]\n" +"...\n" +"3 Mar\n" +"2 Feb\n" +"8 Ago\n" +"9 Sep\n" +"5 May\n" +"6 Jun\n" +"7 Jul\n" +"1 Ene\n" +"4 Abr\n" +"11 Nov\n" +"12 Dic\n" +"10 Oct" #: ../Doc/whatsnew/2.2.rst:513 -#, fuzzy msgid "" "That's just the default behaviour. If you want to iterate over keys, " "values, or key/value pairs, you can explicitly call the :meth:`!iterkeys`, :" @@ -1084,12 +1183,12 @@ msgid "" "iterator. In a minor related change, the :keyword:`in` operator now works on " "dictionaries, so ``key in dict`` is now equivalent to ``dict.has_key(key)``." msgstr "" -"Este es el comportamiento por defecto. Si quieres iterar sobre claves, " -"valores o pares clave/valor, puedes llamar explícitamente a los métodos :" -"meth:`iterkeys`, :meth:`itervalues` o :meth:`iteritems` para obtener un " -"iterador apropiado. En un cambio menor relacionado, el operador :keyword:" -"`in` ahora funciona en los diccionarios, por lo que ``key in dict`` es ahora " -"equivalente a ``dict.has_key(key)``." +"Ese es simplemente el comportamiento predeterminado. Si desea iterar sobre " +"claves, valores o pares clave/valor, puede llamar explícitamente a los " +"métodos :meth:`!iterkeys`, :meth:`!itervalues` o :meth:`!iteritems` para " +"obtener un iterador adecuado. En un cambio menor relacionado, el operador :" +"keyword:`in` ahora funciona en diccionarios, por lo que ``key in dict`` " +"ahora es equivalente a ``dict.has_key(key)``." #: ../Doc/whatsnew/2.2.rst:519 msgid "" @@ -1107,6 +1206,9 @@ msgid "" " # do something for each line\n" " ..." msgstr "" +"para línea en archivo:\n" +"# hacer algo para cada línea\n" +"..." #: ../Doc/whatsnew/2.2.rst:527 msgid "" @@ -1177,6 +1279,9 @@ msgid "" " for i in range(N):\n" " yield i" msgstr "" +"def generate_ints(N):\n" +"para i en rango(N):\n" +"rendimiento i" #: ../Doc/whatsnew/2.2.rst:563 msgid "" @@ -1228,9 +1333,8 @@ msgstr "" "de la interacción entre :keyword:`!yield` y las excepciones)" #: ../Doc/whatsnew/2.2.rst:584 -#, fuzzy msgid "Here's a sample usage of the :func:`!generate_ints` generator::" -msgstr "Este es un ejemplo de uso del generador :func:`generate_ints`::" +msgstr "Este es un ejemplo de uso del generador :func:`!generate_ints`::" #: ../Doc/whatsnew/2.2.rst:586 msgid "" @@ -1249,6 +1353,20 @@ msgid "" " File \"\", line 2, in generate_ints\n" "StopIteration" msgstr "" +">>> gen = generate_ints(3)\n" +">>> gen\n" +"\n" +">>> gen.next()\n" +"0\n" +">>> gen.next()\n" +"1\n" +">>> gen.next()\n" +"2\n" +">>> gen.next()\n" +"Traceback (última llamada más reciente):\n" +"Archivo \"\", línea 1, en ?\n" +"Archivo \"\", línea 2, en generate_ints\n" +"StopIteration" #: ../Doc/whatsnew/2.2.rst:601 msgid "" @@ -1309,6 +1427,14 @@ msgid "" " for x in inorder(t.right):\n" " yield x" msgstr "" +"# Un generador recursivo que genera hojas de árboles en orden.\n" +"def inorder(t):\n" +"if t:\n" +"for x in inorder(t.left):\n" +"yield x\n" +"yield t.label\n" +"for x in inorder(t.right):\n" +"yield x" #: ../Doc/whatsnew/2.2.rst:630 msgid "" @@ -1325,7 +1451,6 @@ msgstr "" "un tablero de ajedrez $NxN$ sin visitar ninguna casilla dos veces)." #: ../Doc/whatsnew/2.2.rst:635 -#, fuzzy msgid "" "The idea of generators comes from other programming languages, especially " "Icon (https://www2.cs.arizona.edu/icon/), where the idea of generators is " @@ -1335,20 +1460,21 @@ msgid "" "of what this looks like::" msgstr "" "La idea de los generadores proviene de otros lenguajes de programación, " -"especialmente de Icon (https://www.cs.arizona.edu/icon/), donde la idea de " -"los generadores es fundamental. En Icon, cada expresión y llamada a una " -"función se comporta como un generador. Un ejemplo de \"*An Overview of the " -"Icon Programming Language*\" en https://www.cs.arizona.edu/icon/docs/ipd266." -"htm da una idea de cómo es esto::" +"especialmente Icon (https://www2.cs.arizona.edu/icon/), donde la idea de los " +"generadores es central. En Icon, cada expresión y llamada a función se " +"comporta como un generador. Un ejemplo de \"An Overview of the Icon " +"Programming Language\" en https://www2.cs.arizona.edu/icon/docs/ipd266.htm " +"da una idea de cómo se ve esto:" #: ../Doc/whatsnew/2.2.rst:642 msgid "" "sentence := \"Store it in the neighboring harbor\"\n" "if (i := find(\"or\", sentence)) > 5 then write(i)" msgstr "" +"oración := \"Guardarlo en el puerto vecino\"\n" +"si (i := find(\"o\", oración)) > 5 entonces write(i)" #: ../Doc/whatsnew/2.2.rst:645 -#, fuzzy msgid "" "In Icon the :func:`!find` function returns the indexes at which the " "substring \"or\" is found: 3, 23, 33. In the :keyword:`if` statement, ``i`` " @@ -1357,11 +1483,11 @@ msgid "" "5, so the comparison now succeeds, and the code prints the value 23 to the " "screen." msgstr "" -"En Icon la función :func:`find` retorna los índices en los que se encuentra " -"la subcadena \"o\": 3, 23, 33. En la sentencia :keyword:`if`, a ``i`` se le " -"asigna primero un valor de 3, pero 3 es menor que 5, por lo que la " -"comparación falla, e Icon la reintenta con el segundo valor de 23. 23 es " -"mayor que 5, por lo que la comparación ahora tiene éxito, y el código " +"En Icon, la función :func:`!find` devuelve los índices en los que se " +"encuentra la subcadena \"o\": 3, 23, 33. En la declaración :keyword:`if`, a " +"``i`` primero se le asigna un valor de 3, pero 3 es menor que 5, por lo que " +"la comparación falla y Icon la vuelve a intentar con el segundo valor de 23. " +"23 es mayor que 5, por lo que la comparación ahora tiene éxito y el código " "imprime el valor 23 en la pantalla." #: ../Doc/whatsnew/2.2.rst:651 @@ -1402,7 +1528,6 @@ msgid "PEP 237: Unifying Long Integers and Integers" msgstr "PEP 237: Unificación de enteros largos y enteros" #: ../Doc/whatsnew/2.2.rst:672 -#, fuzzy msgid "" "In recent versions, the distinction between regular integers, which are 32-" "bit values on most machines, and long integers, which can be of arbitrary " @@ -1414,16 +1539,17 @@ msgid "" "be used as a slice index, and ``'abc'[1L:]`` would raise a :exc:`TypeError` " "exception with the message 'slice index must be int'." msgstr "" -"En versiones recientes, la distinción entre enteros regulares, que son " -"valores de 32 bits en la mayoría de las máquinas, y enteros largos, que " -"pueden tener un tamaño arbitrario, se estaba convirtiendo en una molestia. " -"Por ejemplo, en las plataformas que soportan archivos de más de ``2**32`` " -"bytes, el método :meth:`tell` de los objetos archivo tiene que retornar un " -"entero largo. Sin embargo, había varias partes de Python que esperaban " -"números enteros simples y que daban un error si se proporcionaba un número " -"entero largo en su lugar. Por ejemplo, en Python 1.5, sólo podían usarse " -"enteros normales como índice de corte, y ``'abc'[1L:]`` lanzaba una " -"excepción :exc:`TypeError` con el mensaje 'slice index must be int'." +"En versiones recientes, la distinción entre números enteros regulares, que " +"son valores de 32 bits en la mayoría de las máquinas, y números enteros " +"largos, que pueden ser de tamaño arbitrario, se estaba volviendo una " +"molestia. Por ejemplo, en plataformas que admiten archivos de más de bytes " +"que ``2**32``, el método :meth:`!tell` de objetos de archivo tiene que " +"devolver un número entero largo. Sin embargo, había varias partes de Python " +"que esperaban números enteros simples y generarían un error si se " +"proporcionaba un número entero largo en su lugar. Por ejemplo, en Python " +"1.5, solo se podían usar números enteros regulares como índice de segmento, " +"y ``'abc'[1L:]`` generaría una excepción :exc:`TypeError` con el mensaje 'el " +"índice de segmento debe ser int'." #: ../Doc/whatsnew/2.2.rst:682 msgid "" @@ -1450,6 +1576,10 @@ msgid "" ">>> 2 ** 64\n" "18446744073709551616L" msgstr "" +">>> 1234567890123\n" +"1234567890123L\n" +">>> 2 ** 64\n" +"18446744073709551616L" #: ../Doc/whatsnew/2.2.rst:695 msgid "" @@ -1587,17 +1717,17 @@ msgstr "" "`` no cambiará hasta Python 3.0." #: ../Doc/whatsnew/2.2.rst:756 -#, fuzzy msgid "" "Classes can define methods called :meth:`~object.__truediv__` and :meth:" "`~object.__floordiv__` to overload the two division operators. At the C " "level, there are also slots in the :c:type:`PyNumberMethods` structure so " "extension types can define the two operators." msgstr "" -"Las clases pueden definir métodos llamados :meth:`__truediv__` y :meth:" -"`__floordiv__` para sobrecargar los dos operadores de división. En el nivel " -"C, también hay ranuras en la estructura :c:type:`PyNumberMethods` para que " -"los tipos de extensión puedan definir los dos operadores." +"Las clases pueden definir métodos denominados :meth:`~object.__truediv__` y :" +"meth:`~object.__floordiv__` para sobrecargar los dos operadores de división. " +"En el nivel C, también hay espacios en la estructura :c:type:" +"`PyNumberMethods` para que los tipos de extensión puedan definir los dos " +"operadores." #: ../Doc/whatsnew/2.2.rst:761 msgid "" @@ -1650,7 +1780,6 @@ msgstr "" "completamente el soporte de Unicode)" #: ../Doc/whatsnew/2.2.rst:787 -#, fuzzy msgid "" "When built to use UCS-4 (a \"wide Python\"), the interpreter can natively " "handle Unicode characters from U+000000 to U+110000, so the range of legal " @@ -1660,17 +1789,16 @@ msgid "" "exception. This is all described in :pep:`261`, \"Support for 'wide' Unicode " "characters\"; consult it for further details." msgstr "" -"Cuando se compila para usar UCS-4 (un \"Python amplio\"), el intérprete " +"Cuando se crea para utilizar UCS-4 (un \"Python ancho\"), el intérprete " "puede manejar de forma nativa caracteres Unicode desde U+000000 hasta " -"U+110000, por lo que el rango de valores legales para la función :func:" -"`unichr` se expande en consecuencia. Utilizando un intérprete compilado " -"para usar UCS-2 (un \"Python estrecho\"), los valores mayores de 65535 " -"seguirán provocando que :func:`unichr` lance una excepción :exc:" -"`ValueError`. Todo esto se describe en :pep:`261`, \"Soporte para caracteres " -"Unicode 'anchos'\"; consúltelo para más detalles." +"U+110000, por lo que el rango de valores legales para la función :func:`!" +"unichr` se amplía en consecuencia. Si se utiliza un intérprete compilado " +"para utilizar UCS-2 (un \"Python estrecho\"), los valores mayores que 65535 " +"seguirán haciendo que :func:`!unichr` genere una excepción :exc:" +"`ValueError`. Todo esto se describe en :pep:`261`, \"Compatibilidad con " +"caracteres Unicode 'anchos'\"; consúltelo para obtener más detalles." #: ../Doc/whatsnew/2.2.rst:795 -#, fuzzy msgid "" "Another change is simpler to explain. Since their introduction, Unicode " "strings have supported an :meth:`!encode` method to convert the string to a " @@ -1681,12 +1809,12 @@ msgid "" "codec." msgstr "" "Otro cambio es más sencillo de explicar. Desde su introducción, las cadenas " -"Unicode han soportado un método :meth:`encode` para convertir la cadena a " -"una codificación seleccionada como UTF-8 o Latin-1. Un método simétrico " -"``decode([*encoding*])`` ha sido añadido a las cadenas de 8 bits (aunque no " -"a las cadenas Unicode) en 2.2. :meth:`decode` asume que la cadena está en la " -"codificación especificada y la decodifica, retornando lo que sea retornado " -"por el códec." +"Unicode admiten un método :meth:`!encode` para convertir la cadena a una " +"codificación seleccionada, como UTF-8 o Latin-1. En la versión 2.2 se ha " +"añadido un método ``decode([*encoding*])`` simétrico a las cadenas de 8 bits " +"(aunque no a las cadenas Unicode). :meth:`!decode` supone que la cadena está " +"en la codificación especificada y la decodifica, devolviendo lo que devuelva " +"el códec." #: ../Doc/whatsnew/2.2.rst:802 msgid "" @@ -1719,26 +1847,42 @@ msgid "" ">>> \"sheesh\".encode('rot-13')\n" "'furrfu'" msgstr "" +">>> s = \"\"\"Aquí hay un largo fragmento de texto redundante, excesivamente " +"verboso,\n" +"... y repetitivo.\n" +"... \"\"\"\n" +">>> data = s.encode('zlib')\n" +">>> data\n" +"'x\\x9c\\r\\xc9\\xc1\\r\\x80 \\x10\\x04\\xc0?Ul...'\n" +">>> data.decode('zlib')\n" +"'Aquí hay un largo fragmento de texto redundante, excesivamente verboso,\\ny " +"repetitivo.\\n'\n" +">>> print s.encode('uu')\n" +"begin 666 \n" +"M2&5R92!I=F5R8F]S92P*86YD(')E<&5T:71I=F4@=&5X=\"X*\n" +"\n" +"fin\n" +">>> \"caramba\".encode('rot-13')\n" +"'furrfu'" #: ../Doc/whatsnew/2.2.rst:823 -#, fuzzy msgid "" "To convert a class instance to Unicode, a :meth:`!__unicode__` method can be " "defined by a class, analogous to :meth:`!__str__`." msgstr "" "Para convertir una instancia de clase a Unicode, se puede definir un método :" -"meth:`__unicode__` por clase, análogo a :meth:`__str__`." +"meth:`!__unicode__` mediante una clase, análogo a :meth:`!__str__`." #: ../Doc/whatsnew/2.2.rst:826 -#, fuzzy msgid "" ":meth:`!encode`, :meth:`!decode`, and :meth:`!__unicode__` were implemented " "by Marc-André Lemburg. The changes to support using UCS-4 internally were " "implemented by Fredrik Lundh and Martin von Löwis." msgstr "" -":meth:`encode`, :meth:`decode`, y :meth:`__unicode__` fueron implementados " -"por Marc-André Lemburg. Los cambios para soportar el uso de UCS-4 " -"internamente fueron implementados por Fredrik Lundh y Martin von Löwis." +"Marc-André Lemburg implementó :meth:`!encode`, :meth:`!decode` y :meth:`!" +"__unicode__`. Fredrik Lundh y Martin von Löwis implementaron los cambios " +"para admitir el uso interno de UCS-4." #: ../Doc/whatsnew/2.2.rst:833 msgid ":pep:`261` - Support for 'wide' Unicode characters" @@ -1794,9 +1938,14 @@ msgid "" " return g(value-1) + 1\n" " ..." msgstr "" +"def f():\n" +"...\n" +"def g(valor):\n" +"...\n" +"return g(valor-1) + 1\n" +"..." #: ../Doc/whatsnew/2.2.rst:863 -#, fuzzy msgid "" "The function :func:`!g` will always raise a :exc:`NameError` exception, " "because the binding of the name ``g`` isn't in either its local namespace or " @@ -1807,14 +1956,15 @@ msgid "" "find local variables being copied by passing them as the default values of " "arguments. ::" msgstr "" -"La función :func:`g` siempre lanzará una excepción :exc:`NameError`, porque " -"el enlace del nombre ``g`` no está ni en su espacio de nombres local ni en " -"el espacio de nombres a nivel de módulo. Esto no es un gran problema en la " -"práctica (¿con qué frecuencia se definen recursivamente funciones interiores " -"como ésta?), pero esto también hacía más torpe el uso de la expresión :" -"keyword:`lambda`, y esto era un problema en la práctica. En el código que " -"utiliza :keyword:`!lambda` a menudo se pueden encontrar variables locales " -"que se copian al pasarlas como valores por defecto de los argumentos. ::" +"La función :func:`!g` siempre generará una excepción :exc:`NameError`, " +"porque la vinculación del nombre ``g`` no está en su espacio de nombres " +"local ni en el espacio de nombres a nivel de módulo. Esto no es un gran " +"problema en la práctica (¿con qué frecuencia se definen recursivamente " +"funciones internas como esta?), pero esto también hizo que el uso de la " +"expresión :keyword:`lambda` fuera más complicado, y esto fue un problema en " +"la práctica. En el código que usa :keyword:`!lambda`, a menudo se pueden " +"encontrar variables locales que se copian al pasarlas como valores " +"predeterminados de los argumentos. ::" #: ../Doc/whatsnew/2.2.rst:871 msgid "" @@ -1824,6 +1974,11 @@ msgid "" " self.list_attribute)\n" " return L" msgstr "" +"def find(self, name):\n" +"\"Devuelve una lista de todas las entradas iguales a 'name'\"\n" +"L = filter(lambda x, name=name: x == name,\n" +"self.list_attribute)\n" +"return L" #: ../Doc/whatsnew/2.2.rst:877 msgid "" @@ -1912,17 +2067,22 @@ msgid "" " def g():\n" " return x" msgstr "" +"x = 1\n" +"def f():\n" +"# La siguiente línea es un error de sintaxis\n" +"exec 'x=2'\n" +"def g():\n" +"return x" #: ../Doc/whatsnew/2.2.rst:917 -#, fuzzy msgid "" "Line 4 containing the ``exec`` statement is a syntax error, since ``exec`` " "would define a new local variable named ``x`` whose value should be accessed " "by :func:`!g`." msgstr "" -"La línea 4 que contiene la sentencia ``exec`` es un error de sintaxis, ya " -"que ``exec`` definiría una nueva variable local llamada ``x`` cuyo valor " -"debería ser accedido por :func:`g`." +"La línea 4 que contiene la declaración ``exec`` es un error de sintaxis, ya " +"que ``exec`` definiría una nueva variable local denominada ``x`` a cuyo " +"valor debería acceder :func:`!g`." #: ../Doc/whatsnew/2.2.rst:921 msgid "" @@ -1947,7 +2107,6 @@ msgid "New and Improved Modules" msgstr "Módulos nuevos y mejorados" #: ../Doc/whatsnew/2.2.rst:937 -#, fuzzy msgid "" "The :mod:`xmlrpclib ` module was contributed to the standard " "library by Fredrik Lundh, providing support for writing XML-RPC clients. " @@ -1956,12 +2115,12 @@ msgid "" "from the O'Reilly Network, and then lists the recent headlines for one " "channel::" msgstr "" -"El módulo :mod:`xmlrpclib` fue aportado a la biblioteca estándar por Fredrik " -"Lundh, proporcionando soporte para escribir clientes XML-RPC. XML-RPC es un " -"sencillo protocolo de llamada a procedimientos remotos construido sobre HTTP " -"y XML. Por ejemplo, el siguiente fragmento recupera una lista de canales RSS " -"de la red O'Reilly y, a continuación, muestra los titulares recientes de un " -"canal::" +"El módulo :mod:`xmlrpclib ` fue aportado a la biblioteca " +"estándar por Fredrik Lundh, que proporciona soporte para escribir clientes " +"XML-RPC. XML-RPC es un protocolo simple de llamada a procedimiento remoto " +"creado sobre HTTP y XML. Por ejemplo, el siguiente fragmento recupera una " +"lista de canales RSS de la red O'Reilly y, a continuación, enumera los " +"titulares recientes de un canal:" #: ../Doc/whatsnew/2.2.rst:943 msgid "" @@ -1982,17 +2141,32 @@ msgid "" "# 'description': 'A utility which converts HTML to XSL FO.',\n" "# 'title': 'html2fo 0.3 (Default)'}, ... ]" msgstr "" +"import xmlrpclib\n" +"s = xmlrpclib.Server(\n" +"'http://www.oreillynet.com/meerkat/xml-rpc/server.php')\n" +"channels = s.meerkat.getChannels()\n" +"# channels es una lista de diccionarios, como esta:\n" +"# [{'id': 4, 'title': 'Freshmeat Daily News'}\n" +"# {'id': 190, 'title': '32Bits Online'},\n" +"# {'id': 4549, 'title': '3DGamers'}, ... ]\n" +"\n" +"# Obtener los elementos de un canal\n" +"items = s.meerkat.getItems( {'channel': 4} )\n" +"\n" +"# 'items' es otra lista de diccionarios, como esta:\n" +"# [{'link': 'http://freshmeat.net/releases/52719/',\n" +"# 'description': 'Una utilidad que convierte HTML a XSL FO.',\n" +"# 'title': 'html2fo 0.3 (Predeterminado)'}, ... ]" #: ../Doc/whatsnew/2.2.rst:960 -#, fuzzy msgid "" "The :mod:`SimpleXMLRPCServer ` module makes it easy to create " "straightforward XML-RPC servers. See http://xmlrpc.scripting.com/ for more " "information about XML-RPC." msgstr "" -"El módulo :mod:`SimpleXMLRPCServer` facilita la creación de servidores XML-" -"RPC sencillos. Consulte http://xmlrpc.scripting.com/ para obtener más " -"información sobre XML-RPC." +"El módulo :mod:`SimpleXMLRPCServer ` facilita la creación de " +"servidores XML-RPC sencillos. Consulte http://xmlrpc.scripting.com/ para " +"obtener más información sobre XML-RPC." #: ../Doc/whatsnew/2.2.rst:963 msgid "" @@ -2003,7 +2177,6 @@ msgstr "" "`2104`. (Contribución de Gerhard Häring)" #: ../Doc/whatsnew/2.2.rst:966 -#, fuzzy msgid "" "Several functions that originally returned lengthy tuples now return pseudo-" "sequences that still behave like tuples but also have mnemonic attributes " @@ -2013,12 +2186,13 @@ msgid "" "localtime`, :func:`~time.gmtime`, and :func:`~time.strptime` in the :mod:" "`time` module." msgstr "" -"Varias funciones que originalmente retornaban tuplas largas ahora retornan " -"pseudo-secuencias que siguen comportándose como tuplas pero que también " -"tienen atributos mnemónicos como memberst_mtime o :attr:`tm_year`. Las " -"funciones mejoradas incluyen :func:`stat`, :func:`fstat`, :func:`statvfs` y :" -"func:`fstatvfs` en el módulo :mod:`os`, y :func:`localtime`, :func:`gmtime` " -"y :func:`strptime` en el módulo :mod:`time`." +"Varias funciones que originalmente devolvían tuplas extensas ahora devuelven " +"pseudosecuencias que aún se comportan como tuplas pero que también tienen " +"atributos mnemotécnicos como :attr:`!memberst_mtime` o :attr:`~time." +"struct_time.tm_year`. Las funciones mejoradas incluyen :func:`~os.stat`, :" +"func:`~os.fstat`, :func:`~os.statvfs` y :func:`~os.fstatvfs` en el módulo :" +"mod:`os`, y :func:`~time.localtime`, :func:`~time.gmtime` y :func:`~time." +"strptime` en el módulo :mod:`time`." #: ../Doc/whatsnew/2.2.rst:973 msgid "" @@ -2087,7 +2261,6 @@ msgstr "" "por Guido van Rossum, usando el módulo :mod:`pydoc` de Ka-Ping Yee)" #: ../Doc/whatsnew/2.2.rst:999 -#, fuzzy msgid "" "Various bugfixes and performance improvements have been made to the SRE " "engine underlying the :mod:`re` module. For example, the :func:`re.sub` " @@ -2098,13 +2271,12 @@ msgid "" "Fredrik Lundh. The BIGCHARSET patch was contributed by Martin von Löwis.)" msgstr "" "Se han realizado varias correcciones de errores y mejoras de rendimiento en " -"el motor SRE subyacente al módulo :mod:`re`. Por ejemplo, las funciones :" -"func:`re.sub` y :func:`re.split` han sido reescritas en C. Otro parche " -"contribuido acelera ciertos rangos de caracteres Unicode por un factor de " -"dos, y un nuevo método :meth:`finditer` que retorna un iterador sobre todas " -"las coincidencias no superpuestas en una cadena dada. (El mantenimiento de " -"SRE corre a cargo de Fredrik Lundh. El parche BIGCHARSET fue aportado por " -"Martin von Löwis)" +"el motor SRE subyacente al módulo :mod:`re`. Por ejemplo, las funciones :" +"func:`re.sub` y :func:`re.split` se han reescrito en C. Otro parche aportado " +"acelera ciertos rangos de caracteres Unicode por un factor de dos, y un " +"nuevo método :meth:`~re.finditer` que devuelve un iterador sobre todas las " +"coincidencias no superpuestas en una cadena dada. (SRE es mantenido por " +"Fredrik Lundh. El parche BIGCHARSET fue aportado por Martin von Löwis)." #: ../Doc/whatsnew/2.2.rst:1007 msgid "" @@ -2131,7 +2303,6 @@ msgstr "" "SORT, GETACL y SETACL. (Contribución de Anthony Baxter y Michel Pelletier)" #: ../Doc/whatsnew/2.2.rst:1016 -#, fuzzy msgid "" "The :mod:`!rfc822` module's parsing of email addresses is now compliant " "with :rfc:`2822`, an update to :rfc:`822`. (The module's name is *not* " @@ -2139,15 +2310,14 @@ msgid "" "been added for parsing and generating e-mail messages. (Contributed by " "Barry Warsaw, and arising out of his work on Mailman.)" msgstr "" -"El módulo :mod:`rfc822` que analiza las direcciones de correo electrónico " -"cumple ahora con :rfc:`2822`, una actualización de :rfc:`822`. (El nombre " -"del módulo *no* se va a cambiar a ``rfc2822``.) También se ha añadido un " -"nuevo paquete, :mod:`email`, para analizar y generar mensajes de correo " -"electrónico. (Contribuido por Barry Warsaw, y surgido de su trabajo en " -"Mailman)" +"El análisis de direcciones de correo electrónico del módulo :mod:`!rfc822` " +"ahora es compatible con :rfc:`2822`, una actualización de :rfc:`822`. (El " +"nombre del módulo, *not*, se cambiará a ``rfc2822``). También se ha añadido " +"un nuevo paquete, :mod:`email`, para analizar y generar mensajes de correo " +"electrónico. (Contribuido por Barry Warsaw y derivado de su trabajo en " +"Mailman)." #: ../Doc/whatsnew/2.2.rst:1022 -#, fuzzy msgid "" "The :mod:`difflib` module now contains a new :class:`!Differ` class for " "producing human-readable lists of changes (a \"delta\") between two " @@ -2157,16 +2327,15 @@ msgid "" "contributed by David Goodger, from ndiff.py code by Tim Peters who then did " "the generatorization.)" msgstr "" -"El módulo :mod:`difflib` contiene ahora una nueva clase :class:`Differ` para " -"producir listas legibles por humanos de cambios (un \"delta\") entre dos " -"secuencias de líneas de texto. También hay dos funciones generadoras, :func:" -"`ndiff` y :func:`restore`, que retornan respectivamente un delta de dos " -"secuencias, o una de las secuencias originales de un delta. (Trabajo de " -"gruñido contribuido por David Goodger, a partir del código ndiff.py de Tim " -"Peters que luego hizo la generización)" +"El módulo :mod:`difflib` ahora contiene una nueva clase :class:`!Differ` " +"para producir listas legibles por humanos de cambios (un \"delta\") entre " +"dos secuencias de líneas de texto. También hay dos funciones generadoras, :" +"func:`!ndiff` y :func:`!restore`, que devuelven respectivamente un delta de " +"dos secuencias, o una de las secuencias originales de un delta. (Trabajo " +"básico aportado por David Goodger, a partir del código ndiff.py de Tim " +"Peters, quien luego realizó la generación)." #: ../Doc/whatsnew/2.2.rst:1029 -#, fuzzy msgid "" "New constants :const:`!ascii_letters`, :const:`!ascii_lowercase`, and :const:" "`!ascii_uppercase` were added to the :mod:`string` module. There were " @@ -2177,38 +2346,36 @@ msgid "" "been fixed to use :const:`!ascii_letters` instead. (Reported by an unknown " "person; fixed by Fred L. Drake, Jr.)" msgstr "" -"Se han añadido las nuevas constantes :const:`ascii_letters`, :const:" -"`ascii_lowercase` y :const:`ascii_uppercase` al módulo :mod:`string`. Había " -"varios módulos en la biblioteca estándar que utilizaban :const:`string." -"letters` para referirse a los rangos A-Za-z, pero esa suposición es " -"incorrecta cuando se utilizan locales, porque :const:`string.letters` varía " -"dependiendo del conjunto de caracteres legales definidos por el local " -"actual. Los módulos con errores se han corregido para que utilicen :const:" -"`ascii_letters` en su lugar. (Informado por una persona desconocida; " -"corregido por Fred L. Drake, Jr.)" +"Se agregaron las nuevas constantes :const:`!ascii_letters`, :const:`!" +"ascii_lowercase` y :const:`!ascii_uppercase` al módulo :mod:`string`. Había " +"varios módulos en la biblioteca estándar que usaban :const:`!string.letters` " +"para referirse a los rangos A-Za-z, pero esa suposición es incorrecta cuando " +"se usan las configuraciones regionales, porque :const:`!string.letters` " +"varía según el conjunto de caracteres legales definidos por la configuración " +"regional actual. Todos los módulos con errores se han corregido para que " +"usen :const:`!ascii_letters` en su lugar. (Informado por una persona " +"desconocida; corregido por Fred L. Drake, Jr.)" #: ../Doc/whatsnew/2.2.rst:1038 -#, fuzzy msgid "" "The :mod:`mimetypes` module now makes it easier to use alternative MIME-type " "databases by the addition of a :class:`~mimetypes.MimeTypes` class, which " "takes a list of filenames to be parsed. (Contributed by Fred L. Drake, Jr.)" msgstr "" -"El módulo :mod:`mimetypes` facilita ahora el uso de bases de datos de tipos " -"MIME alternativos mediante la adición de una clase :class:`MimeTypes`, que " -"toma una lista de nombres de archivo para ser analizados. (Contribución de " -"Fred L. Drake, Jr.)" +"El módulo :mod:`mimetypes` ahora facilita el uso de bases de datos de tipo " +"MIME alternativas mediante la incorporación de una clase :class:`~mimetypes." +"MimeTypes`, que toma una lista de nombres de archivos para analizar. " +"(Contribuido por Fred L. Drake, Jr.)" #: ../Doc/whatsnew/2.2.rst:1042 -#, fuzzy msgid "" "A :class:`~threading.Timer` class was added to the :mod:`threading` module " "that allows scheduling an activity to happen at some future time. " "(Contributed by Itamar Shtull-Trauring.)" msgstr "" -"Se ha añadido una clase :class:`Timer` al módulo :mod:`threading` que " -"permite programar una actividad para que ocurra en algún momento futuro. " -"(Contribución de Itamar Shtull-Trauring)" +"Se agregó una clase :class:`~threading.Timer` al módulo :mod:`threading` que " +"permite programar una actividad para que se realice en un momento futuro. " +"(Contribución de Itamar Shtull-Trauring)." #: ../Doc/whatsnew/2.2.rst:1050 msgid "Interpreter Changes and Fixes" @@ -2250,7 +2417,6 @@ msgstr "" "(Contribución de Fred L. Drake, Jr.)" #: ../Doc/whatsnew/2.2.rst:1066 -#, fuzzy msgid "" "Another low-level API, primarily of interest to implementers of Python " "debuggers and development tools, was added. :c:func:" @@ -2260,13 +2426,13 @@ msgid "" "looping over all the thread states for a given interpreter. (Contributed by " "David Beazley.)" msgstr "" -"Se ha añadido otra API de bajo nivel, principalmente de interés para los " +"Se agregó otra API de bajo nivel, principalmente de interés para los " "implementadores de depuradores y herramientas de desarrollo de Python. :c:" "func:`PyInterpreterState_Head` y :c:func:`PyInterpreterState_Next` permiten " -"al usuario recorrer todos los objetos intérpretes existentes; :c:func:" +"que un llamador recorra todos los objetos de intérprete existentes; :c:func:" "`PyInterpreterState_ThreadHead` y :c:func:`PyThreadState_Next` permiten " -"recorrer todos los estados de los hilos de un intérprete dado. " -"(Contribución de David Beazley)" +"recorrer todos los estados de subprocesos para un intérprete determinado. " +"(Contribución de David Beazley)." #: ../Doc/whatsnew/2.2.rst:1073 msgid "" @@ -2294,10 +2460,9 @@ msgstr "" "siguientes pasos:" #: ../Doc/whatsnew/2.2.rst:1082 -#, fuzzy msgid "Rename :c:macro:`!Py_TPFLAGS_GC` to :c:macro:`Py_TPFLAGS_HAVE_GC`." msgstr "" -"Cambia el nombre de :c:func:`Py_TPFLAGS_GC` a :c:func:`PyTPFLAGS_HAVE_GC`." +"Cambia el nombre de :c:func:`!Py_TPFLAGS_GC` a :c:func:`PyTPFLAGS_HAVE_GC`." #: ../Doc/whatsnew/2.2.rst:1085 msgid "" @@ -2310,27 +2475,24 @@ msgid "objects, and :c:func:`PyObject_GC_Del` to deallocate them." msgstr "objetos, y :c:func:`PyObject_GC_Del` para desocuparlos." #: ../Doc/whatsnew/2.2.rst:1087 -#, fuzzy msgid "" "Rename :c:func:`!PyObject_GC_Init` to :c:func:`PyObject_GC_Track` and :c:" "func:`!PyObject_GC_Fini` to :c:func:`PyObject_GC_UnTrack`." msgstr "" -"Cambiar el nombre de :c:func:`PyObject_GC_Init` a :c:func:" -"`PyObject_GC_Track` y" +"Cambie el nombre de :c:func:`!PyObject_GC_Init` a :c:func:" +"`PyObject_GC_Track` y de :c:func:`!PyObject_GC_Fini` a :c:func:" +"`PyObject_GC_UnTrack`." #: ../Doc/whatsnew/2.2.rst:1090 -#, fuzzy msgid "Remove :c:macro:`!PyGC_HEAD_SIZE` from object size calculations." msgstr "" -"Eliminar :c:func:`PyGC_HEAD_SIZE` del cálculo del tamaño de los objetos." +"Eliminar :c:macro:`!PyGC_HEAD_SIZE` de los cálculos de tamaño de objeto." #: ../Doc/whatsnew/2.2.rst:1092 -#, fuzzy msgid "" "Remove calls to :c:func:`!PyObject_AS_GC` and :c:func:`!PyObject_FROM_GC`." msgstr "" -"Eliminar las llamadas a :c:func:`PyObject_AS_GC` y :c:func:" -"`PyObject_FROM_GC`." +"Eliminar llamadas a :c:func:`!PyObject_AS_GC` y :c:func:`!PyObject_FROM_GC`." #: ../Doc/whatsnew/2.2.rst:1094 msgid "" @@ -2369,7 +2531,6 @@ msgstr "" "valores de los argumentos." #: ../Doc/whatsnew/2.2.rst:1109 -#, fuzzy msgid "" "Two new flags :c:macro:`METH_NOARGS` and :c:macro:`METH_O` are available in " "method definition tables to simplify implementation of methods with no " @@ -2378,16 +2539,15 @@ msgid "" "`METH_VARARGS`. Also, the old :c:macro:`!METH_OLDARGS` style of writing C " "methods is now officially deprecated." msgstr "" -"Dos nuevos indicadores :const:`METH_NOARGS` y :const:`METH_O` están " +"Hay dos nuevos indicadores :c:macro:`METH_NOARGS` y :c:macro:`METH_O` " "disponibles en las tablas de definición de métodos para simplificar la " -"implementación de métodos sin argumentos o con un único argumento no tipado. " +"implementación de métodos sin argumentos o con un único argumento sin tipo. " "Llamar a estos métodos es más eficiente que llamar a un método " -"correspondiente que utilice :const:`METH_VARARGS`. Además, el antiguo " -"estilo :const:`METH_OLDARGS` de escribir métodos en C está oficialmente en " -"desuso." +"correspondiente que utilice :c:macro:`METH_VARARGS`. Además, el antiguo " +"estilo :c:macro:`!METH_OLDARGS` de escribir métodos en C ahora está " +"oficialmente obsoleto." #: ../Doc/whatsnew/2.2.rst:1115 -#, fuzzy msgid "" "Two new wrapper functions, :c:func:`PyOS_snprintf` and :c:func:" "`PyOS_vsnprintf` were added to provide cross-platform implementations for " @@ -2396,13 +2556,13 @@ msgid "" "functions, the Python versions check the bounds of the buffer used to " "protect against buffer overruns. (Contributed by M.-A. Lemburg.)" msgstr "" -"Se han añadido dos nuevas funciones de envoltura, :c:func:`PyOS_snprintf` y :" -"c:func:`PyOS_vsnprintf` para proporcionar implementaciones multiplataforma " -"para las relativamente nuevas APIs de la biblioteca C :c:func:`snprintf` y :" -"c:func:`vsnprintf`. A diferencia de las funciones estándar :c:func:`sprintf` " -"y :c:func:`vsprintf`, las versiones de Python comprueban los límites del " -"búfer utilizado para protegerse de los desbordamientos del mismo. " -"(Contribución de M.-A. Lemburg.)" +"Se agregaron dos nuevas funciones de contenedor, :c:func:`PyOS_snprintf` y :" +"c:func:`PyOS_vsnprintf`, para proporcionar implementaciones multiplataforma " +"para las relativamente nuevas API de bibliotecas C :c:func:`snprintf` y :c:" +"func:`vsnprintf`. A diferencia de las funciones estándar :c:func:`sprintf` " +"y :c:func:`!vsprintf`, las versiones de Python verifican los límites del " +"búfer utilizado para protegerse contra desbordamientos del búfer. " +"(Contribuido por M.-A. Lemburg)." #: ../Doc/whatsnew/2.2.rst:1122 msgid "" @@ -2586,7 +2746,6 @@ msgstr "" "`.netrc`, si tiene uno. (Contribución de Mike Romberg)" #: ../Doc/whatsnew/2.2.rst:1216 -#, fuzzy msgid "" "Some features of the object returned by the :func:`!xrange` function are now " "deprecated, and trigger warnings when they're accessed; they'll disappear in " @@ -2598,15 +2757,15 @@ msgid "" "fourth argument to the :c:func:`!PyRange_New` function, ``repeat``, has also " "been deprecated." msgstr "" -"Algunas características del objeto retornado por la función :func:`xrange` " -"están ahora obsoletas, y provocan advertencias cuando se accede a ellas; " -"desaparecerán en Python 2.3. Los objetos :class:`xrange` intentaban fingir " -"que eran tipos de secuencia completos soportando el troceado, la " +"Algunas características del objeto devuelto por la función :func:`!xrange` " +"ahora están obsoletas y activan advertencias cuando se accede a ellas; " +"desaparecerán en Python 2.3. Los objetos :class:`!xrange` intentaron simular " +"que eran tipos de secuencia completa al admitir la segmentación, la " "multiplicación de secuencias y el operador :keyword:`in`, pero estas " -"características se utilizaban raramente y, por lo tanto, tenían errores. El " -"método :meth:`tolist` y los atributos :attr:`start`, :attr:`stop` y :attr:" -"`step` también han quedado obsoletos. A nivel de C, el cuarto argumento de " -"la función :c:func:`PyRange_New`, ``repeat``, también ha quedado obsoleto." +"características se usaban rara vez y, por lo tanto, presentaban errores. El " +"método :meth:`!tolist` y los atributos :attr:`!start`, :attr:`!stop` y :attr:" +"`!step` también están en desuso. En el nivel C, el cuarto argumento de la " +"función :c:func:`!PyRange_New`, ``repeat``, también ha quedado en desuso." #: ../Doc/whatsnew/2.2.rst:1225 msgid "" @@ -2675,7 +2834,6 @@ msgstr "" "getdlopenflags` y :func:`sys.setdlopenflags`. (Contribución de Bram Stolk.)" #: ../Doc/whatsnew/2.2.rst:1251 -#, fuzzy msgid "" "The :func:`pow` built-in function no longer supports 3 arguments when " "floating-point numbers are supplied. ``pow(x, y, z)`` returns ``(x**y) % " @@ -2684,10 +2842,10 @@ msgid "" "``pow(2.0, 8.0, 7.0)`` will now raise a :exc:`TypeError` exception." msgstr "" "La función incorporada :func:`pow` ya no admite 3 argumentos cuando se " -"suministran números de punto flotante. ``pow(x, y, z)`` retorna ``(x**y) % " -"z``, pero esto nunca es útil para números de punto flotante, y el resultado " -"final varía de forma impredecible dependiendo de la plataforma. Una llamada " -"como ``pow(2.0, 8.0, 7.0)`` lanzará ahora una excepción :exc:`TypeError`." +"suministran números de punto flotante. ``pow(x, y, z)`` devuelve ``(x**y) % " +"z``, pero esto nunca es útil para números de punto flotante y el resultado " +"final varía de manera impredecible según la plataforma. Una llamada como " +"``pow(2.0, 8.0, 7.0)`` ahora generará una excepción :exc:`TypeError`." #: ../Doc/whatsnew/2.2.rst:1261 msgid "Acknowledgements" From ffcbbcef0e51eed09f84be5627ffc305d8d80d79 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cristi=C3=A1n=20Maureira-Fredes?= Date: Sun, 24 Nov 2024 00:30:22 +0100 Subject: [PATCH 2/3] Add new word for whatsnew/2.2 --- dictionaries/whatsnew_2.2.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/dictionaries/whatsnew_2.2.txt b/dictionaries/whatsnew_2.2.txt index 649d60a9fd..3fce374a3c 100644 --- a/dictionaries/whatsnew_2.2.txt +++ b/dictionaries/whatsnew_2.2.txt @@ -74,6 +74,7 @@ inorder itojun meerkat memberst +mnemotécnicos must ndiff newattr From ebecd5f7c7974d3f883b421d9e55418d7132b6dc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cristi=C3=A1n=20Maureira-Fredes?= Date: Sun, 24 Nov 2024 00:58:23 +0100 Subject: [PATCH 3/3] Adapt some snippets --- whatsnew/2.2.po | 44 ++++++++++++++++++++++---------------------- 1 file changed, 22 insertions(+), 22 deletions(-) diff --git a/whatsnew/2.2.po b/whatsnew/2.2.po index b2a69166f9..52b25502c8 100644 --- a/whatsnew/2.2.po +++ b/whatsnew/2.2.po @@ -1158,22 +1158,22 @@ msgid "" "Dec 12\n" "Oct 10" msgstr "" -">>> m = {'Ene': 1, 'Feb': 2, 'Mar': 3, 'Abr': 4, 'May': 5, 'Jun': 6,\n" -"... 'Jul': 7, 'Ago': 8, 'Sep': ​​9, 'Oct': 10, 'Nov': 11, 'Dic': 12}\n" -">>> para clave en m: print clave, m[clave]\n" +">>> m = {'Jan': 1, 'Feb': 2, 'Mar': 3, 'Apr': 4, 'May': 5, 'Jun': 6,\n" +"... 'Jul': 7, 'Aug': 8, 'Sep': 9, 'Oct': 10, 'Nov': 11, 'Dec': 12}\n" +">>> for key in m: print key, m[key]\n" "...\n" -"3 Mar\n" -"2 Feb\n" -"8 Ago\n" -"9 Sep\n" -"5 May\n" -"6 Jun\n" -"7 Jul\n" -"1 Ene\n" -"4 Abr\n" -"11 Nov\n" -"12 Dic\n" -"10 Oct" +"Mar 3\n" +"Feb 2\n" +"Aug 8\n" +"Sep 9\n" +"May 5\n" +"Jun 6\n" +"Jul 7\n" +"Jan 1\n" +"Apr 4\n" +"Nov 11\n" +"Dec 12\n" +"Oct 10" #: ../Doc/whatsnew/2.2.rst:513 msgid "" @@ -1206,9 +1206,9 @@ msgid "" " # do something for each line\n" " ..." msgstr "" -"para línea en archivo:\n" -"# hacer algo para cada línea\n" -"..." +"for line in file:\n" +" # do something for each line\n" +" ..." #: ../Doc/whatsnew/2.2.rst:527 msgid "" @@ -1280,8 +1280,8 @@ msgid "" " yield i" msgstr "" "def generate_ints(N):\n" -"para i en rango(N):\n" -"rendimiento i" +" for i in range(N):\n" +" yield i" #: ../Doc/whatsnew/2.2.rst:563 msgid "" @@ -1471,8 +1471,8 @@ msgid "" "sentence := \"Store it in the neighboring harbor\"\n" "if (i := find(\"or\", sentence)) > 5 then write(i)" msgstr "" -"oración := \"Guardarlo en el puerto vecino\"\n" -"si (i := find(\"o\", oración)) > 5 entonces write(i)" +"sentence := \"Store it in the neighboring harbor\"\n" +"if (i := find(\"or\", sentence)) > 5 then write(i)" #: ../Doc/whatsnew/2.2.rst:645 msgid ""