2.3.po

# Copyright (C) 2001-2020, Python Software Foundation
# This file is distributed under the same license as the Python package.
# Maintained by the python-doc-es workteam.
# docs-es@python.org /
# https://mail.python.org/mailman3/lists/docs-es.python.org/
# Check https://github.com/python/python-docs-es/blob/3.8/TRANSLATORS to get
# the list of volunteers
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.8\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2023-10-12 19:43+0200\n"
"PO-Revision-Date: 2021-09-25 10:30+0100\n"
"Last-Translator: Claudia Millan <clmilneb@gmail.com>\n"
"Language-Team: python-doc-es\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.13.0\n"

#: ../Doc/whatsnew/2.3.rst:3
msgid "What's New in Python 2.3"
msgstr "Qué hay de nuevo en Python 2.3"

#: ../Doc/whatsnew/2.3.rst
msgid "Author"
msgstr "Autor"

#: ../Doc/whatsnew/2.3.rst:5
msgid "A.M. Kuchling"
msgstr "A.M. Kuchling"

#: ../Doc/whatsnew/2.3.rst:11
msgid ""
"This article explains the new features in Python 2.3.  Python 2.3 was "
"released on July 29, 2003."
msgstr ""
"Este artículo explica las nuevas características de Python 2.3.  Python 2.3 "
"se publicó el 29 de julio de 2003."

#: ../Doc/whatsnew/2.3.rst:14
msgid ""
"The main themes for Python 2.3 are polishing some of the features added in "
"2.2, adding various small but useful enhancements to the core language, and "
"expanding the standard library.  The new object model introduced in the "
"previous version has benefited from 18 months of bugfixes and from "
"optimization efforts that have improved the performance of new-style "
"classes.  A few new built-in functions have been added such as :func:`sum` "
"and :func:`enumerate`.  The :keyword:`in` operator can now be used for "
"substring searches (e.g. ``\"ab\" in \"abc\"`` returns :const:`True`)."
msgstr ""
"Los temas principales de Python 2.3 son el pulido de algunas de las "
"características añadidas en la 2.2, la adición de varias mejoras pequeñas "
"pero útiles al núcleo del lenguaje y la ampliación de la biblioteca "
"estándar.  El nuevo modelo de objetos introducido en la versión anterior se "
"ha beneficiado de 18 meses de correcciones de errores y de esfuerzos de "
"optimización que han mejorado el rendimiento de las clases de nuevo estilo.  "
"Se han añadido algunas funciones incorporadas, como :func:`sum` y :func:"
"`enumerate`.  El operador :keyword:`in` puede utilizarse ahora para "
"búsquedas de subcadenas (por ejemplo, ``\"ab\" en \"abc\"`` retorna :const:"
"`True`)."

#: ../Doc/whatsnew/2.3.rst:23
msgid ""
"Some of the many new library features include Boolean, set, heap, and date/"
"time data types, the ability to import modules from ZIP-format archives, "
"metadata support for the long-awaited Python catalog, an updated version of "
"IDLE, and modules for logging messages, wrapping text, parsing CSV files, "
"processing command-line options, using BerkeleyDB databases...  the list of "
"new and enhanced modules is lengthy."
msgstr ""
"Algunas de las nuevas características de la biblioteca son los tipos de "
"datos booleanos, de conjunto, de montón y de fecha/hora, la posibilidad de "
"importar módulos desde archivos con formato ZIP, el soporte de metadatos "
"para el tan esperado catálogo de Python, una versión actualizada de IDLE y "
"módulos para registrar mensajes, envolver texto, analizar archivos CSV, "
"procesar opciones de línea de comandos, utilizar bases de datos "
"BerkeleyDB... la lista de módulos nuevos y mejorados es larga."

#: ../Doc/whatsnew/2.3.rst:30
msgid ""
"This article doesn't attempt to provide a complete specification of the new "
"features, but instead provides a convenient overview.  For full details, you "
"should refer to the documentation for Python 2.3, such as the Python Library "
"Reference and the Python Reference Manual.  If you want to understand the "
"complete implementation and design rationale, refer to the PEP for a "
"particular new feature."
msgstr ""
"Este artículo no pretende proporcionar una especificación completa de las "
"nuevas características, sino que proporciona una visión general "
"conveniente.  Para obtener todos los detalles, debes consultar la "
"documentación de Python 2.3, como la Referencia de la Biblioteca de Python y "
"el Manual de Referencia de Python.  Si quieres entender la implementación "
"completa y los fundamentos del diseño, consulta el PEP de una nueva "
"característica en particular."

#: ../Doc/whatsnew/2.3.rst:41
msgid "PEP 218: A Standard Set Datatype"
msgstr "PEP 218: Un tipo de datos de conjunto estándar"

#: ../Doc/whatsnew/2.3.rst:43
msgid ""
"The new :mod:`sets` module contains an implementation of a set datatype.  "
"The :class:`Set` class is for mutable sets, sets that can have members added "
"and removed.  The :class:`ImmutableSet` class is for sets that can't be "
"modified, and instances of :class:`ImmutableSet` can therefore be used as "
"dictionary keys. Sets are built on top of dictionaries, so the elements "
"within a set must be hashable."
msgstr ""
"El nuevo módulo :mod:`sets` contiene una implementación de un tipo de datos "
"de conjuntos.  La clase :class:`Set` es para conjuntos mutables, conjuntos a "
"los que se les pueden añadir y eliminar miembros.  La clase :class:"
"`ImmutableSet` es para los conjuntos que no pueden ser modificados, y las "
"instancias de :class:`ImmutableSet` pueden por lo tanto ser utilizadas como "
"claves de diccionario. Los conjuntos se construyen sobre diccionarios, por "
"lo que los elementos de un conjunto deben ser hashables."

#: ../Doc/whatsnew/2.3.rst:50
msgid "Here's a simple example::"
msgstr "Aquí hay un ejemplo simple::"

#: ../Doc/whatsnew/2.3.rst:66
msgid ""
"The union and intersection of sets can be computed with the :meth:`union` "
"and :meth:`intersection` methods; an alternative notation uses the bitwise "
"operators ``&`` and ``|``. Mutable sets also have in-place versions of these "
"methods, :meth:`union_update` and :meth:`intersection_update`. ::"
msgstr ""
"La unión y la intersección de los conjuntos pueden calcularse con los "
"métodos :meth:`union` y :meth:`intersection`; una notación alternativa "
"utiliza los operadores bitácora ``&`` y ``|``. Los conjuntos mutables "
"también tienen versiones in situ de estos métodos, :meth:`union_update` y :"
"meth:`intersection_update`. ::"

#: ../Doc/whatsnew/2.3.rst:86
msgid ""
"It's also possible to take the symmetric difference of two sets.  This is "
"the set of all elements in the union that aren't in the intersection.  "
"Another way of putting it is that the symmetric difference contains all "
"elements that are in exactly one set.  Again, there's an alternative "
"notation (``^``), and an in-place version with the ungainly name :meth:"
"`symmetric_difference_update`. ::"
msgstr ""
"También es posible tomar la diferencia simétrica de dos conjuntos.  Este es "
"el conjunto de todos los elementos de la unión que no están en la "
"intersección.  Otra forma de decirlo es que la diferencia simétrica contiene "
"todos los elementos que están exactamente en un conjunto.  De nuevo, existe "
"una notación alternativa (``^``), y una versión in-place con el poco "
"agraciado nombre :meth:`symmetric_difference_update`. ::"

#: ../Doc/whatsnew/2.3.rst:100
msgid ""
"There are also :meth:`issubset` and :meth:`issuperset` methods for checking "
"whether one set is a subset or superset of another::"
msgstr ""
"También hay métodos :meth:`issubset` y :meth:`issuperset` para comprobar si "
"un conjunto es subconjunto o superconjunto de otro::"

#: ../Doc/whatsnew/2.3.rst:117
msgid ":pep:`218` - Adding a Built-In Set Object Type"
msgstr ":pep:`218` - Añadiendo un tipo de objeto de conjunto incorporado"

#: ../Doc/whatsnew/2.3.rst:117
msgid ""
"PEP written by Greg V. Wilson. Implemented by Greg V. Wilson, Alex Martelli, "
"and GvR."
msgstr ""
"PEP escrito por Greg V. Wilson. Implementado por Greg V. Wilson, Alex "
"Martelli y GvR."

#: ../Doc/whatsnew/2.3.rst:126
msgid "PEP 255: Simple Generators"
msgstr "PEP 255: Generadores simples"

#: ../Doc/whatsnew/2.3.rst:128
msgid ""
"In Python 2.2, generators were added as an optional feature, to be enabled "
"by a ``from __future__ import generators`` directive.  In 2.3 generators no "
"longer need to be specially enabled, and are now always present; this means "
"that :keyword:`yield` is now always a keyword.  The rest of this section is "
"a copy of the description of generators from the \"What's New in Python "
"2.2\" document; if you read it back when Python 2.2 came out, you can skip "
"the rest of this section."
msgstr ""
"En Python 2.2, los generadores se añadieron como una característica "
"opcional, que se activaba mediante una directiva ``from __future__ import "
"generators``.  En 2.3 los generadores ya no necesitan ser habilitados "
"especialmente, y ahora están siempre presentes; esto significa que :keyword:"
"`yield` es ahora siempre una palabra clave.  El resto de esta sección es una "
"copia de la descripción de los generadores del documento \"What's New in "
"Python 2.2\"; si lo leíste cuando salió Python 2.2, puedes saltarte el resto "
"de esta sección."

#: ../Doc/whatsnew/2.3.rst:136
msgid ""
"You're doubtless familiar with how function calls work in Python or C. When "
"you call a function, it gets a private namespace where its local variables "
"are created.  When the function reaches a :keyword:`return` statement, the "
"local variables are destroyed and the resulting value is returned to the "
"caller.  A later call to the same function will get a fresh new set of local "
"variables. But, what if the local variables weren't thrown away on exiting a "
"function? What if you could later resume the function where it left off?  "
"This is what generators provide; they can be thought of as resumable "
"functions."
msgstr ""
"Sin duda estás familiarizado con cómo funcionan las llamadas a funciones en "
"Python o C. Cuando llamas a una función, ésta obtiene un espacio de nombres "
"privado donde se crean sus variables locales.  Cuando la función llega a una "
"declaración :keyword:`return`, las variables locales se destruyen y el valor "
"resultante se retorna a quien la llamó.  Una llamada posterior a la misma "
"función obtendrá un nuevo conjunto de variables locales. Pero, ¿qué pasaría "
"si las variables locales no se tiraran al salir de una función? ¿Qué pasaría "
"si pudieras reanudar la función donde la dejaste?  Esto es lo que "
"proporcionan los generadores; se puede pensar en ellos como funciones "
"reanudables."

#: ../Doc/whatsnew/2.3.rst:145
msgid "Here's the simplest example of a generator function::"
msgstr "Este es el ejemplo más sencillo de una función generadora::"

#: ../Doc/whatsnew/2.3.rst:151
msgid ""
"A new keyword, :keyword:`yield`, was introduced for generators.  Any "
"function containing a :keyword:`!yield` statement is a generator function; "
"this is detected by Python's bytecode compiler which compiles the function "
"specially as a result."
msgstr ""
"Se ha introducido una nueva palabra clave, :keyword:`yield`, para los "
"generadores.  Cualquier función que contenga una declaración :keyword:`!"
"yield` es una función generadora; esto es detectado por el compilador de "
"código de bits de Python que compila la función especialmente como resultado."

#: ../Doc/whatsnew/2.3.rst:156
msgid ""
"When you call a generator function, it doesn't return a single value; "
"instead it returns a generator object that supports the iterator protocol.  "
"On executing the :keyword:`yield` statement, the generator outputs the value "
"of ``i``, similar to a :keyword:`return` statement.  The big difference "
"between :keyword:`!yield` and a :keyword:`!return` statement is that on "
"reaching a :keyword:`!yield` the generator's state of execution is suspended "
"and local variables are preserved.  On the next call to the generator's ``."
"next()`` method, the function will resume executing immediately after the :"
"keyword:`!yield` statement.  (For complicated reasons, the :keyword:`!yield` "
"statement isn't allowed inside the :keyword:`try` block of a :keyword:`!"
"try`...\\ :keyword:`!finally` statement; read :pep:`255` for a full "
"explanation of the interaction between :keyword:`!yield` and exceptions.)"
msgstr ""
"Cuando se llama a una función generadora, ésta no retorna un único valor, "
"sino que retorna un objeto generador que soporta el protocolo de los "
"iteradores.  Al ejecutar la sentencia :keyword:`yield`, el generador retorna "
"el valor de ``i``, de forma similar a una sentencia :keyword:`return`.  La "
"gran diferencia entre :keyword:`!yield` y una sentencia :keyword:`!return` "
"es que al llegar a una sentencia :keyword:`!yield` se suspende el estado de "
"ejecución del generador y se conservan las variables locales.  En la "
"siguiente llamada al método ``.next()`` del generador, la función se "
"reanudará la ejecución inmediatamente después de la sentencia :keyword:`!"
"yield`.  (Por razones complicadas, la sentencia :keyword:`!yield` no está "
"permitida dentro del bloque :keyword:`try` de una sentencia :keyword:`!"
"try`...`; lea :pep:`255` para una explicación completa de la interacción "
"entre :keyword:`!yield` y las excepciones)"

#: ../Doc/whatsnew/2.3.rst:169
msgid "Here's a sample usage of the :func:`generate_ints` generator::"
msgstr "Este es un ejemplo de uso del generador :func:`generate_ints`::"

#: ../Doc/whatsnew/2.3.rst:186
msgid ""
"You could equally write ``for i in generate_ints(5)``, or ``a,b,c = "
"generate_ints(3)``."
msgstr ""
"También podrías escribir ``for i in generate_ints(5)``, o ``a,b,c = "
"generate_ints(3)``."

#: ../Doc/whatsnew/2.3.rst:189
msgid ""
"Inside a generator function, the :keyword:`return` statement can only be "
"used without a value, and signals the end of the procession of values; "
"afterwards the generator cannot return any further values. :keyword:`!"
"return` with a value, such as ``return 5``, is a syntax error inside a "
"generator function.  The end of the generator's results can also be "
"indicated by raising :exc:`StopIteration` manually, or by just letting the "
"flow of execution fall off the bottom of the function."
msgstr ""
"Dentro de una función generadora, la expresión :keyword:`return` sólo puede "
"usarse sin un valor, y señala el final de la procesión de valores; después "
"el generador no puede retornar más valores. :keyword:`!return` con un valor, "
"como ``return 5``, es un error de sintaxis dentro de una función "
"generadora.  El final de los resultados del generador también puede "
"indicarse levantando manualmente :exc:`StopIteration`, o simplemente dejando "
"que el flujo de ejecución caiga en el fondo de la función."

#: ../Doc/whatsnew/2.3.rst:197
msgid ""
"You could achieve the effect of generators manually by writing your own "
"class and storing all the local variables of the generator as instance "
"variables.  For example, returning a list of integers could be done by "
"setting ``self.count`` to 0, and having the :meth:`next` method increment "
"``self.count`` and return it. However, for a moderately complicated "
"generator, writing a corresponding class would be much messier. :file:`Lib/"
"test/test_generators.py` contains a number of more interesting examples.  "
"The simplest one implements an in-order traversal of a tree using generators "
"recursively. ::"
msgstr ""
"Puedes conseguir el efecto de los generadores manualmente escribiendo tu "
"propia clase y almacenando todas las variables locales del generador como "
"variables de instancia.  Por ejemplo, la devolución de una lista de enteros "
"podría hacerse estableciendo ``self.count`` a 0, y haciendo que el método :"
"meth:`next` incremente ``self.count`` y lo retorne. Sin embargo, para un "
"generador medianamente complicado, escribir la clase correspondiente sería "
"mucho más complicado. :file:`Lib/test/test_generators.py` contiene varios "
"ejemplos más interesantes.  El más sencillo implementa un recorrido en orden "
"de un árbol utilizando generadores de forma recursiva ::"

#: ../Doc/whatsnew/2.3.rst:215
msgid ""
"Two other examples in :file:`Lib/test/test_generators.py` produce solutions "
"for the N-Queens problem (placing $N$ queens on an $NxN$ chess board so that "
"no queen threatens another) and the Knight's Tour (a route that takes a "
"knight to every square of an $NxN$ chessboard without visiting any square "
"twice)."
msgstr ""
"Otros dos ejemplos en :file:`Lib/test/test_generators.py` producen "
"soluciones para el problema de las N reinas (colocar $N$ reinas en un "
"tablero de ajedrez $NxN$ de forma que ninguna reina amenace a otra) y el "
"recorrido del caballero (una ruta que lleva a un caballo a cada casilla de "
"un tablero de ajedrez $NxN$ sin visitar ninguna casilla dos veces)."

#: ../Doc/whatsnew/2.3.rst:220
msgid ""
"The idea of generators comes from other programming languages, especially "
"Icon (https://www2.cs.arizona.edu/icon/), where the idea of generators is "
"central.  In Icon, every expression and function call behaves like a "
"generator.  One example from \"An Overview of the Icon Programming "
"Language\" at https://www2.cs.arizona.edu/icon/docs/ipd266.htm gives an idea "
"of what this looks like::"
msgstr ""
"La idea de los generadores proviene de otros lenguajes de programación, "
"especialmente de Icon (https://www2.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://www2.cs.arizona.edu/icon/docs/ipd266."
"htm da una idea de cómo es esto::"

#: ../Doc/whatsnew/2.3.rst:230
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`` is first "
"assigned a value of 3, but 3 is less than 5, so the comparison fails, and "
"Icon retries it with the second value of 23.  23 is greater than 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 expresión :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 "
"imprime el valor 23 en la pantalla."

#: ../Doc/whatsnew/2.3.rst:236
msgid ""
"Python doesn't go nearly as far as Icon in adopting generators as a central "
"concept.  Generators are considered part of the core Python language, but "
"learning or using them isn't compulsory; if they don't solve any problems "
"that you have, feel free to ignore them. One novel feature of Python's "
"interface as compared to Icon's is that a generator's state is represented "
"as a concrete object (the iterator) that can be passed around to other "
"functions or stored in a data structure."
msgstr ""
"Python no va tan lejos como Icon en la adopción de generadores como concepto "
"central.  Los generadores se consideran parte del núcleo del lenguaje "
"Python, pero aprenderlos o utilizarlos no es obligatorio; si no resuelven "
"ningún problema que tengas, siéntete libre de ignorarlos. Una característica "
"novedosa de la interfaz de Python en comparación con la de Icon es que el "
"estado de un generador se representa como un objeto concreto (el iterador) "
"que puede pasarse a otras funciones o almacenarse en una estructura de datos."

#: ../Doc/whatsnew/2.3.rst:248
msgid ":pep:`255` - Simple Generators"
msgstr ":pep:`255` - Generadores simples"

#: ../Doc/whatsnew/2.3.rst:248
msgid ""
"Written by Neil Schemenauer, Tim Peters, Magnus Lie Hetland.  Implemented "
"mostly by Neil Schemenauer and Tim Peters, with other fixes from the Python "
"Labs crew."
msgstr ""
"Escrito por Neil Schemenauer, Tim Peters, Magnus Lie Hetland.  Implementado "
"principalmente por Neil Schemenauer y Tim Peters, con otras correcciones del "
"equipo de Python Labs."

#: ../Doc/whatsnew/2.3.rst:257
msgid "PEP 263: Source Code Encodings"
msgstr "PEP 263: Codificación del código fuente"

#: ../Doc/whatsnew/2.3.rst:259
msgid ""
"Python source files can now be declared as being in different character set "
"encodings.  Encodings are declared by including a specially formatted "
"comment in the first or second line of the source file.  For example, a "
"UTF-8 file can be declared with::"
msgstr ""
"Los archivos fuente de Python ahora pueden declararse con diferentes "
"codificaciones de conjuntos de caracteres.  Las codificaciones se declaran "
"incluyendo un comentario con formato especial en la primera o segunda línea "
"del archivo fuente.  Por ejemplo, un archivo UTF-8 puede declararse con::"

#: ../Doc/whatsnew/2.3.rst:267
msgid ""
"Without such an encoding declaration, the default encoding used is 7-bit "
"ASCII. Executing or importing modules that contain string literals with 8-"
"bit characters and have no encoding declaration will result in a :exc:"
"`DeprecationWarning` being signalled by Python 2.3; in 2.4 this will be a "
"syntax error."
msgstr ""
"Sin esta declaración de codificación, la codificación por defecto utilizada "
"es ASCII de 7 bits. Ejecutar o importar módulos que contengan literales de "
"cadena con caracteres de 8 bits y que no tengan una declaración de "
"codificación dará lugar a un :exc:`DeprecationWarning` señalado por Python "
"2.3; en 2.4 será un error de sintaxis."

#: ../Doc/whatsnew/2.3.rst:273
msgid ""
"The encoding declaration only affects Unicode string literals, which will be "
"converted to Unicode using the specified encoding.  Note that Python "
"identifiers are still restricted to ASCII characters, so you can't have "
"variable names that use characters outside of the usual alphanumerics."
msgstr ""
"La declaración de codificación sólo afecta a los literales de cadena "
"Unicode, que se convertirán a Unicode utilizando la codificación "
"especificada.  Ten en cuenta que los identificadores de Python siguen "
"restringidos a caracteres ASCII, por lo que no puedes tener nombres de "
"variables que utilicen caracteres fuera de los alfanuméricos habituales."

#: ../Doc/whatsnew/2.3.rst:282
msgid ":pep:`263` - Defining Python Source Code Encodings"
msgstr ""
":pep:`263` - Definición de las codificaciones del código fuente de Python"

#: ../Doc/whatsnew/2.3.rst:282
msgid ""
"Written by Marc-André Lemburg and Martin von Löwis; implemented by Suzuki "
"Hisao and Martin von Löwis."
msgstr ""
"Escrito por Marc-André Lemburg y Martin von Löwis; realizado por Suzuki "
"Hisao y Martin von Löwis."

#: ../Doc/whatsnew/2.3.rst:289
msgid "PEP 273: Importing Modules from ZIP Archives"
msgstr "PEP 273: Importar módulos desde archivos ZIP"

#: ../Doc/whatsnew/2.3.rst:291
msgid ""
"The new :mod:`zipimport` module adds support for importing modules from a "
"ZIP-format archive.  You don't need to import the module explicitly; it will "
"be automatically imported if a ZIP archive's filename is added to ``sys."
"path``. For example:"
msgstr ""
"El nuevo módulo :mod:`zipimport` añade soporte para importar módulos desde "
"un archivo en formato ZIP.  No es necesario importar el módulo "
"explícitamente; se importará automáticamente si se añade el nombre de un "
"archivo ZIP a ``sys.path``. Por ejemplo:"

#: ../Doc/whatsnew/2.3.rst:314
msgid ""
"An entry in ``sys.path`` can now be the filename of a ZIP archive. The ZIP "
"archive can contain any kind of files, but only files named :file:`\\*.py`, :"
"file:`\\*.pyc`, or :file:`\\*.pyo` can be imported.  If an archive only "
"contains :file:`\\*.py` files, Python will not attempt to modify the archive "
"by adding the corresponding :file:`\\*.pyc` file, meaning that if a ZIP "
"archive doesn't contain :file:`\\*.pyc` files, importing may be rather slow."
msgstr ""
"Una entrada en ``sys.path`` puede ser ahora el nombre de un archivo ZIP. El "
"archivo ZIP puede contener cualquier tipo de ficheros, pero sólo se pueden "
"importar los ficheros llamados :file:`\\*.py`, :file:`\\*.pyc`, o :file:`\\*."
"pyo`.  Si un archivo sólo contiene ficheros :file:`\\*.py`, Python no "
"intentará modificar el archivo añadiendo el correspondiente fichero :file:"
"`\\*.pyc`, lo que significa que si un archivo ZIP no contiene ficheros :file:"
"`\\*.pyc`, la importación puede ser bastante lenta."

#: ../Doc/whatsnew/2.3.rst:321
msgid ""
"A path within the archive can also be specified to only import from a "
"subdirectory; for example, the path :file:`/tmp/example.zip/lib/` would only "
"import from the :file:`lib/` subdirectory within the archive."
msgstr ""
"También se puede especificar una ruta dentro del archivo para importar sólo "
"de un subdirectorio; por ejemplo, la ruta :file:`/tmp/example.zip/lib/` sólo "
"importaría del subdirectorio :file:`lib/` dentro del archivo."

#: ../Doc/whatsnew/2.3.rst:331
msgid ":pep:`273` - Import Modules from Zip Archives"
msgstr ":pep:`273` - Importación de módulos desde archivos Zip"

#: ../Doc/whatsnew/2.3.rst:329
msgid ""
"Written by James C. Ahlstrom,  who also provided an implementation. Python "
"2.3 follows the specification in :pep:`273`,  but uses an implementation "
"written by Just van Rossum  that uses the import hooks described in :pep:"
"`302`. See section :ref:`section-pep302` for a description of the new import "
"hooks."
msgstr ""
"Escrito por James C. Ahlstrom, que también proporcionó una implementación. "
"Python 2.3 sigue la especificación en :pep:`273`, pero utiliza una "
"implementación escrita por Just van Rossum que utiliza los ganchos de "
"importación descritos en :pep:`302`. Vea la sección :ref:`section-pep302` "
"para una descripción de los nuevos ganchos de importación."

#: ../Doc/whatsnew/2.3.rst:338
msgid "PEP 277: Unicode file name support for Windows NT"
msgstr "PEP 277: Soporte de nombres de archivo Unicode para Windows NT"

#: ../Doc/whatsnew/2.3.rst:340
msgid ""
"On Windows NT, 2000, and XP, the system stores file names as Unicode "
"strings. Traditionally, Python has represented file names as byte strings, "
"which is inadequate because it renders some file names inaccessible."
msgstr ""
"En Windows NT, 2000 y XP, el sistema almacena los nombres de archivo como "
"cadenas Unicode. Tradicionalmente, Python ha representado los nombres de "
"archivo como cadenas de bytes, lo cual es inadecuado porque hace que algunos "
"nombres de archivo sean inaccesibles."

#: ../Doc/whatsnew/2.3.rst:344
msgid ""
"Python now allows using arbitrary Unicode strings (within the limitations of "
"the file system) for all functions that expect file names, most notably the :"
"func:`open` built-in function. If a Unicode string is passed to :func:`os."
"listdir`, Python now returns a list of Unicode strings.  A new function, :"
"func:`os.getcwdu`, returns the current directory as a Unicode string."
msgstr ""
"Python permite ahora utilizar cadenas Unicode arbitrarias (dentro de las "
"limitaciones del sistema de archivos) para todas las funciones que esperan "
"nombres de archivos, sobre todo la función incorporada :func:`open`. Si se "
"pasa una cadena Unicode a :func:`os.listdir`, Python retorna ahora una lista "
"de cadenas Unicode.  Una nueva función, :func:`os.getcwdu`, retorna el "
"directorio actual como una cadena Unicode."

#: ../Doc/whatsnew/2.3.rst:350
msgid ""
"Byte strings still work as file names, and on Windows Python will "
"transparently convert them to Unicode using the ``mbcs`` encoding."
msgstr ""
"Las cadenas de bytes siguen funcionando como nombres de archivo, y en "
"Windows Python las convertirá de forma transparente a Unicode utilizando la "
"codificación ``mbcs``."

#: ../Doc/whatsnew/2.3.rst:353
msgid ""
"Other systems also allow Unicode strings as file names but convert them to "
"byte strings before passing them to the system, which can cause a :exc:"
"`UnicodeError` to be raised. Applications can test whether arbitrary Unicode "
"strings are supported as file names by checking :attr:`os.path."
"supports_unicode_filenames`, a Boolean value."
msgstr ""
"Otros sistemas también permiten cadenas Unicode como nombres de archivo, "
"pero las convierten en cadenas de bytes antes de pasarlas al sistema, lo que "
"puede provocar un :exc:`UnicodeError`. Las aplicaciones pueden comprobar si "
"se admiten cadenas Unicode arbitrarias como nombres de archivo comprobando :"
"attr:`os.path.supports_unicode_filenames`, un valor booleano."

#: ../Doc/whatsnew/2.3.rst:359
msgid "Under MacOS, :func:`os.listdir` may now return Unicode filenames."
msgstr ""
"En MacOS, :func:`os.listdir` ahora puede retornar nombres de archivo Unicode."

#: ../Doc/whatsnew/2.3.rst:365
msgid ":pep:`277` - Unicode file name support for Windows NT"
msgstr ":pep:`277` - Soporte de nombres de archivo Unicode para Windows NT"

#: ../Doc/whatsnew/2.3.rst:365
msgid ""
"Written by Neil Hodgson; implemented by Neil Hodgson, Martin von Löwis, and "
"Mark Hammond."
msgstr ""
"Escrito por Neil Hodgson; realizado por Neil Hodgson, Martin von Löwis y "
"Mark Hammond."

#: ../Doc/whatsnew/2.3.rst:375
msgid "PEP 278: Universal Newline Support"
msgstr "PEP 278: Soporte universal de nuevas líneas"

#: ../Doc/whatsnew/2.3.rst:377
msgid ""
"The three major operating systems used today are Microsoft Windows, Apple's "
"Macintosh OS, and the various Unix derivatives.  A minor irritation of cross-"
"platform work  is that these three platforms all use different characters to "
"mark the ends of lines in text files.  Unix uses the linefeed (ASCII "
"character 10), MacOS uses the carriage return (ASCII character 13), and "
"Windows uses a two-character sequence of a carriage return plus a newline."
msgstr ""
"Los tres principales sistemas operativos que se utilizan hoy en día son "
"Microsoft Windows, el sistema operativo Macintosh de Apple y los diversos "
"derivados de Unix.  Una pequeña molestia del trabajo entre plataformas es "
"que estas tres plataformas utilizan diferentes caracteres para marcar el "
"final de las líneas en los archivos de texto.  Unix utiliza el salto de "
"línea (carácter ASCII 10), MacOS utiliza el retorno de carro (carácter ASCII "
"13), y Windows utiliza una secuencia de dos caracteres de un retorno de "
"carro más una nueva línea."

#: ../Doc/whatsnew/2.3.rst:384
msgid ""
"Python's file objects can now support end of line conventions other than the "
"one followed by the platform on which Python is running. Opening a file with "
"the mode ``'U'`` or ``'rU'`` will open a file for reading in :term:"
"`universal newlines` mode.  All three line ending conventions will be "
"translated to a ``'\\n'`` in the strings returned by the various file "
"methods such as :meth:`read` and :meth:`readline`."
msgstr ""
"Los objetos de archivo de Python pueden ahora soportar convenciones de fin "
"de línea distintas de la que sigue la plataforma en la que se ejecuta "
"Python. Al abrir un archivo con el modo ``'U`` o ``'rU`` se abrirá un "
"archivo para su lectura en modo :term:`universal newlines`.  Las tres "
"convenciones de final de línea se traducirán a un ``'\\n'`` en las cadenas "
"retornadas por los distintos métodos de archivo como :meth:`read` y :meth:"
"`readline`."

#: ../Doc/whatsnew/2.3.rst:391
msgid ""
"Universal newline support is also used when importing modules and when "
"executing a file with the :func:`execfile` function.  This means that Python "
"modules can be shared between all three operating systems without needing to "
"convert the line-endings."
msgstr ""
"El soporte universal de nuevas líneas también se utiliza al importar módulos "
"y al ejecutar un archivo con la función :func:`execfile`.  Esto significa "
"que los módulos de Python pueden ser compartidos entre los tres sistemas "
"operativos sin necesidad de convertir los finales de línea."

#: ../Doc/whatsnew/2.3.rst:396
msgid ""
"This feature can be disabled when compiling Python by specifying the :option:"
"`!--without-universal-newlines` switch when running Python's :program:"
"`configure` script."
msgstr ""
"Esta función puede desactivarse al compilar Python especificando la opción :"
"option:`!--without-universal-newlines` al ejecutar el script :program:"
"`configure` de Python."

#: ../Doc/whatsnew/2.3.rst:403
msgid ":pep:`278` - Universal Newline Support"
msgstr ":pep:`278` - Soporte universal de nuevas líneas"

#: ../Doc/whatsnew/2.3.rst:404
msgid "Written and implemented by Jack Jansen."
msgstr "Escrito y ejecutado por Jack Jansen."

#: ../Doc/whatsnew/2.3.rst:412
msgid "PEP 279: enumerate()"
msgstr "PEP 279: enumerate()"

#: ../Doc/whatsnew/2.3.rst:414
msgid ""
"A new built-in function, :func:`enumerate`, will make certain loops a bit "
"clearer.  ``enumerate(thing)``, where *thing* is either an iterator or a "
"sequence, returns an iterator that will return ``(0, thing[0])``, ``(1, "
"thing[1])``, ``(2, thing[2])``, and so forth."
msgstr ""
"Una nueva función incorporada, :func:`enumerate`, hará que ciertos bucles "
"sean un poco más claros.  ``enumerate(cosa)``, donde *cosa* es un iterador o "
"una secuencia, retorna un iterador que retornará ``(0, cosa[0])``, ``(1, "
"cosa[1])``, ``(2, cosa[2])``, y así sucesivamente."

#: ../Doc/whatsnew/2.3.rst:419
msgid "A common idiom to change every element of a list looks like this::"
msgstr ""
"Un modismo común para cambiar cada elemento de una lista tiene el siguiente "
"aspecto::"

#: ../Doc/whatsnew/2.3.rst:426
msgid "This can be rewritten using :func:`enumerate` as::"
msgstr "Esto se puede reescribir usando :func:`enumerate` como::"

#: ../Doc/whatsnew/2.3.rst:435
msgid ":pep:`279` - The enumerate() built-in function"
msgstr ":pep:`279` - La función incorporada enumerate()"

#: ../Doc/whatsnew/2.3.rst:436
msgid "Written and implemented by Raymond D. Hettinger."
msgstr "Escrito y ejecutado por Raymond D. Hettinger."

#: ../Doc/whatsnew/2.3.rst:442
msgid "PEP 282: The logging Package"
msgstr "PEP 282: El paquete de registro"

#: ../Doc/whatsnew/2.3.rst:444
msgid ""
"A standard package for writing logs, :mod:`logging`, has been added to "
"Python 2.3.  It provides a powerful and flexible mechanism for generating "
"logging output which can then be filtered and processed in various ways.  A "
"configuration file written in a standard format can be used to control the "
"logging behavior of a program.  Python includes handlers that will write log "
"records to standard error or to a file or socket, send them to the system "
"log, or even e-mail them to a particular address; of course, it's also "
"possible to write your own handler classes."
msgstr ""
"Se ha añadido a Python 2.3 un paquete estándar para escribir registros, :mod:"
"`logging`.  Proporciona un mecanismo potente y flexible para generar salidas "
"de registro que pueden ser filtradas y procesadas de varias maneras.  Se "
"puede utilizar un archivo de configuración escrito en un formato estándar "
"para controlar el comportamiento de registro de un programa.  Python incluye "
"manejadores que escribirán los registros en el error estándar o en un "
"archivo o socket, los enviarán al registro del sistema, o incluso los "
"enviarán por correo electrónico a una dirección particular; por supuesto, "
"también es posible escribir tus propias clases de manejadores."

#: ../Doc/whatsnew/2.3.rst:453
msgid ""
"The :class:`Logger` class is the primary class. Most application code will "
"deal with one or more :class:`Logger` objects, each one used by a particular "
"subsystem of the application. Each :class:`Logger` is identified by a name, "
"and names are organized into a hierarchy using ``.``  as the component "
"separator. For example, you might have :class:`Logger` instances named "
"``server``, ``server.auth`` and ``server.network``.  The latter two "
"instances are below ``server`` in the hierarchy.  This means that if you "
"turn up the verbosity for ``server`` or direct ``server`` messages to a "
"different handler, the changes will also apply to records logged to ``server."
"auth`` and ``server.network``. There's also a root :class:`Logger` that's "
"the parent of all other loggers."
msgstr ""
"La clase :class:`Logger` es la clase principal. La mayoría del código de la "
"aplicación tratará con uno o más objetos :class:`Logger`, cada uno utilizado "
"por un subsistema particular de la aplicación. Cada :class:`Logger` se "
"identifica con un nombre, y los nombres se organizan en una jerarquía "
"utilizando ``.`` como separador de componentes. Por ejemplo, puedes tener "
"instancias de :class:`Logger` llamadas ``servidor``, ``servidor.auth`` y "
"``servidor.network``.  Estas dos últimas instancias están por debajo de "
"``servidor`` en la jerarquía.  Esto significa que si aumentas la verbosidad "
"de ``servidor`` o diriges los mensajes de ``servidor`` a un gestor "
"diferente, los cambios también se aplicarán a los registros de ``servidor."
"auth`` y ``servidor.network``. También hay un :class:`Logger` raíz que es el "
"padre de todos los demás loggers."

#: ../Doc/whatsnew/2.3.rst:464
msgid ""
"For simple uses, the :mod:`logging` package contains some convenience "
"functions that always use the root log::"
msgstr ""
"Para usos sencillos, el paquete :mod:`logging` contiene algunas funciones de "
"conveniencia que siempre utilizan la raíz log::"

#: ../Doc/whatsnew/2.3.rst:475 ../Doc/whatsnew/2.3.rst:500
msgid "This produces the following output::"
msgstr "Esto produce la siguiente salida::"

#: ../Doc/whatsnew/2.3.rst:481
msgid ""
"In the default configuration, informational and debugging messages are "
"suppressed and the output is sent to standard error.  You can enable the "
"display of informational and debugging messages by calling the :meth:"
"`setLevel` method on the root logger."
msgstr ""
"En la configuración por defecto, los mensajes informativos y de depuración "
"se suprimen y la salida se envía al error estándar.  Puede habilitar la "
"visualización de mensajes informativos y de depuración llamando al método :"
"meth:`setLevel` del registrador raíz."

#: ../Doc/whatsnew/2.3.rst:486
msgid ""
"Notice the :func:`warning` call's use of string formatting operators; all of "
"the functions for logging messages take the arguments ``(msg, arg1, "
"arg2, ...)`` and log the string resulting from ``msg % (arg1, arg2, ...)``."
msgstr ""
"Observe que la llamada :func:`warning` utiliza operadores de formato de "
"cadena; todas las funciones para el registro de mensajes toman los "
"argumentos ``(msg, arg1, arg2, ...)`` y registran la cadena resultante de "
"``msg % (arg1, arg2, ...)``."

#: ../Doc/whatsnew/2.3.rst:490
msgid ""
"There's also an :func:`exception` function that records the most recent "
"traceback.  Any of the other functions will also record the traceback if you "
"specify a true value for the keyword argument *exc_info*. ::"
msgstr ""
"También hay una función :func:`exception` que registra el rastro más "
"reciente.  Cualquiera de las otras funciones también registrará el rastro si "
"se especifica un valor verdadero para el argumento de la palabra clave "
"*exc_info*. ::"

#: ../Doc/whatsnew/2.3.rst:508
msgid ""
"Slightly more advanced programs will use a logger other than the root "
"logger. The ``getLogger(name)`` function is used to get a particular log, "
"creating it if it doesn't exist yet. ``getLogger(None)`` returns the root "
"logger. ::"
msgstr ""
"Los programas un poco más avanzados utilizarán un logger distinto del logger "
"raíz. La función ``getLogger(nombre)`` se utiliza para obtener un registro "
"en particular, creándolo si aún no existe. ``getLogger(None)`` retorna el "
"logger raíz. ::"

#: ../Doc/whatsnew/2.3.rst:519
msgid ""
"Log records are usually propagated up the hierarchy, so a message logged to "
"``server.auth`` is also seen by ``server`` and ``root``, but a :class:"
"`Logger` can prevent this by setting its :attr:`propagate` attribute to :"
"const:`False`."
msgstr ""
"Los registros se suelen propagar hacia arriba en la jerarquía, por lo que un "
"mensaje registrado en ``servidor.auth`` también es visto por ``servidor`` y "
"``root``, pero un :class:`Logger` puede evitar esto estableciendo su "
"atributo :attr:`propagate` a :const:`False`."

#: ../Doc/whatsnew/2.3.rst:523
msgid ""
"There are more classes provided by the :mod:`logging` package that can be "
"customized.  When a :class:`Logger` instance is told to log a message, it "
"creates a :class:`LogRecord` instance that is sent to any number of "
"different :class:`Handler` instances.  Loggers and handlers can also have an "
"attached list of filters, and each filter can cause the :class:`LogRecord` "
"to be ignored or can modify the record before passing it along.  When "
"they're finally output, :class:`LogRecord` instances are converted to text "
"by a :class:`Formatter` class.  All of these classes can be replaced by your "
"own specially written classes."
msgstr ""
"Hay más clases proporcionadas por el paquete :mod:`logging` que se pueden "
"personalizar. Cuando se le indica a una instancia :class:`Logger` que "
"registre un mensaje, crea una instancia :class:`LogRecord` que se envía a "
"cualquier cantidad de instancias :class:`Handler` diferentes. Los "
"registradores y los controladores también pueden tener una lista adjunta de "
"filtros, y cada filtro puede hacer que se ignore el :class:`LogRecord` o "
"puede modificar el registro antes de pasarlo. Cuando finalmente se emiten, "
"las instancias :class:`LogRecord` se convierten en texto mediante una clase :"
"class:`Formatter`. Todas estas clases pueden ser reemplazadas por sus "
"propias clases especialmente escritas."

#: ../Doc/whatsnew/2.3.rst:533
msgid ""
"With all of these features the :mod:`logging` package should provide enough "
"flexibility for even the most complicated applications.  This is only an "
"incomplete overview of its features, so please see the package's reference "
"documentation for all of the details.  Reading :pep:`282` will also be "
"helpful."
msgstr ""
"Con todas estas características, el paquete :mod:`logging` debería "
"proporcionar suficiente flexibilidad incluso para las aplicaciones más "
"complicadas.  Esto es sólo un resumen incompleto de sus características, así "
"que por favor consulte la documentación de referencia del paquete para todos "
"los detalles.  La lectura de :pep:`282` también será útil."

#: ../Doc/whatsnew/2.3.rst:541
msgid ":pep:`282` - A Logging System"
msgstr ":pep:`282` - Un sistema de registro"

#: ../Doc/whatsnew/2.3.rst:542
msgid "Written by Vinay Sajip and Trent Mick; implemented by Vinay Sajip."
msgstr "Escrito por Vinay Sajip y Trent Mick; implementado por Vinay Sajip."

#: ../Doc/whatsnew/2.3.rst:550
msgid "PEP 285: A Boolean Type"
msgstr "PEP 285: Un tipo booleano"

#: ../Doc/whatsnew/2.3.rst:552
msgid ""
"A Boolean type was added to Python 2.3.  Two new constants were added to "
"the :mod:`__builtin__` module, :const:`True` and :const:`False`.  (:const:"
"`True` and :const:`False` constants were added to the built-ins in Python "
"2.2.1, but the 2.2.1 versions are simply set to integer values of 1 and 0 "
"and aren't a different type.)"
msgstr ""
"Se ha añadido un tipo booleano a Python 2.3.  Se añadieron dos nuevas "
"constantes al módulo :mod:`__builtin__`, :const:`True` y :const:`False`.  "
"(Las constantes :const:`True` y :const:`False` se añadieron a los módulos "
"incorporados en Python 2.2.1, pero las versiones de 2.2.1 se ajustan "
"simplemente a valores enteros de 1 y 0 y no son un tipo diferente)"

#: ../Doc/whatsnew/2.3.rst:558
msgid ""
"The type object for this new type is named :class:`bool`; the constructor "
"for it takes any Python value and converts it to :const:`True` or :const:"
"`False`. ::"
msgstr ""
"El objeto de tipo para este nuevo tipo se denomina :class:`bool`; su "
"constructor toma cualquier valor de Python y lo convierte en :const:`True` "
"o :const:`False`. ::"

#: ../Doc/whatsnew/2.3.rst:570
msgid ""
"Most of the standard library modules and built-in functions have been "
"changed to return Booleans. ::"
msgstr ""
"La mayoría de los módulos de la biblioteca estándar y las funciones "
"incorporadas se han modificado para retornar booleanos. ::"

#: ../Doc/whatsnew/2.3.rst:581
msgid ""
"Python's Booleans were added with the primary goal of making code clearer.  "
"For example, if you're reading a function and encounter the statement "
"``return 1``, you might wonder whether the ``1`` represents a Boolean truth "
"value, an index, or a coefficient that multiplies some other quantity.  If "
"the statement is ``return True``, however, the meaning of the return value "
"is quite clear."
msgstr ""
"Los booleanos de Python se añadieron con el objetivo principal de hacer el "
"código más claro.  Por ejemplo, si estás leyendo una función y te encuentras "
"con la sentencia ``return 1``, podrías preguntarte si el ``1`` representa un "
"valor de verdad booleano, un índice o un coeficiente que multiplica alguna "
"otra cantidad.  Sin embargo, si la sentencia es ``return True``, el "
"significado del valor de retorno es bastante claro."

#: ../Doc/whatsnew/2.3.rst:587
msgid ""
"Python's Booleans were *not* added for the sake of strict type-checking.  A "
"very strict language such as Pascal would also prevent you performing "
"arithmetic with Booleans, and would require that the expression in an :"
"keyword:`if` statement always evaluate to a Boolean result.  Python is not "
"this strict and never will be, as :pep:`285` explicitly says.  This means "
"you can still use any expression in an :keyword:`!if` statement, even ones "
"that evaluate to a list or tuple or some random object.  The Boolean type is "
"a subclass of the :class:`int` class so that arithmetic using a Boolean "
"still works. ::"
msgstr ""
"Los booleanos de Python *no* se añadieron en aras de una comprobación de "
"tipos estricta.  Un lenguaje muy estricto como Pascal también le impediría "
"realizar aritmética con booleanos, y requeriría que la expresión en una "
"declaración :keyword:`if` siempre se evaluara a un resultado booleano.  "
"Python no es tan estricto y nunca lo será, como dice explícitamente :pep:"
"`285`.  Esto significa que puede utilizar cualquier expresión en una "
"sentencia :keyword:`!if`, incluso las que se evalúan a una lista o tupla o "
"algún objeto aleatorio.  El tipo Booleano es una subclase de la clase :class:"
"`int` por lo que la aritmética que utiliza un Booleano sigue funcionando. ::"

#: ../Doc/whatsnew/2.3.rst:605
msgid ""
"To sum up :const:`True` and :const:`False` in a sentence: they're "
"alternative ways to spell the integer values 1 and 0, with the single "
"difference that :func:`str` and :func:`repr` return the strings ``'True'`` "
"and ``'False'`` instead of ``'1'`` and ``'0'``."
msgstr ""
"Para resumir :const:`True` and :const:`False`  en una frase: son formas "
"alternativas de deletrear los valores enteros 1 y 0, con la única diferencia "
"de que :func:`str` y :func:`repr` retornan las cadenas ``Verdadero`` y "
"``Falso`` en lugar de ``1`` y ``0``."

#: ../Doc/whatsnew/2.3.rst:613
msgid ":pep:`285` - Adding a bool type"
msgstr ":pep:`285` - Añadir un tipo booleano"

#: ../Doc/whatsnew/2.3.rst:614
msgid "Written and implemented by GvR."
msgstr "Escrito y ejecutado por GvR."

#: ../Doc/whatsnew/2.3.rst:620
msgid "PEP 293: Codec Error Handling Callbacks"
msgstr "PEP 293: Llamadas de retorno para el manejo de errores del códec"

#: ../Doc/whatsnew/2.3.rst:622
msgid ""
"When encoding a Unicode string into a byte string, unencodable characters "
"may be encountered.  So far, Python has allowed specifying the error "
"processing as either \"strict\" (raising :exc:`UnicodeError`), "
"\"ignore\" (skipping the character), or \"replace\" (using a question mark "
"in the output string), with \"strict\" being the default behavior. It may be "
"desirable to specify alternative processing of such errors, such as "
"inserting an XML character reference or HTML entity reference into the "
"converted string."
msgstr ""
"Al codificar una cadena Unicode en una cadena de bytes, pueden encontrarse "
"caracteres no codificables.  Hasta ahora, Python ha permitido especificar el "
"procesamiento del error como \"estricto\" (lanzando :exc:`UnicodeError`), "
"\"ignorar\" (saltando el carácter), o \"reemplazar\" (usando un signo de "
"interrogación en la cadena de salida), siendo \"estricto\" el comportamiento "
"por defecto. Puede ser deseable especificar un procesamiento alternativo de "
"tales errores, como insertar una referencia de carácter XML o una referencia "
"de entidad HTML en la cadena convertida."

#: ../Doc/whatsnew/2.3.rst:630
msgid ""
"Python now has a flexible framework to add different processing strategies.  "
"New error handlers can be added with :func:`codecs.register_error`, and "
"codecs then can access the error handler with :func:`codecs.lookup_error`. "
"An equivalent C API has been added for codecs written in C. The error "
"handler gets the necessary state information such as the string being "
"converted, the position in the string where the error was detected, and the "
"target encoding.  The handler can then either raise an exception or return a "
"replacement string."
msgstr ""
"Python tiene ahora un marco flexible para añadir diferentes estrategias de "
"procesamiento.  Se pueden añadir nuevos manejadores de errores con :func:"
"`codecs.register_error`, y los códecs pueden acceder al manejador de errores "
"con :func:`codecs.lookup_error`. Se ha añadido una API en C equivalente para "
"los códecs escritos en C. El gestor de errores obtiene la información de "
"estado necesaria, como la cadena que se está convirtiendo, la posición en la "
"cadena donde se ha detectado el error y la codificación de destino.  El "
"controlador puede entonces lanzar una excepción o retornar una cadena de "
"reemplazo."

#: ../Doc/whatsnew/2.3.rst:638
msgid ""
"Two additional error handlers have been implemented using this framework: "
"\"backslashreplace\" uses Python backslash quoting to represent unencodable "
"characters and \"xmlcharrefreplace\" emits XML character references."
msgstr ""
"Se han implementado dos manejadores de error adicionales utilizando este "
"marco: \"backslashreplace\" utiliza las comillas de barra invertida de "
"Python para representar los caracteres no codificables y "
"\"xmlcharrefreplace\" emite referencias de caracteres XML."

#: ../Doc/whatsnew/2.3.rst:645
msgid ":pep:`293` - Codec Error Handling Callbacks"
msgstr ":pep:`293` - Retrollamadas de manejo de errores del códec"

#: ../Doc/whatsnew/2.3.rst:646
msgid "Written and implemented by Walter Dörwald."
msgstr "Escrito y ejecutado por Walter Dörwald."

#: ../Doc/whatsnew/2.3.rst:654
msgid "PEP 301: Package Index and Metadata for Distutils"
msgstr "PEP 301: Índice de paquetes y metadatos para Distutils"

#: ../Doc/whatsnew/2.3.rst:656
msgid ""
"Support for the long-requested Python catalog makes its first appearance in "
"2.3."
msgstr ""
"La compatibilidad con el catálogo de Python, largamente solicitada, hace su "
"primera aparición en 2.3."

#: ../Doc/whatsnew/2.3.rst:658
msgid ""
"The heart of the catalog is the new Distutils :command:`register` command. "
"Running ``python setup.py register`` will collect the metadata describing a "
"package, such as its name, version, maintainer, description, &c., and send "
"it to a central catalog server.  The resulting catalog is available from "
"https://pypi.org."
msgstr ""
"El corazón del catálogo es el nuevo comando :command:`register` de "
"Distutils. Ejecutando ``python setup.py register`` se recogen los metadatos "
"que describen un paquete, como su nombre, versión, mantenedor, descripción, "
"etc., y se envían a un servidor de catálogo central.  El catálogo resultante "
"está disponible en https://pypi.org."

#: ../Doc/whatsnew/2.3.rst:664
msgid ""
"To make the catalog a bit more useful, a new optional *classifiers* keyword "
"argument has been added to the Distutils :func:`setup` function.  A list of "
"`Trove <http://catb.org/~esr/trove/>`_-style strings can be supplied to help "
"classify the software."
msgstr ""
"Para hacer el catálogo un poco más útil, se ha añadido un nuevo argumento "
"opcional de palabra clave *clasificadores* a la función Distutils :func:"
"`setup`.  Se puede suministrar una lista de cadenas de estilo `Trove <http://"
"catb.org/~esr/trove/>`_ para ayudar a clasificar el software."

#: ../Doc/whatsnew/2.3.rst:669
msgid ""
"Here's an example :file:`setup.py` with classifiers, written to be "
"compatible with older versions of the Distutils::"
msgstr ""
"Aquí hay un ejemplo :file:`setup.py` con clasificadores, escrito para que "
"sea compatible con las versiones más antiguas de Distutils::"

#: ../Doc/whatsnew/2.3.rst:688
msgid ""
"The full list of classifiers can be obtained by running  ``python setup.py "
"register --list-classifiers``."
msgstr ""
"La lista completa de clasificadores se puede obtener ejecutando ``python "
"setup.py register --list-classifiers``."

#: ../Doc/whatsnew/2.3.rst:694
msgid ":pep:`301` - Package Index and Metadata for Distutils"
msgstr ":pep:`301` - Índice de paquetes y metadatos para Distutils"

#: ../Doc/whatsnew/2.3.rst:695
msgid "Written and implemented by Richard Jones."
msgstr "Escrito y ejecutado por Richard Jones."

#: ../Doc/whatsnew/2.3.rst:703
msgid "PEP 302: New Import Hooks"
msgstr "PEP 302: Nuevos ganchos de importación"

#: ../Doc/whatsnew/2.3.rst:705
msgid ""
"While it's been possible to write custom import hooks ever since the :mod:"
"`ihooks` module was introduced in Python 1.3, no one has ever been really "
"happy with it because writing new import hooks is difficult and messy.  "
"There have been various proposed alternatives such as the :mod:`imputil` "
"and :mod:`iu` modules, but none of them has ever gained much acceptance, and "
"none of them were easily usable from C code."
msgstr ""
"Aunque ha sido posible escribir ganchos de importación personalizados desde "
"que se introdujo el módulo :mod:`ihooks` en Python 1.3, nadie ha estado "
"nunca realmente contento con él porque escribir nuevos ganchos de "
"importación es difícil y complicado.  Se han propuesto varias alternativas, "
"como los módulos :mod:`imputil` y :mod:`iu`, pero ninguno de ellos ha tenido "
"mucha aceptación, y ninguno era fácilmente utilizable desde el código C."

#: ../Doc/whatsnew/2.3.rst:712
msgid ""
":pep:`302` borrows ideas from its predecessors, especially from Gordon "
"McMillan's :mod:`iu` module.  Three new items  are added to the :mod:`sys` "
"module:"
msgstr ""
":pep:`302` toma prestadas ideas de sus predecesores, especialmente del "
"módulo :mod:`iu` de Gordon McMillan.  Se añaden tres nuevos elementos al "
"módulo :mod:`sys`:"

#: ../Doc/whatsnew/2.3.rst:716
msgid ""
"``sys.path_hooks`` is a list of callable objects; most  often they'll be "
"classes.  Each callable takes a string containing a path and either returns "
"an importer object that will handle imports from this path or raises an :exc:"
"`ImportError` exception if it can't handle this path."
msgstr ""
"``sys.path_hooks`` es una lista de objetos invocables; la mayoría de las "
"veces serán clases.  Cada llamada toma una cadena que contiene una ruta y "
"retorna un objeto importador que manejará las importaciones desde esta ruta "
"o lanza una excepción :exc:`ImportError` si no puede manejar esta ruta."

#: ../Doc/whatsnew/2.3.rst:721
msgid ""
"``sys.path_importer_cache`` caches importer objects for each path, so ``sys."
"path_hooks`` will only need to be traversed once for each path."
msgstr ""
"``sys.path_importer_cache`` almacena en caché los objetos del importador "
"para cada ruta, por lo que ``sys.path_hooks`` sólo tendrá que ser recorrido "
"una vez para cada ruta."

#: ../Doc/whatsnew/2.3.rst:724
msgid ""
"``sys.meta_path`` is a list of importer objects that will be traversed "
"before ``sys.path`` is checked.  This list is initially empty, but user code "
"can add objects to it.  Additional built-in and frozen modules can be "
"imported by an object added to this list."
msgstr ""
"``sys.meta_path`` es una lista de objetos importadores que se recorrerán "
"antes de comprobar ``sys.path``.  Esta lista está inicialmente vacía, pero "
"el código de usuario puede añadir objetos a ella.  Los módulos adicionales "
"incorporados y congelados pueden ser importados por un objeto añadido a esta "
"lista."

#: ../Doc/whatsnew/2.3.rst:729
msgid ""
"Importer objects must have a single method, ``find_module(fullname, "
"path=None)``.  *fullname* will be a module or package name, e.g. ``string`` "
"or ``distutils.core``.  :meth:`!find_module` must return a loader object "
"that has a single method, ``load_module(fullname)``, that creates and "
"returns the corresponding module object."
msgstr ""
"Los objetos importadores deben tener un único método, "
"``find_module(fullname, path=None)``.  *fullname* será un nombre de módulo o "
"paquete, por ejemplo ``string`` o ``distutils.core``. :meth:`!find_module` "
"debe retornar un objeto cargador que tenga un único método, "
"``load_module(fullname)``, que cree y retorne el objeto módulo "
"correspondiente."

#: ../Doc/whatsnew/2.3.rst:735
msgid ""
"Pseudo-code for Python's new import logic, therefore, looks something like "
"this (simplified a bit; see :pep:`302` for the full details)::"
msgstr ""
"Por lo tanto, el pseudocódigo de la nueva lógica de importación de Python es "
"algo así (simplificado un poco; véase :pep:`302` para los detalles "
"completos)::"

#: ../Doc/whatsnew/2.3.rst:760
msgid ":pep:`302` - New Import Hooks"
msgstr ":pep:`302` - Nuevos ganchos de importación"

#: ../Doc/whatsnew/2.3.rst:761
msgid ""
"Written by Just van Rossum and Paul Moore. Implemented by Just van Rossum."
msgstr ""
"Escrito por Just van Rossum y Paul Moore. Implementado por Just van Rossum."

#: ../Doc/whatsnew/2.3.rst:769
msgid "PEP 305: Comma-separated Files"
msgstr "PEP 305: Archivos separados por comas"

#: ../Doc/whatsnew/2.3.rst:771
msgid ""
"Comma-separated files are a format frequently used for exporting data from "
"databases and spreadsheets.  Python 2.3 adds a parser for comma-separated "
"files."
msgstr ""
"Los archivos separados por comas son un formato frecuentemente utilizado "
"para exportar datos de bases de datos y hojas de cálculo.  Python 2.3 añade "
"un analizador de archivos separados por comas."

#: ../Doc/whatsnew/2.3.rst:774
msgid "Comma-separated format is deceptively simple at first glance::"
msgstr ""
"El formato separado por comas es engañosamente sencillo a primera vista::"

#: ../Doc/whatsnew/2.3.rst:778
msgid ""
"Read a line and call ``line.split(',')``: what could be simpler? But toss in "
"string data that can contain commas, and things get more complicated::"
msgstr ""
"Leer una línea y llamar a ``line.split(',')``: ¿qué puede ser más sencillo? "
"Pero si se añaden datos de cadena que pueden contener comas, las cosas se "
"complican::"

#: ../Doc/whatsnew/2.3.rst:783
msgid ""
"A big ugly regular expression can parse this, but using the new  :mod:`csv` "
"package is much simpler::"
msgstr ""
"Una expresión regular grande y fea puede analizar esto, pero usar el nuevo "
"paquete :mod:`csv` es mucho más sencillo::"

#: ../Doc/whatsnew/2.3.rst:793
msgid ""
"The :func:`reader` function takes a number of different options. The field "
"separator isn't limited to the comma and can be changed to any character, "
"and so can the quoting and line-ending characters."
msgstr ""
"La función :func:`reader` admite varias opciones. El separador de campos no "
"se limita a la coma y puede cambiarse por cualquier carácter, al igual que "
"las comillas y el final de línea."

#: ../Doc/whatsnew/2.3.rst:797
msgid ""
"Different dialects of comma-separated files can be defined and registered; "
"currently there are two dialects, both used by Microsoft Excel. A separate :"
"class:`csv.writer` class will generate comma-separated files from a "
"succession of tuples or lists, quoting strings that contain the delimiter."
msgstr ""
"Se pueden definir y registrar diferentes dialectos de archivos separados por "
"comas; actualmente hay dos dialectos, ambos utilizados por Microsoft Excel. "
"Una clase :class:`csv.writer` independiente generará archivos separados por "
"comas a partir de una sucesión de tuplas o listas, citando cadenas que "
"contengan el delimitador."

#: ../Doc/whatsnew/2.3.rst:806
msgid ":pep:`305` - CSV File API"
msgstr ":pep:`305` - API de archivos CSV"

#: ../Doc/whatsnew/2.3.rst:806
msgid ""
"Written and implemented  by Kevin Altis, Dave Cole, Andrew McNamara, Skip "
"Montanaro, Cliff Wells."
msgstr ""
"Escrito y realizado por Kevin Altis, Dave Cole, Andrew McNamara, Skip "
"Montanaro, Cliff Wells."

#: ../Doc/whatsnew/2.3.rst:815
msgid "PEP 307: Pickle Enhancements"
msgstr "PEP 307: Mejoras en Pickle"

#: ../Doc/whatsnew/2.3.rst:817
msgid ""
"The :mod:`pickle` and :mod:`cPickle` modules received some attention during "
"the 2.3 development cycle.  In 2.2, new-style classes could be pickled "
"without difficulty, but they weren't pickled very compactly; :pep:`307` "
"quotes a trivial example where a new-style class results in a pickled string "
"three times longer than that for a classic class."
msgstr ""
"Los módulos :mod:`pickle` y :mod:`cPickle` recibieron cierta atención "
"durante el ciclo de desarrollo de la 2.3.  En 2.2, las clases de estilo "
"nuevo podían ser desempaquetadas sin dificultad, pero no se desempaquetaba "
"de forma muy compacta; :pep:`307` cita un ejemplo trivial en el que una "
"clase de estilo nuevo da lugar a una cadena desempaquetada tres veces más "
"larga que la de una clase clásica."

#: ../Doc/whatsnew/2.3.rst:823
msgid ""
"The solution was to invent a new pickle protocol.  The :func:`pickle.dumps` "
"function has supported a text-or-binary flag  for a long time.  In 2.3, this "
"flag is redefined from a Boolean to an integer: 0 is the old text-mode "
"pickle format, 1 is the old binary format, and now 2 is a new 2.3-specific "
"format.  A new constant, :const:`pickle.HIGHEST_PROTOCOL`, can be used to "
"select the fanciest protocol available."
msgstr ""
"La solución fue inventar un nuevo protocolo pickle.  La función :func:"
"`pickle.dumps` soporta desde hace tiempo una bandera de texto o binario.  En "
"la versión 2.3, esta bandera se ha redefinido, pasando de ser un booleano a "
"un entero: 0 es el antiguo formato pickle en modo texto, 1 es el antiguo "
"formato binario, y ahora 2 es un nuevo formato específico de 2.3.  Una nueva "
"constante, :const:`pickle.HIGHEST_PROTOCOL`, puede utilizarse para "
"seleccionar el protocolo más elegante disponible."

#: ../Doc/whatsnew/2.3.rst:830
msgid ""
"Unpickling is no longer considered a safe operation.  2.2's :mod:`pickle` "
"provided hooks for trying to prevent unsafe classes from being unpickled "
"(specifically, a :attr:`__safe_for_unpickling__` attribute), but none of "
"this code was ever audited and therefore it's all been ripped out in 2.3.  "
"You should not unpickle untrusted data in any version of Python."
msgstr ""
"El unpickling ya no se considera una operación segura. El :mod:`pickle` de "
"la versión 2.2 proporcionaba ganchos para tratar de evitar que las clases no "
"seguras fueran deserializadas (específicamente, un atributo :attr:"
"`__safe_for_unpickling__`), pero nada de este código fue nunca auditado y "
"por lo tanto todo ha sido eliminado en la versión 2.3.  No se debe "
"deserializar datos no confiables en ninguna versión de Python."

#: ../Doc/whatsnew/2.3.rst:836
msgid ""
"To reduce the pickling overhead for new-style classes, a new interface for "
"customizing pickling was added using three special methods: :meth:"
"`__getstate__`, :meth:`__setstate__`, and :meth:`__getnewargs__`.  Consult :"
"pep:`307` for the full semantics  of these methods."
msgstr ""
"Para reducir la sobrecarga de pickling de las clases de estilo nuevo, se ha "
"añadido una nueva interfaz para personalizar el pickling mediante tres "
"métodos especiales: :meth:`__getstate__`, :meth:`__setstate__`, y :meth:"
"`__getnewargs__`.  Consulte :pep:`307` para conocer la semántica completa de "
"estos métodos."

#: ../Doc/whatsnew/2.3.rst:841
msgid ""
"As a way to compress pickles yet further, it's now possible to use integer "
"codes instead of long strings to identify pickled classes. The Python "
"Software Foundation will maintain a list of standardized codes; there's also "
"a range of codes for private use.  Currently no codes have been specified."
msgstr ""
"Como forma de comprimir aún más los pickles, ahora es posible utilizar "
"códigos enteros en lugar de cadenas largas para identificar las clases "
"serializadas. La Python Software Foundation mantendrá una lista de códigos "
"estandarizados; también hay una gama de códigos para uso privado.  "
"Actualmente no se ha especificado ningún código."

#: ../Doc/whatsnew/2.3.rst:849
msgid ":pep:`307` - Extensions to the pickle protocol"
msgstr ":pep:`307` - Extensiones del protocolo pickle"

#: ../Doc/whatsnew/2.3.rst:850
msgid "Written and implemented  by Guido van Rossum and Tim Peters."
msgstr "Escrito y ejecutado por Guido van Rossum y Tim Peters."

#: ../Doc/whatsnew/2.3.rst:858
msgid "Extended Slices"
msgstr "Rebanadas ampliadas"

#: ../Doc/whatsnew/2.3.rst:860
msgid ""
"Ever since Python 1.4, the slicing syntax has supported an optional third "
"\"step\" or \"stride\" argument.  For example, these are all legal Python "
"syntax: ``L[1:10:2]``, ``L[:-1:1]``, ``L[::-1]``.  This was added to Python "
"at the request of the developers of Numerical Python, which uses the third "
"argument extensively.  However, Python's built-in list, tuple, and string "
"sequence types have never supported this feature, raising a :exc:`TypeError` "
"if you tried it. Michael Hudson contributed a patch to fix this shortcoming."
msgstr ""
"Desde la versión 1.4 de Python, la sintaxis de corte admite un tercer "
"argumento opcional \"paso\" o \"zancada\".  Por ejemplo, estas son todas las "
"sintaxis legales de Python: ``L[1:10:2]``, ``L[:-1:1]``, ``L[::-1]``.  Esto "
"se añadió a Python a petición de los desarrolladores de Numerical Python, "
"que utiliza ampliamente el tercer argumento.  Sin embargo, los tipos de "
"secuencias de listas, tuplas y cadenas incorporados en Python nunca han "
"soportado esta característica, y lanzan un :exc:`TypeError` si lo intentas. "
"Michael Hudson ha contribuido con un parche para solucionar este problema."

#: ../Doc/whatsnew/2.3.rst:868
msgid ""
"For example, you can now easily extract the elements of a list that have "
"even indexes::"
msgstr ""
"Por ejemplo, ahora puede extraer fácilmente los elementos de una lista que "
"tengan índices pares::"

#: ../Doc/whatsnew/2.3.rst:875
msgid ""
"Negative values also work to make a copy of the same list in reverse order::"
msgstr ""
"Los valores negativos también sirven para hacer una copia de la misma lista "
"en orden inverso::"

#: ../Doc/whatsnew/2.3.rst:880
msgid "This also works for tuples, arrays, and strings::"
msgstr "Esto también funciona para tuplas, arrays y cadenas::"

#: ../Doc/whatsnew/2.3.rst:888
msgid ""
"If you have a mutable sequence such as a list or an array you can assign to "
"or delete an extended slice, but there are some differences between "
"assignment to extended and regular slices.  Assignment to a regular slice "
"can be used to change the length of the sequence::"
msgstr ""
"Si tienes una secuencia mutable, como una lista o un array, puedes asignar o "
"eliminar una rebanada extendida, pero hay algunas diferencias entre la "
"asignación a rebanadas extendidas y regulares.  La asignación a una rebanada "
"regular se puede utilizar para cambiar la longitud de la secuencia::"

#: ../Doc/whatsnew/2.3.rst:900
msgid ""
"Extended slices aren't this flexible.  When assigning to an extended slice, "
"the list on the right hand side of the statement must contain the same "
"number of items as the slice it is replacing::"
msgstr ""
"Las rebanadas extendidas no son tan flexibles.  Cuando se asigna a una "
"rebanada extendida, la lista a la derecha de la declaración debe contener el "
"mismo número de elementos que la rebanada que está reemplazando::"

#: ../Doc/whatsnew/2.3.rst:917
msgid "Deletion is more straightforward::"
msgstr "La eliminación es más sencilla::"

#: ../Doc/whatsnew/2.3.rst:928
msgid ""
"One can also now pass slice objects to the :meth:`__getitem__` methods of "
"the built-in sequences::"
msgstr ""
"Ahora también se pueden pasar objetos slice a los métodos :meth:"
"`__getitem__` de las secuencias incorporadas::"

#: ../Doc/whatsnew/2.3.rst:934
msgid "Or use slice objects directly in subscripts::"
msgstr "O utilizar los objetos de corte directamente en los subíndices::"

#: ../Doc/whatsnew/2.3.rst:939
msgid ""
"To simplify implementing sequences that support extended slicing, slice "
"objects now have a method ``indices(length)`` which, given the length of a "
"sequence, returns a ``(start, stop, step)`` tuple that can be passed "
"directly to :func:`range`. :meth:`indices` handles omitted and out-of-bounds "
"indices in a manner consistent with regular slices (and this innocuous "
"phrase hides a welter of confusing details!).  The method is intended to be "
"used like this::"
msgstr ""
"Para simplificar la implementación de secuencias que soportan el corte "
"extendido, los objetos slice tienen ahora un método ``indices(length)`` que, "
"dada la longitud de una secuencia, retorna una tupla ``(start, stop, step)`` "
"que puede pasarse directamente a :func:`range`. :meth:`indices` maneja los "
"índices omitidos y los que están fuera de los límites de una manera "
"consistente con los slices regulares (¡y esta frase inocua esconde un montón "
"de detalles confusos!).  El método está pensado para ser utilizado así::"

#: ../Doc/whatsnew/2.3.rst:957
msgid ""
"From this example you can also see that the built-in :class:`slice` object "
"is now the type object for the slice type, and is no longer a function.  "
"This is consistent with Python 2.2, where :class:`int`, :class:`str`, etc., "
"underwent the same change."
msgstr ""
"En este ejemplo también se puede ver que el objeto incorporado :class:"
"`slice` es ahora el objeto tipo para el tipo slice, y ya no es una función.  "
"Esto es consistente con Python 2.2, donde :class:`int`, :class:`str`, etc., "
"sufrieron el mismo cambio."

#: ../Doc/whatsnew/2.3.rst:966
msgid "Other Language Changes"
msgstr "Otros cambios en el lenguaje"

#: ../Doc/whatsnew/2.3.rst:968
msgid ""
"Here are all of the changes that Python 2.3 makes to the core Python "
"language."
msgstr ""
"Estos son todos los cambios que Python 2.3 introduce en el núcleo del "
"lenguaje Python."

#: ../Doc/whatsnew/2.3.rst:970
msgid ""
"The :keyword:`yield` statement is now always a keyword, as described in "
"section :ref:`section-generators` of this document."
msgstr ""
"La expresión :keyword:`yield` es ahora siempre una palabra clave, como se "
"describe en la sección :ref:`section-generators` de este documento."

#: ../Doc/whatsnew/2.3.rst:973
msgid ""
"A new built-in function :func:`enumerate` was added, as described in "
"section :ref:`section-enumerate` of this document."
msgstr ""
"Se ha añadido una nueva función incorporada :func:`enumerate`, como se "
"describe en la sección :ref:`section-enumerate` de este documento."

#: ../Doc/whatsnew/2.3.rst:976
msgid ""
"Two new constants, :const:`True` and :const:`False` were added along with "
"the built-in :class:`bool` type, as described in section :ref:`section-bool` "
"of this document."
msgstr ""
"Se han añadido dos nuevas constantes, :const:`True` y :const:`False` junto "
"con el tipo incorporado :class:`bool`, como se describe en la sección :ref:"
"`section-bool` de este documento."

#: ../Doc/whatsnew/2.3.rst:980
msgid ""
"The :func:`int` type constructor will now return a long integer instead of "
"raising an :exc:`OverflowError` when a string or floating-point number is "
"too large to fit into an integer.  This can lead to the paradoxical result "
"that ``isinstance(int(expression), int)`` is false, but that seems unlikely "
"to cause problems in practice."
msgstr ""
"El constructor de tipo :func:`int` ahora retornará un entero largo en lugar "
"de lanzar un :exc:`OverflowError` cuando una cadena o un número de punto "
"flotante es demasiado grande para caber en un entero.  Esto puede llevar al "
"resultado paradójico de que ``isinstance(int(expresión), int)`` sea falso, "
"pero parece poco probable que cause problemas en la práctica."

#: ../Doc/whatsnew/2.3.rst:986
msgid ""
"Built-in types now support the extended slicing syntax, as described in "
"section :ref:`section-slices` of this document."
msgstr ""
"Los tipos incorporados ahora soportan la sintaxis de rebanado extendida, "
"como se describe en la sección :ref:`section-slices` de este documento."

#: ../Doc/whatsnew/2.3.rst:989
msgid ""
"A new built-in function, ``sum(iterable, start=0)``,  adds up the numeric "
"items in the iterable object and returns their sum.  :func:`sum` only "
"accepts numbers, meaning that you can't use it to concatenate a bunch of "
"strings. (Contributed by Alex Martelli.)"
msgstr ""
"Una nueva función incorporada, ``suma(iterable, start=0)``, suma los "
"elementos numéricos en el objeto iterable y retorna su suma. :func:`suma` "
"sólo acepta números, lo que significa que no se puede utilizar para "
"concatenar un montón de cadenas. (Contribución de Alex Martelli)"

#: ../Doc/whatsnew/2.3.rst:994
msgid ""
"``list.insert(pos, value)`` used to  insert *value* at the front of the list "
"when *pos* was negative.  The behaviour has now been changed to be "
"consistent with slice indexing, so when *pos* is -1 the value will be "
"inserted before the last element, and so forth."
msgstr ""
"``list.insert(pos, valor)`` solía insertar *valor* al principio de la lista "
"cuando *pos* era negativo.  El comportamiento ha sido cambiado para ser "
"consistente con la indexación de las rebanadas, así que cuando *pos* es -1 "
"el valor será insertado antes del último elemento, y así sucesivamente."

#: ../Doc/whatsnew/2.3.rst:999
msgid ""
"``list.index(value)``, which searches for *value*  within the list and "
"returns its index, now takes optional  *start* and *stop* arguments to limit "
"the search to  only part of the list."
msgstr ""
"``list.index(value)``, que busca *valor* dentro de la lista y retorna su "
"índice, ahora toma los argumentos opcionales *start* y *stop* para limitar "
"la búsqueda sólo a una parte de la lista."

#: ../Doc/whatsnew/2.3.rst:1003
msgid ""
"Dictionaries have a new method, ``pop(key[, *default*])``, that returns the "
"value corresponding to *key* and removes that key/value pair from the "
"dictionary.  If the requested key isn't present in the dictionary, *default* "
"is returned if it's specified and :exc:`KeyError` raised if it isn't. ::"
msgstr ""
"Los diccionarios tienen un nuevo método, ``pop(key[, *default*])``, que "
"retorna el valor correspondiente a *key* y elimina ese par clave/valor del "
"diccionario.  Si la clave solicitada no está presente en el diccionario, se "
"retorna *default* si está especificada y se lanza :exc:`KeyError` si no lo "
"está:"

#: ../Doc/whatsnew/2.3.rst:1025
msgid ""
"There's also a new class method,  ``dict.fromkeys(iterable, value)``, that "
"creates a dictionary with keys taken from the supplied iterator *iterable* "
"and all values set to *value*, defaulting to ``None``."
msgstr ""
"También hay un nuevo método de clase, ``dict.fromkeys(iterable, value)``, "
"que crea un diccionario con claves tomadas del iterador *iterable* "
"suministrado y todos los valores establecidos a *value*, por defecto a "
"``None``."

#: ../Doc/whatsnew/2.3.rst:1029
msgid "(Patches contributed by Raymond Hettinger.)"
msgstr "(Parches aportados por Raymond Hettinger)"

#: ../Doc/whatsnew/2.3.rst:1031
msgid ""
"Also, the :func:`dict` constructor now accepts keyword arguments to simplify "
"creating small dictionaries::"
msgstr ""
"Además, el constructor :func:`dict` ahora acepta argumentos de palabras "
"clave para simplificar la creación de pequeños diccionarios::"

#: ../Doc/whatsnew/2.3.rst:1037
msgid "(Contributed by Just van Rossum.)"
msgstr "(Contribución de Just van Rossum.)"

#: ../Doc/whatsnew/2.3.rst:1039
msgid ""
"The :keyword:`assert` statement no longer checks the ``__debug__`` flag, so "
"you can no longer disable assertions by assigning to ``__debug__``. Running "
"Python with the :option:`-O` switch will still generate code that doesn't "
"execute any assertions."
msgstr ""
"La expresión :keyword:`assert` ya no comprueba la bandera ``debug__``, por "
"lo que ya no se pueden desactivar las aserciones asignando a ``__debug__``. "
"Ejecutar Python con la opción :option:`-O` seguirá generando código que no "
"ejecute ninguna aserción."

#: ../Doc/whatsnew/2.3.rst:1044
msgid ""
"Most type objects are now callable, so you can use them to create new "
"objects such as functions, classes, and modules.  (This means that the :mod:"
"`new` module can be deprecated in a future Python version, because you can "
"now use the type objects available in the :mod:`types` module.) For example, "
"you can create a new module object with the following code:"
msgstr ""
"La mayoría de los objetos de tipo son ahora invocables, por lo que puedes "
"usarlos para crear nuevos objetos como funciones, clases y módulos.  (Esto "
"significa que el módulo :mod:`new` puede quedar obsoleto en una futura "
"versión de Python, porque ahora puedes utilizar los objetos de tipo "
"disponibles en el módulo :mod:`types`) Por ejemplo, puede crear un nuevo "
"objeto de módulo con el siguiente código:"

#: ../Doc/whatsnew/2.3.rst:1059
msgid ""
"A new warning, :exc:`PendingDeprecationWarning` was added to indicate "
"features which are in the process of being deprecated.  The warning will "
"*not* be printed by default.  To check for use of features that will be "
"deprecated in the future, supply :option:`-Walways::"
"PendingDeprecationWarning:: <-W>` on the command line or use :func:`warnings."
"filterwarnings`."
msgstr ""
"Se ha añadido una nueva advertencia, :exc:`PendingDeprecationWarning` para "
"indicar las características que están en proceso de ser obsoletas.  La "
"advertencia no se imprimirá por defecto.  Para comprobar el uso de funciones "
"que quedarán obsoletas en el futuro, proporcione :option:`-Walways::"
"PendingDeprecationWarning:: <-W>` en la línea de comandos o utilice :func:"
"`warnings.filterwarnings`."

#: ../Doc/whatsnew/2.3.rst:1065
msgid ""
"The process of deprecating string-based exceptions, as in ``raise \"Error "
"occurred\"``, has begun.  Raising a string will now trigger :exc:"
"`PendingDeprecationWarning`."
msgstr ""
"Ha comenzado el proceso de desaprobación de las excepciones basadas en "
"cadenas, como en ``lanzamiento de \"Error ocurred”``.  Al lanzar una cadena, "
"ahora se activará :exc:`PendingDeprecationWarning`."

#: ../Doc/whatsnew/2.3.rst:1069
msgid ""
"Using ``None`` as a variable name will now result in a :exc:`SyntaxWarning` "
"warning.  In a future version of Python, ``None`` may finally become a "
"keyword."
msgstr ""
"El uso de ``None`` como nombre de una variable ahora resultará en una "
"advertencia :exc:`SyntaxWarning`.  En una futura versión de Python, ``None`` "
"podría convertirse en una palabra clave."

#: ../Doc/whatsnew/2.3.rst:1072
msgid ""
"The :meth:`xreadlines` method of file objects, introduced in Python 2.1, is "
"no longer necessary because files now behave as their own iterator. :meth:"
"`xreadlines` was originally introduced as a faster way to loop over all the "
"lines in a file, but now you can simply write ``for line in file_obj``. File "
"objects also have a new read-only :attr:`encoding` attribute that gives the "
"encoding used by the file; Unicode strings written to the file will be "
"automatically  converted to bytes using the given encoding."
msgstr ""
"El método :meth:`xreadlines` de los objetos archivo, introducido en Python "
"2.1, ya no es necesario porque los archivos se comportan ahora como su "
"propio iterador. :meth:`xreadlines` se introdujo originalmente como una "
"forma más rápida de recorrer todas las líneas de un archivo, pero ahora se "
"puede escribir simplemente ``for line in file_obj``. Los objetos archivo "
"también tienen un nuevo atributo :attr:`encoding` de sólo lectura que "
"proporciona la codificación utilizada por el archivo; las cadenas Unicode "
"escritas en el archivo se convertirán automáticamente a bytes utilizando la "
"codificación dada."

#: ../Doc/whatsnew/2.3.rst:1080
msgid ""
"The method resolution order used by new-style classes has changed, though "
"you'll only notice the difference if you have a really complicated "
"inheritance hierarchy.  Classic classes are unaffected by this change.  "
"Python 2.2 originally used a topological sort of a class's ancestors, but "
"2.3 now uses the C3 algorithm as described in the paper `\"A Monotonic "
"Superclass Linearization for Dylan\" <https://citeseerx.ist.psu.edu/viewdoc/"
"summary?doi=10.1.1.19.3910>`_. To understand the motivation for this "
"change,  read Michele Simionato's article `\"Python 2.3 Method Resolution "
"Order\" <http://www.phyast.pitt.edu/~micheles/mro.html>`_, or read the "
"thread on python-dev starting with the message at https://mail.python.org/"
"pipermail/python-dev/2002-October/029035.html. Samuele Pedroni first pointed "
"out the problem and also implemented the fix by coding the C3 algorithm."
msgstr ""
"El orden de resolución de métodos utilizado por las clases de estilo nuevo "
"ha cambiado, aunque solo notará la diferencia si tiene una jerarquía de "
"herencia realmente complicada. Las clases clásicas no se ven afectadas por "
"este cambio. Python 2.2 originalmente usó un tipo topológico de los "
"ancestros de una clase, pero 2.3 ahora usa el algoritmo C3 como se describe "
"en el documento `\"A Monotonic Superclass Linearization for Dylan\" <https://"
"citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.19.3910>`_. Para comprender "
"la motivación de este cambio, lea el artículo `\"Python 2.3 Method "
"Resolution Order\" <http://www.phyast.pitt.edu/~micheles/mro.html>`_ de "
"Michele Simionato, o lea el hilo en python-dev que comienza con el mensaje "
"en https://mail.python.org/pipermail/python-dev/2002-October/029035.html . "
"Samuele Pedroni fue el primero en señalar el problema y también implementó "
"la solución codificando el algoritmo C3."

#: ../Doc/whatsnew/2.3.rst:1093
msgid ""
"Python runs multithreaded programs by switching between threads after "
"executing N bytecodes.  The default value for N has been increased from 10 "
"to 100 bytecodes, speeding up single-threaded applications by reducing the "
"switching overhead.  Some multithreaded applications may suffer slower "
"response time, but that's easily fixed by setting the limit back to a lower "
"number using ``sys.setcheckinterval(N)``. The limit can be retrieved with "
"the new :func:`sys.getcheckinterval` function."
msgstr ""
"Python ejecuta programas multihilo cambiando entre hilos después de ejecutar "
"N bytecodes.  El valor por defecto de N se ha incrementado de 10 a 100 "
"bytecodes, acelerando las aplicaciones de un solo hilo al reducir la "
"sobrecarga de cambio.  Algunas aplicaciones multihilo pueden sufrir un "
"tiempo de respuesta más lento, pero eso se arregla fácilmente estableciendo "
"el límite a un número menor usando ``sys.setcheckinterval(N)``. El límite "
"puede recuperarse con la nueva función :func:`sys.getcheckinterval`."

#: ../Doc/whatsnew/2.3.rst:1101
msgid ""
"One minor but far-reaching change is that the names of extension types "
"defined by the modules included with Python now contain the module and a "
"``'.'`` in front of the type name.  For example, in Python 2.2, if you "
"created a socket and printed its :attr:`__class__`, you'd get this output::"
msgstr ""
"Un cambio menor pero de gran alcance es que los nombres de los tipos de "
"extensión definidos por los módulos incluidos con Python ahora contienen el "
"módulo y un ``.'`` delante del nombre del tipo.  Por ejemplo, en Python 2.2, "
"si creabas un socket e imprimías su :attr:`__class__`, obtendrías esta "
"salida::"

#: ../Doc/whatsnew/2.3.rst:1110
msgid "In 2.3, you get this::"
msgstr "En 2.3, se obtiene esto::"

#: ../Doc/whatsnew/2.3.rst:1115
msgid ""
"One of the noted incompatibilities between old- and new-style classes has "
"been removed: you can now assign to the :attr:`~definition.__name__` and :"
"attr:`~class.__bases__` attributes of new-style classes.  There are some "
"restrictions on what can be assigned to :attr:`~class.__bases__` along the "
"lines of those relating to assigning to an instance's :attr:`~instance."
"__class__` attribute."
msgstr ""
"Se ha eliminado una de las incompatibilidades señaladas entre las clases de "
"estilo antiguo y las de estilo nuevo: ahora se pueden asignar a los "
"atributos :attr:`~definición.__name__` y :attr:`~clase.__bases__` de las "
"clases de estilo nuevo.  Hay algunas restricciones sobre lo que se puede "
"asignar a :attr:`~class.__bases__` en la línea de las relacionadas con la "
"asignación al atributo :attr:`~instance.__class__` de una instancia."

#: ../Doc/whatsnew/2.3.rst:1125
msgid "String Changes"
msgstr "Cambios en las cadenas de texto"

#: ../Doc/whatsnew/2.3.rst:1127
msgid ""
"The :keyword:`in` operator now works differently for strings. Previously, "
"when evaluating ``X in Y`` where *X* and *Y* are strings, *X* could only be "
"a single character. That's now changed; *X* can be a string of any length, "
"and ``X in Y`` will return :const:`True` if *X* is a substring of *Y*.  If "
"*X* is the empty string, the result is always :const:`True`. ::"
msgstr ""
"El operador :keyword:`in` ahora funciona de forma diferente para las "
"cadenas. Antes, cuando se evaluaba ``X en Y`` donde *X* y *Y* eran cadenas, "
"*X* sólo podía ser un único carácter. Esto ha cambiado; *X* puede ser una "
"cadena de cualquier longitud, y ``X en Y`` retornará :const:`True` si *X* es "
"una subcadena de *Y*.  Si *X* es una cadena vacía, el resultado es siempre :"
"const:`True`. ::"

#: ../Doc/whatsnew/2.3.rst:1140
msgid ""
"Note that this doesn't tell you where the substring starts; if you need that "
"information, use the :meth:`find` string method."
msgstr ""
"Tenga en cuenta que esto no le dice dónde empieza la subcadena; si necesita "
"esa información, utilice el método :meth:`find` string."

#: ../Doc/whatsnew/2.3.rst:1143
msgid ""
"The :meth:`strip`, :meth:`lstrip`, and :meth:`rstrip` string methods now "
"have an optional argument for specifying the characters to strip.  The "
"default is still to remove all whitespace characters::"
msgstr ""
"Los métodos de cadena :meth:`strip`, :meth:`lstrip` y :meth:`rstrip` tienen "
"ahora un argumento opcional para especificar los caracteres a eliminar.  El "
"valor por defecto sigue siendo eliminar todos los caracteres de espacio en "
"blanco::"

#: ../Doc/whatsnew/2.3.rst:1157
msgid "(Suggested by Simon Brunning and implemented by Walter Dörwald.)"
msgstr "(Sugerido por Simon Brunning y aplicado por Walter Dörwald)"

#: ../Doc/whatsnew/2.3.rst:1159
msgid ""
"The :meth:`startswith` and :meth:`endswith` string methods now accept "
"negative numbers for the *start* and *end* parameters."
msgstr ""
"Los métodos de cadena :meth:`startswith` y :meth:`endswith` ahora aceptan "
"números negativos para los parámetros *start* y *end*."

#: ../Doc/whatsnew/2.3.rst:1162
msgid ""
"Another new string method is :meth:`zfill`, originally a function in the :"
"mod:`string` module.  :meth:`zfill` pads a numeric string with zeros on the "
"left until it's the specified width. Note that the ``%`` operator is still "
"more flexible and powerful than :meth:`zfill`. ::"
msgstr ""
"Otro nuevo método de cadena es :meth:`zfill`, originalmente una función del "
"módulo :mod:`string`. :meth:`zfill` rellena una cadena numérica con ceros a "
"la izquierda hasta que tenga el ancho especificado. Tenga en cuenta que el "
"operador ``%`` sigue siendo más flexible y potente que :meth:`zfill`. ::"

#: ../Doc/whatsnew/2.3.rst:1174
msgid "(Contributed by Walter Dörwald.)"
msgstr "(Contribución de Walter Dörwald.)"

#: ../Doc/whatsnew/2.3.rst:1176
msgid ""
"A new type object, :class:`basestring`, has been added. Both 8-bit strings "
"and Unicode strings inherit from this type, so ``isinstance(obj, "
"basestring)`` will return :const:`True` for either kind of string.  It's a "
"completely abstract type, so you can't create :class:`basestring` instances."
msgstr ""
"Se ha añadido un nuevo tipo de objeto, :class:`basestring`. Tanto las "
"cadenas de 8 bits como las cadenas Unicode heredan de este tipo, por lo que "
"``isinstance(obj, basestring)`` retornará :const:`True` para cualquier tipo "
"de cadena.  Es un tipo completamente abstracto, por lo que no se pueden "
"crear instancias de :class:`basestring`."

#: ../Doc/whatsnew/2.3.rst:1181
msgid ""
"Interned strings are no longer immortal and will now be garbage-collected in "
"the usual way when the only reference to them is from the internal "
"dictionary of interned strings.  (Implemented by Oren Tirosh.)"
msgstr ""
"Las cadenas internas ya no son inmortales y ahora serán recolectadas de la "
"forma habitual cuando la única referencia a ellas sea desde el diccionario "
"interno de cadenas internas.  (Implementado por Oren Tirosh)"

#: ../Doc/whatsnew/2.3.rst:1189
msgid "Optimizations"
msgstr "Optimizaciones"

#: ../Doc/whatsnew/2.3.rst:1191
msgid ""
"The creation of new-style class instances has been made much faster; they're "
"now faster than classic classes!"
msgstr ""
"La creación de instancias de clases de estilo nuevo se ha hecho mucho más "
"rápida; ¡ahora son más rápidas que las clases clásicas!"

#: ../Doc/whatsnew/2.3.rst:1194
msgid ""
"The :meth:`sort` method of list objects has been extensively rewritten by "
"Tim Peters, and the implementation is significantly faster."
msgstr ""
"El método :meth:`sort` de los objetos de la lista ha sido ampliamente "
"reescrito por Tim Peters, y la implementación es significativamente más "
"rápida."

#: ../Doc/whatsnew/2.3.rst:1197
msgid ""
"Multiplication of large long integers is now much faster thanks to an "
"implementation of Karatsuba multiplication, an algorithm that scales better "
"than the O(n\\*n) required for the grade-school multiplication algorithm.  "
"(Original patch by Christopher A. Craig, and significantly reworked by Tim "
"Peters.)"
msgstr ""
"La multiplicación de enteros largos es ahora mucho más rápida gracias a una "
"implementación de la multiplicación Karatsuba, un algoritmo que escala mejor "
"que el O(n\\*n) requerido para el algoritmo de multiplicación de la escuela "
"primaria.  (Parche original de Christopher A. Craig, y reelaborado "
"significativamente por Tim Peters)"

#: ../Doc/whatsnew/2.3.rst:1202
msgid ""
"The ``SET_LINENO`` opcode is now gone.  This may provide a small speed "
"increase, depending on your compiler's idiosyncrasies. See section :ref:"
"`23section-other` for a longer explanation. (Removed by Michael Hudson.)"
msgstr ""
"El opcode ``SET_LINENO`` ha desaparecido.  Esto puede proporcionar un "
"pequeño aumento de velocidad, dependiendo de la idiosincrasia de su "
"compilador. Vea la sección :ref:`23section-other` para una explicación más "
"larga. (Eliminado por Michael Hudson)"

#: ../Doc/whatsnew/2.3.rst:1206
msgid ""
":func:`xrange` objects now have their own iterator, making ``for i in "
"xrange(n)`` slightly faster than ``for i in range(n)``.  (Patch by Raymond "
"Hettinger.)"
msgstr ""
"Los objetos :func:`xrange` tienen ahora su propio iterador, haciendo que "
"``for i in xrange(n)`` sea ligeramente más rápido que ``for i in "
"range(n)``.  (Parche de Raymond Hettinger)"

#: ../Doc/whatsnew/2.3.rst:1210
msgid ""
"A number of small rearrangements have been made in various hotspots to "
"improve performance, such as inlining a function or removing some code.  "
"(Implemented mostly by GvR, but lots of people have contributed single "
"changes.)"
msgstr ""
"Se han realizado una serie de pequeños reajustes en varios puntos "
"conflictivos para mejorar el rendimiento, como por ejemplo alinear una "
"función o eliminar algo de código.  (Implementado principalmente por GvR, "
"pero mucha gente ha contribuido con cambios individuales)"

#: ../Doc/whatsnew/2.3.rst:1214
#, python-format
msgid ""
"The net result of the 2.3 optimizations is that Python 2.3 runs the  pystone "
"benchmark around 25% faster than Python 2.2."
msgstr ""
"El resultado neto de las optimizaciones de la versión 2.3 es que Python 2.3 "
"ejecuta el benchmark pystone alrededor de un 25% f más rápido que Python 2.2."

#: ../Doc/whatsnew/2.3.rst:1221
msgid "New, Improved, and Deprecated Modules"
msgstr "Módulos nuevos, mejorados y obsoletos"

#: ../Doc/whatsnew/2.3.rst:1223
msgid ""
"As usual, Python's standard library received a number of enhancements and "
"bug fixes.  Here's a partial list of the most notable changes, sorted "
"alphabetically by module name. Consult the :file:`Misc/NEWS` file in the "
"source tree for a more complete list of changes, or look through the CVS "
"logs for all the details."
msgstr ""
"Como es habitual, la biblioteca estándar de Python ha recibido una serie de "
"mejoras y correcciones de errores.  Aquí hay una lista parcial de los "
"cambios más notables, ordenados alfabéticamente por nombre de módulo. "
"Consulte el archivo :file:`Misc/NEWS` en el árbol de fuentes para obtener "
"una lista más completa de los cambios, o busque en los registros de CVS para "
"obtener todos los detalles."

#: ../Doc/whatsnew/2.3.rst:1228
msgid ""
"The :mod:`array` module now supports arrays of Unicode characters using the "
"``'u'`` format character.  Arrays also now support using the ``+=`` "
"assignment operator to add another array's contents, and the ``*=`` "
"assignment operator to repeat an array. (Contributed by Jason Orendorff.)"
msgstr ""
"El módulo :mod:`array` soporta ahora matrices de caracteres Unicode que "
"utilizan el carácter de formato ``'u``.  Las matrices también soportan ahora "
"el uso del operador de asignación ``+=`` para añadir el contenido de otra "
"matriz, y el operador de asignación ``*=`` para repetir una matriz. "
"(Contribución de Jason Orendorff)"

#: ../Doc/whatsnew/2.3.rst:1233
msgid ""
"The :mod:`bsddb` module has been replaced by version 4.1.6 of the `PyBSDDB "
"<https://pybsddb.sourceforge.net>`_ package, providing a more complete "
"interface to the transactional features of the BerkeleyDB library."
msgstr ""
"El módulo :mod:`bsddb` ha sido reemplazado por la versión 4.1.6 del paquete "
"`PyBSDDB <https://pybsddb.sourceforge.net>`_, lo que proporciona una "
"interfaz más completa para las funciones transaccionales de la biblioteca "
"BerkeleyDB."

#: ../Doc/whatsnew/2.3.rst:1237
msgid ""
"The old version of the module has been renamed to  :mod:`bsddb185` and is no "
"longer built automatically; you'll  have to edit :file:`Modules/Setup` to "
"enable it.  Note that the new :mod:`bsddb` package is intended to be "
"compatible with the  old module, so be sure to file bugs if you discover any "
"incompatibilities. When upgrading to Python 2.3, if the new interpreter is "
"compiled with a new version of  the underlying BerkeleyDB library, you will "
"almost certainly have to convert your database files to the new version.  "
"You can do this fairly easily with the new scripts :file:`db2pickle.py` and :"
"file:`pickle2db.py` which you will find in the distribution's :file:`Tools/"
"scripts` directory.  If you've already been using the PyBSDDB package and "
"importing it as :mod:`bsddb3`, you will have to change your ``import`` "
"statements to import it as :mod:`bsddb`."
msgstr ""
"La antigua versión del módulo ha sido renombrada como :mod:`bsddb185` y ya "
"no se construye automáticamente; tendrás que editar :file:`Modules/Setup` "
"para activarlo.  Ten en cuenta que el nuevo paquete :mod:`bsddb` está "
"pensado para ser compatible con el módulo antiguo, así que asegúrate de "
"enviar errores si descubres alguna incompatibilidad. Al actualizar a Python "
"2.3, si el nuevo intérprete se compila con una nueva versión de la "
"biblioteca BerkeleyDB subyacente, es casi seguro que tendrá que convertir "
"sus archivos de base de datos a la nueva versión.  Puede hacerlo fácilmente "
"con los nuevos scripts :file:`db2pickle.py` y :file:`pickle2db.py` que "
"encontrará en el directorio :file:`Tools/scripts` de la distribución.  Si ya "
"ha estado utilizando el paquete PyBSDDB e importándolo como :mod:`bsddb3`, "
"tendrá que cambiar sus sentencias ``import`` para importarlo como :mod:"
"`bsddb`."

#: ../Doc/whatsnew/2.3.rst:1249
msgid ""
"The new :mod:`bz2` module is an interface to the bz2 data compression "
"library. bz2-compressed data is usually smaller than  corresponding :mod:"
"`zlib`\\ -compressed data. (Contributed by Gustavo Niemeyer.)"
msgstr ""
"El nuevo módulo :mod:`bz2` es una interfaz para la biblioteca de compresión "
"de datos bz2. Los datos comprimidos con bz2 suelen ser más pequeños que los "
"correspondientes datos comprimidos con :mod:`zlib`. (Contribución de Gustavo "
"Niemeyer)"

#: ../Doc/whatsnew/2.3.rst:1253
msgid ""
"A set of standard date/time types has been added in the new :mod:`datetime` "
"module.  See the following section for more details."
msgstr ""
"Se ha añadido un conjunto de tipos de fecha/hora estándar en el nuevo "
"módulo :mod:`datetime`.  Consulte la siguiente sección para obtener más "
"detalles."

#: ../Doc/whatsnew/2.3.rst:1256
msgid ""
"The Distutils :class:`Extension` class now supports an extra constructor "
"argument named *depends* for listing additional source files that an "
"extension depends on.  This lets Distutils recompile the module if any of "
"the dependency files are modified.  For example, if :file:`sampmodule.c` "
"includes the header file :file:`sample.h`, you would create the :class:"
"`Extension` object like this::"
msgstr ""
"La clase Distutils :class:`Extension` soporta ahora un argumento constructor "
"extra llamado *depends* para listar archivos fuente adicionales de los que "
"depende una extensión.  Esto permite a Distutils recompilar el módulo si se "
"modifica alguno de los archivos de dependencia.  Por ejemplo, si :file:"
"`sampmodule.c` incluye el fichero de cabecera :file:`sample.h`, se crearía "
"el objeto :class:`Extension` así::"

#: ../Doc/whatsnew/2.3.rst:1267
msgid ""
"Modifying :file:`sample.h` would then cause the module to be recompiled. "
"(Contributed by Jeremy Hylton.)"
msgstr ""
"La modificación de :file:`sample.h` haría que el módulo se recompilara. "
"(Contribución de Jeremy Hylton)"

#: ../Doc/whatsnew/2.3.rst:1270
msgid ""
"Other minor changes to Distutils: it now checks for the :envvar:`CC`, :"
"envvar:`CFLAGS`, :envvar:`CPP`, :envvar:`LDFLAGS`, and :envvar:`CPPFLAGS` "
"environment variables, using them to override the settings in Python's "
"configuration (contributed by Robert Weber)."
msgstr ""
"Otros cambios menores en Distutils: ahora comprueba las variables de "
"entorno :envvar:`CC`, :envvar:`CFLAGS`, :envvar:`CPP`, :envvar:`LDFLAGS` y :"
"envvar:`CPPFLAGS`, utilizándolas para anular los ajustes de la configuración "
"de Python (contribución de Robert Weber)."

#: ../Doc/whatsnew/2.3.rst:1275
msgid ""
"Previously the :mod:`doctest` module would only search the docstrings of "
"public methods and functions for test cases, but it now also examines "
"private ones as well.  The :func:`DocTestSuite` function creates a :class:"
"`unittest.TestSuite` object from a set of :mod:`doctest` tests."
msgstr ""
"Anteriormente el módulo :mod:`doctest` sólo buscaba casos de prueba en los "
"docstrings de los métodos y funciones públicos, pero ahora también examina "
"los privados.  La función :func:`DocTestSuite` crea un objeto :class:"
"`unittest.TestSuite` a partir de un conjunto de pruebas :mod:`doctest`."

#: ../Doc/whatsnew/2.3.rst:1280
msgid ""
"The new ``gc.get_referents(object)`` function returns a list of all the "
"objects referenced by *object*."
msgstr ""
"La nueva función ``gc.get_referents(object)`` retorna una lista de todos los "
"objetos referenciados por *object*."

#: ../Doc/whatsnew/2.3.rst:1283
msgid ""
"The :mod:`getopt` module gained a new function, :func:`gnu_getopt`, that "
"supports the same arguments as the existing :func:`getopt` function but uses "
"GNU-style scanning mode. The existing :func:`getopt` stops processing "
"options as soon as a non-option argument is encountered, but in GNU-style "
"mode processing continues, meaning that options and arguments can be mixed.  "
"For example::"
msgstr ""
"El módulo :mod:`getopt` ha ganado una nueva función, :func:`gnu_getopt`, que "
"admite los mismos argumentos que la función :func:`getopt` existente, pero "
"utiliza el modo de exploración al estilo GNU. La función :func:`getopt` "
"existente deja de procesar las opciones tan pronto como se encuentra un "
"argumento que no es una opción, pero en el modo GNU el procesamiento "
"continúa, lo que significa que las opciones y los argumentos pueden "
"mezclarse.  Por ejemplo::"

#: ../Doc/whatsnew/2.3.rst:1294
msgid "(Contributed by Peter Åstrand.)"
msgstr "(Contribución de Peter Åstrand.)"

#: ../Doc/whatsnew/2.3.rst:1296
msgid ""
"The :mod:`grp`, :mod:`pwd`, and :mod:`resource` modules now return enhanced "
"tuples::"
msgstr ""
"Los módulos :mod:`grp`, :mod:`pwd` y :mod:`resource` retornan ahora tuplas "
"mejoradas::"

#: ../Doc/whatsnew/2.3.rst:1304
msgid "The :mod:`gzip` module can now handle files exceeding 2 GiB."
msgstr "El módulo :mod:`gzip` ahora puede manejar archivos de más de 2 GiB."

#: ../Doc/whatsnew/2.3.rst:1306
msgid ""
"The new :mod:`heapq` module contains an implementation of a heap queue "
"algorithm.  A heap is an array-like data structure that keeps items in a "
"partially sorted order such that, for every index *k*, ``heap[k] <= "
"heap[2*k+1]`` and ``heap[k] <= heap[2*k+2]``.  This makes it quick to remove "
"the smallest item, and inserting a new item while maintaining the heap "
"property is O(lg n).  (See https://xlinux.nist.gov/dads//HTML/priorityque."
"html for more information about the priority queue data structure.)"
msgstr ""
"El nuevo módulo :mod:`heapq` contiene una implementación de un algoritmo de "
"colas de montón.  Un montón es una estructura de datos similar a un array "
"que mantiene los elementos en un orden parcialmente ordenado de forma que, "
"para cada índice *k*, ``heap[k] <= heap[2*k+1]`` y ``heap[k] <= "
"heap[2*k+2]``.  Esto hace que sea rápido eliminar el elemento más pequeño, y "
"la inserción de un nuevo elemento manteniendo la propiedad del montón es "
"*O(lg n)*.  (Véase https://xlinux.nist.gov/dads//HTML/priorityque.html para "
"más información sobre la estructura de datos de la cola de prioridad)"

#: ../Doc/whatsnew/2.3.rst:1314
msgid ""
"The :mod:`heapq` module provides :func:`heappush` and :func:`heappop` "
"functions for adding and removing items while maintaining the heap property "
"on top of some other mutable Python sequence type.  Here's an example that "
"uses a Python list::"
msgstr ""
"El módulo :mod:`heapq` proporciona las funciones :func:`heappush` y :func:"
"`heappop` para añadir y eliminar elementos manteniendo la propiedad del "
"montón sobre algún otro tipo de secuencia mutable de Python.  Aquí hay un "
"ejemplo que utiliza una lista de Python::"

#: ../Doc/whatsnew/2.3.rst:1332
msgid "(Contributed by Kevin O'Connor.)"
msgstr "(Contribución de Kevin O'Connor.)"

#: ../Doc/whatsnew/2.3.rst:1334
msgid ""
"The IDLE integrated development environment has been updated using the code "
"from the IDLEfork project (https://idlefork.sourceforge.net).  The most "
"notable feature is that the code being developed is now executed in a "
"subprocess, meaning that there's no longer any need for manual ``reload()`` "
"operations. IDLE's core code has been incorporated into the standard library "
"as the :mod:`idlelib` package."
msgstr ""
"El entorno de desarrollo integrado IDLE ha sido actualizado utilizando el "
"código del proyecto IDLEfork (http://idlefork.sourceforge.net).  La "
"característica más notable es que el código que se está desarrollando se "
"ejecuta ahora en un subproceso, lo que significa que ya no es necesario "
"realizar operaciones manuales de ``reload()``. El código central de IDLE ha "
"sido incorporado a la biblioteca estándar como el paquete :mod:`idlelib`."

#: ../Doc/whatsnew/2.3.rst:1340
msgid ""
"The :mod:`imaplib` module now supports IMAP over SSL. (Contributed by Piers "
"Lauder and Tino Lange.)"
msgstr ""
"El módulo :mod:`imaplib` ahora admite IMAP sobre SSL. (Contribuido por Piers "
"Lauder y Tino Lange.)"

#: ../Doc/whatsnew/2.3.rst:1343
msgid ""
"The :mod:`itertools` contains a number of useful functions for use with "
"iterators, inspired by various functions provided by the ML and Haskell "
"languages.  For example, ``itertools.ifilter(predicate, iterator)`` returns "
"all elements in the iterator for which the function :func:`predicate` "
"returns :const:`True`, and ``itertools.repeat(obj, N)`` returns ``obj`` *N* "
"times. There are a number of other functions in the module; see the "
"package's reference documentation for details. (Contributed by Raymond "
"Hettinger.)"
msgstr ""
"El :mod:`itertools` contiene una serie de funciones útiles para usar con "
"iteradores, inspiradas en varias funciones proporcionadas por los lenguajes "
"ML y Haskell. Por ejemplo, ``itertools.ifilter(predicate, iterator)`` "
"devuelve todos los elementos del iterador para los que la función :func:"
"`predicate` devuelve :const:`True` y ``itertools.repeat(obj, N)`` devuelve "
"``obj`` *N* veces. Hay una serie de otras funciones en el módulo; consulte "
"la documentación de referencia del paquete para obtener más detalles. "
"(Contribuido por Raymond Hettinger.)"

#: ../Doc/whatsnew/2.3.rst:1352
msgid ""
"Two new functions in the :mod:`math` module, ``degrees(rads)`` and "
"``radians(degs)``, convert between radians and degrees.  Other functions in "
"the :mod:`math` module such as :func:`math.sin` and :func:`math.cos` have "
"always required input values measured in radians.  Also, an optional *base* "
"argument was added to :func:`math.log` to make it easier to compute "
"logarithms for bases other than ``e`` and ``10``.  (Contributed by Raymond "
"Hettinger.)"
msgstr ""
"Dos nuevas funciones en el módulo :mod:`math`, ``degrees(rads)`` y "
"``radians(degs)``, convierten entre radianes y grados. Otras funciones del "
"módulo :mod:`math`, como :func:`math.sin` y :func:`math.cos`, siempre han "
"requerido valores de entrada medidos en radianes. Además, se agregó un "
"argumento opcional *base* a :func:`math.log` para facilitar el cálculo de "
"logaritmos para bases distintas de ``e`` y ``10``. (Contribuido por Raymond "
"Hettinger.)"

#: ../Doc/whatsnew/2.3.rst:1359
msgid ""
"Several new POSIX functions (:func:`getpgid`, :func:`killpg`, :func:"
"`lchown`, :func:`loadavg`, :func:`major`, :func:`makedev`, :func:`minor`, "
"and :func:`mknod`) were added to the :mod:`posix` module that underlies the :"
"mod:`os` module. (Contributed by Gustavo Niemeyer, Geert Jansen, and Denis "
"S. Otkidach.)"
msgstr ""
"Se agregaron varias funciones POSIX nuevas (:func:`getpgid`, :func:"
"`killpg`, :func:`lchown`, :func:`loadavg`, :func:`major`, :func:`makedev`, :"
"func:`minor` y :func:`mknod`) al módulo :mod:`posix` que subyace al módulo :"
"mod:`os`. (Contribuido por Gustavo Niemeyer, Geert Jansen y Denis S. "
"Otkidach.)"

#: ../Doc/whatsnew/2.3.rst:1365
msgid ""
"In the :mod:`os` module, the :func:`\\*stat` family of functions can now "
"report fractions of a second in a timestamp.  Such time stamps are "
"represented as floats, similar to the value returned by :func:`time.time`."
msgstr ""
"En el módulo :mod:`os`, la familia de funciones :func:`\\*stat` ahora puede "
"informar fracciones de segundo en una marca de tiempo. Estas marcas de "
"tiempo se representan como flotantes, similar al valor devuelto por :func:"
"`time.time`."

#: ../Doc/whatsnew/2.3.rst:1369
msgid ""
"During testing, it was found that some applications will break if time "
"stamps are floats.  For compatibility, when using the tuple interface of "
"the :class:`stat_result` time stamps will be represented as integers. When "
"using named fields (a feature first introduced in Python 2.2), time stamps "
"are still represented as integers, unless :func:`os.stat_float_times` is "
"invoked to enable float return values::"
msgstr ""
"Durante las pruebas, se descubrió que algunas aplicaciones se romperán si "
"las marcas de tiempo son flotantes. Por compatibilidad, cuando se utiliza la "
"interfaz de tupla de las marcas de tiempo :class:`stat_result` se "
"representarán como números enteros. Cuando se utilizan campos con nombre "
"(una característica introducida por primera vez en Python 2.2), las marcas "
"de tiempo todavía se representan como números enteros, a menos que se "
"invoque :func:`os.stat_float_times` para habilitar los valores de retorno "
"flotantes:"

#: ../Doc/whatsnew/2.3.rst:1382
msgid "In Python 2.4, the default will change to always returning floats."
msgstr ""
"En Python 2.4, el valor predeterminado cambiará para devolver siempre "
"flotantes."

#: ../Doc/whatsnew/2.3.rst:1384
msgid ""
"Application developers should enable this feature only if all their "
"libraries work properly when confronted with floating point time stamps, or "
"if they use the tuple API. If used, the feature should be activated on an "
"application level instead of trying to enable it on a per-use basis."
msgstr ""
"Los desarrolladores de aplicaciones deben habilitar esta función solo si "
"todas sus bibliotecas funcionan correctamente cuando se enfrentan a marcas "
"de tiempo de punto flotante o si utilizan la API de tuplas. Si se usa, la "
"función debe activarse a nivel de aplicación en lugar de intentar "
"habilitarla por uso."

#: ../Doc/whatsnew/2.3.rst:1389
msgid ""
"The :mod:`optparse` module contains a new parser for command-line arguments "
"that can convert option values to a particular Python type  and will "
"automatically generate a usage message.  See the following section for  more "
"details."
msgstr ""
"El módulo :mod:`optparse` contiene un nuevo analizador para argumentos de "
"línea de comandos que puede convertir valores de opción a un tipo de Python "
"en particular y generará automáticamente un mensaje de uso. Consulte la "
"siguiente sección para obtener más detalles."

#: ../Doc/whatsnew/2.3.rst:1394
msgid ""
"The old and never-documented :mod:`linuxaudiodev` module has been "
"deprecated, and a new version named :mod:`ossaudiodev` has been added.  The "
"module was renamed because the OSS sound drivers can be used on platforms "
"other than Linux, and the interface has also been tidied and brought up to "
"date in various ways. (Contributed by Greg Ward and Nicholas FitzRoy-Dale.)"
msgstr ""
"El módulo :mod:`linuxaudiodev` antiguo y nunca documentado ha quedado "
"obsoleto y se ha agregado una nueva versión denominada :mod:`ossaudiodev`. "
"Se cambió el nombre del módulo porque los controladores de sonido OSS se "
"pueden usar en plataformas distintas de Linux, y la interfaz también se ha "
"arreglado y actualizado de varias maneras. (Contribuido por Greg Ward y "
"Nicholas FitzRoy-Dale.)"

#: ../Doc/whatsnew/2.3.rst:1400
msgid ""
"The new :mod:`platform` module contains a number of functions that try to "
"determine various properties of the platform you're running on.  There are "
"functions for getting the architecture, CPU type, the Windows OS version, "
"and even the Linux distribution version. (Contributed by Marc-André Lemburg.)"
msgstr ""
"El nuevo módulo :mod:`platform` contiene una serie de funciones que intentan "
"determinar varias propiedades de la plataforma en la que se está ejecutando. "
"Hay funciones para obtener la arquitectura, el tipo de CPU, la versión del "
"sistema operativo Windows e incluso la versión de distribución de Linux. "
"(Contribución de Marc-André Lemburg.)"

#: ../Doc/whatsnew/2.3.rst:1405
msgid ""
"The parser objects provided by the :mod:`pyexpat` module can now optionally "
"buffer character data, resulting in fewer calls to your character data "
"handler and therefore faster performance.  Setting the parser object's :attr:"
"`buffer_text` attribute to :const:`True` will enable buffering."
msgstr ""
"Los objetos del analizador proporcionados por el módulo :mod:`pyexpat` ahora "
"pueden almacenar opcionalmente datos de caracteres, lo que resulta en menos "
"llamadas al controlador de datos de caracteres y, por lo tanto, un "
"rendimiento más rápido. La configuración del atributo :attr:`buffer_text` "
"del objeto del analizador en :const:`True` habilitará el almacenamiento en "
"búfer."

#: ../Doc/whatsnew/2.3.rst:1410
msgid ""
"The ``sample(population, k)`` function was added to the :mod:`random` "
"module.  *population* is a sequence or :class:`xrange` object containing the "
"elements of a population, and :func:`sample` chooses *k* elements from the "
"population without replacing chosen elements.  *k* can be any value up to "
"``len(population)``. For example::"
msgstr ""
"La función ``sample(population, k)`` se agregó al módulo :mod:`random`. "
"*population* es una secuencia o un objeto :class:`xrange` que contiene los "
"elementos de la población, and :func:`sample` elije *k* elementos de la "
"población sin reemplazar los elementos escogidos. *k* puede tener cualquier "
"valor hasta ``len(population)``. Por ejemplo::"

#: ../Doc/whatsnew/2.3.rst:1432
msgid ""
"The :mod:`random` module now uses a new algorithm, the Mersenne Twister, "
"implemented in C.  It's faster and more extensively studied than the "
"previous algorithm."
msgstr ""
"El módulo :mod:`random` ahora usa un nuevo algoritmo, el Mersenne Twister, "
"implementado en C. Es más rápido y más estudiado que el algoritmo anterior."

#: ../Doc/whatsnew/2.3.rst:1436
msgid "(All changes contributed by Raymond Hettinger.)"
msgstr "(Parches aportados por Raymond Hettinger)"

#: ../Doc/whatsnew/2.3.rst:1438
msgid ""
"The :mod:`readline` module also gained a number of new functions: :func:"
"`get_history_item`, :func:`get_current_history_length`, and :func:"
"`redisplay`."
msgstr ""
"El módulo :mod:`readline` también obtuvo varias funciones nuevas: :func:"
"`get_history_item`, :func:`get_current_history_length` y :func:`redisplay`."

#: ../Doc/whatsnew/2.3.rst:1442
msgid ""
"The :mod:`rexec` and :mod:`Bastion` modules have been declared dead, and "
"attempts to import them will fail with a :exc:`RuntimeError`.  New-style "
"classes provide new ways to break out of the restricted execution "
"environment provided by :mod:`rexec`, and no one has interest in fixing them "
"or time to do so.  If you have applications using :mod:`rexec`, rewrite them "
"to use something else."
msgstr ""
"Los módulos :mod:`rexec` y :mod:`Bastion` se han declarado muertos y los "
"intentos de importarlos fallarán con un :exc:`RuntimeError`. Las clases de "
"nuevo estilo brindan nuevas formas de salir del entorno de ejecución "
"restringido proporcionado por :mod:`rexec`, y nadie tiene interés en "
"arreglarlas o el tiempo para hacerlo. Si tiene aplicaciones que usan :mod:"
"`rexec`, vuelva a escribirlas para usar otra cosa."

#: ../Doc/whatsnew/2.3.rst:1448
msgid ""
"(Sticking with Python 2.2 or 2.1 will not make your applications any safer "
"because there are known bugs in the :mod:`rexec` module in those versions.  "
"To repeat: if you're using :mod:`rexec`, stop using it immediately.)"
msgstr ""
"(Seguir con Python 2.2 o 2.1 no hará que sus aplicaciones sean más seguras "
"porque hay errores conocidos en el módulo :mod:`rexec` en esas versiones. "
"Para repetir: si está usando :mod:`rexec`, deje de usarlo inmediatamente)."

#: ../Doc/whatsnew/2.3.rst:1452
msgid ""
"The :mod:`rotor` module has been deprecated because the  algorithm it uses "
"for encryption is not believed to be secure.  If you need encryption, use "
"one of the several AES Python modules that are available separately."
msgstr ""
"El módulo :mod:`rotor` ha quedado obsoleto porque no se cree que el "
"algoritmo que utiliza para el cifrado sea seguro. Si necesita cifrado, use "
"uno de los varios módulos AES Python que están disponibles por separado."

#: ../Doc/whatsnew/2.3.rst:1456
msgid ""
"The :mod:`shutil` module gained a ``move(src, dest)`` function that "
"recursively moves a file or directory to a new location."
msgstr ""
"El módulo :mod:`shutil` obtuvo una función ``move(src, dest)`` que mueve "
"recursivamente un archivo o directorio a una nueva ubicación."

#: ../Doc/whatsnew/2.3.rst:1459
msgid ""
"Support for more advanced POSIX signal handling was added to the :mod:"
"`signal` but then removed again as it proved impossible to make it work "
"reliably across platforms."
msgstr ""
"Se agregó soporte para un manejo de señal POSIX más avanzado al :mod:"
"`signal`, pero luego se eliminó nuevamente, ya que resultó imposible hacerlo "
"funcionar de manera confiable en todas las plataformas."

#: ../Doc/whatsnew/2.3.rst:1463
msgid ""
"The :mod:`socket` module now supports timeouts.  You can call the "
"``settimeout(t)`` method on a socket object to set a timeout of *t* seconds. "
"Subsequent socket operations that take longer than *t* seconds to complete "
"will abort and raise a :exc:`socket.timeout` exception."
msgstr ""
"El módulo :mod:`socket` ahora admite tiempos de espera. Puede llamar al "
"método ``settimeout(t)`` en un objeto de socket para establecer un tiempo de "
"espera de *t* seconds. Subsequent socket operations that take longer than "
"*t* segundos para completar, abortará y lanzará una excepción :exc:`socket."
"timeout`."

#: ../Doc/whatsnew/2.3.rst:1468
msgid ""
"The original timeout implementation was by Tim O'Malley.  Michael Gilfix "
"integrated it into the Python :mod:`socket` module and shepherded it through "
"a lengthy review.  After the code was checked in, Guido van Rossum rewrote "
"parts of it.  (This is a good example of a collaborative development process "
"in action.)"
msgstr ""
"La implementación del tiempo de espera original fue realizada por Tim "
"O'Malley. Michael Gilfix lo integró en el módulo Python :mod:`socket` y lo "
"guió a través de una extensa revisión. Después de que se registró el código, "
"Guido van Rossum reescribió partes del mismo. (Este es un buen ejemplo de un "
"proceso de desarrollo colaborativo en acción)."

#: ../Doc/whatsnew/2.3.rst:1474
msgid ""
"On Windows, the :mod:`socket` module now ships with Secure  Sockets Layer "
"(SSL) support."
msgstr ""
"En Windows, el módulo :mod:`socket` ahora se envía con compatibilidad con "
"Secure Sockets Layer (SSL)."

#: ../Doc/whatsnew/2.3.rst:1477
msgid ""
"The value of the C :c:macro:`PYTHON_API_VERSION` macro is now exposed at the "
"Python level as ``sys.api_version``.  The current exception can be cleared "
"by calling the new :func:`sys.exc_clear` function."
msgstr ""
"El valor de la macro C :c:macro:`PYTHON_API_VERSION` ahora se expone en el "
"nivel de Python como ``sys.api_version``. La excepción actual se puede "
"borrar llamando a la nueva función :func:`sys.exc_clear`."

#: ../Doc/whatsnew/2.3.rst:1481
msgid ""
"The new :mod:`tarfile` module  allows reading from and writing to :program:"
"`tar`\\ -format archive files. (Contributed by Lars Gustäbel.)"
msgstr ""
"El nuevo módulo :mod:`tarfile` permite leer y escribir en: programa: `tar` "
"\\ -format archivos de almacenamiento. (Contribución de Lars Gustäbel.)"

#: ../Doc/whatsnew/2.3.rst:1484
msgid ""
"The new :mod:`textwrap` module contains functions for wrapping strings "
"containing paragraphs of text.  The ``wrap(text, width)`` function takes a "
"string and returns a list containing the text split into lines of no more "
"than the chosen width.  The ``fill(text, width)`` function returns a single "
"string, reformatted to fit into lines no longer than the chosen width. (As "
"you can guess, :func:`fill` is built on top of :func:`wrap`.  For example::"
msgstr ""
"El nuevo módulo :mod:`textwrap` contiene funciones para envolver cadenas que "
"contienen párrafos de texto. La función ``wrap(text, width)`` toma una "
"cadena y devuelve una lista que contiene el texto dividido en líneas de no "
"más del ancho elegido. La función ``fill(text, width)`` devuelve una sola "
"cadena, reformateada para que quepa en líneas que no superen el ancho "
"elegido. (Como puede adivinar, :func:`fill` está construido sobre :func:"
"`wrap`. Por ejemplo:"

#: ../Doc/whatsnew/2.3.rst:1506
msgid ""
"The module also contains a :class:`TextWrapper` class that actually "
"implements the text wrapping strategy.   Both the :class:`TextWrapper` class "
"and the :func:`wrap` and :func:`fill` functions support a number of "
"additional keyword arguments for fine-tuning the formatting; consult the "
"module's documentation for details. (Contributed by Greg Ward.)"
msgstr ""
"El módulo también contiene una clase :class:`TextWrapper` que realmente "
"implementa la estrategia de envoltura de texto. Tanto la clase :class:"
"`TextWrapper` como las funciones :func:`wrap` y :func:`fill` admiten varios "
"argumentos de palabras clave adicionales para ajustar el formato; consulte "
"la documentación del módulo para obtener más detalles. (Contribuido por Greg "
"Ward.)"

#: ../Doc/whatsnew/2.3.rst:1512
msgid ""
"The :mod:`thread` and :mod:`threading` modules now have companion modules, :"
"mod:`dummy_thread` and :mod:`dummy_threading`, that provide a do-nothing "
"implementation of the :mod:`thread` module's interface for platforms where "
"threads are not supported.  The intention is to simplify thread-aware "
"modules (ones that *don't* rely on threads to run) by putting the following "
"code at the top::"
msgstr ""
"Los módulos :mod:`thread` y :mod:`threading` ahora tienen módulos "
"complementarios, :mod:`dummy_thread` y :mod:`dummy_threading`, que "
"proporcionan una implementación sin acción de la interfaz del módulo :mod:"
"`thread` para plataformas donde no se admiten subprocesos. La intención es "
"simplificar los módulos compatibles con subprocesos (aquellos en los que "
"*don't* depende de los subprocesos para ejecutarse) colocando el siguiente "
"código en la parte superior:"

#: ../Doc/whatsnew/2.3.rst:1524
msgid ""
"In this example, :mod:`_threading` is used as the module name to make it "
"clear that the module being used is not necessarily the actual :mod:"
"`threading` module. Code can call functions and use classes in :mod:"
"`_threading` whether or not threads are supported, avoiding an :keyword:`if` "
"statement and making the code slightly clearer.  This module will not "
"magically make multithreaded code run without threads; code that waits for "
"another thread to return or to do something will simply hang forever."
msgstr ""
"En este ejemplo, :mod:`_threading` se usa como el nombre del módulo para "
"dejar en claro que el módulo que se está usando no es necesariamente el "
"módulo :mod:`threading`. El código puede llamar funciones y usar clases en :"
"mod:`_threading`, ya sea que se admitan subprocesos o no, evitando una "
"declaración :keyword:`if` y haciendo que el código sea un poco más claro. "
"Este módulo no hará mágicamente que el código multiproceso se ejecute sin "
"subprocesos; el código que espera a que vuelva otro hilo o que haga algo "
"simplemente se colgará para siempre."

#: ../Doc/whatsnew/2.3.rst:1532
msgid ""
"The :mod:`time` module's :func:`strptime` function has long been an "
"annoyance because it uses the platform C library's :func:`strptime` "
"implementation, and different platforms sometimes have odd bugs.  Brett "
"Cannon contributed a portable implementation that's written in pure Python "
"and should behave identically on all platforms."
msgstr ""
"La función :func:`strptime` del módulo :mod:`time` ha sido durante mucho "
"tiempo una molestia porque utiliza la implementación :func:`strptime` de la "
"biblioteca de la plataforma C, y las diferentes plataformas a veces tienen "
"errores extraños. Brett Cannon contribuyó con una implementación portátil "
"que está escrita en Python puro y debería comportarse de manera idéntica en "
"todas las plataformas."

#: ../Doc/whatsnew/2.3.rst:1538
msgid ""
"The new :mod:`timeit` module helps measure how long snippets of Python code "
"take to execute.  The :file:`timeit.py` file can be run directly from the "
"command line, or the module's :class:`Timer` class can be imported and used "
"directly.  Here's a short example that figures out whether it's faster to "
"convert an 8-bit string to Unicode by appending an empty Unicode string to "
"it or by using the :func:`unicode` function::"
msgstr ""
"El nuevo módulo :mod:`timeit` ayuda a medir cuánto tardan en ejecutarse los "
"fragmentos de código Python. El archivo :file:`timeit.py` se puede ejecutar "
"directamente desde la línea de comando, o la clase :class:`Timer` del módulo "
"se puede importar y usar directamente. Aquí hay un breve ejemplo que "
"determina si es más rápido convertir una cadena de 8 bits a Unicode "
"agregando una cadena Unicode vacía o usando la función :func:`unicode`:"

#: ../Doc/whatsnew/2.3.rst:1558
msgid ""
"The :mod:`Tix` module has received various bug fixes and updates for the "
"current version of the Tix package."
msgstr ""
"El módulo :mod:`Tix` ha recibido varias correcciones de errores y "
"actualizaciones para la versión actual del paquete Tix."

#: ../Doc/whatsnew/2.3.rst:1561
msgid ""
"The :mod:`Tkinter` module now works with a thread-enabled  version of Tcl. "
"Tcl's threading model requires that widgets only be accessed from the thread "
"in which they're created; accesses from another thread can cause Tcl to "
"panic.  For certain Tcl interfaces, :mod:`Tkinter` will now automatically "
"avoid this  when a widget is accessed from a different thread by marshalling "
"a command, passing it to the correct thread, and waiting for the results.  "
"Other interfaces can't be handled automatically but :mod:`Tkinter` will now "
"raise an exception on such an access so that you can at least find out about "
"the problem.  See https://mail.python.org/pipermail/python-dev/2002-"
"December/031107.html for a more detailed explanation of this change.  "
"(Implemented by Martin von Löwis.)"
msgstr ""
"El módulo :mod:`Tkinter` ahora funciona con una versión de Tcl habilitada "
"para subprocesos. El modelo de subprocesos de Tcl requiere que solo se "
"acceda a los widgets desde el subproceso en el que se crearon; los accesos "
"desde otro hilo pueden hacer que Tcl entre en pánico. Para ciertas "
"interfaces Tcl, :mod:`Tkinter` ahora evitará esto automáticamente cuando se "
"acceda a un widget desde un subproceso diferente al ordenar un comando, "
"pasarlo al subproceso correcto y esperar los resultados. Otras interfaces no "
"se pueden manejar automáticamente, pero :mod:`Tkinter` ahora lanzará una "
"excepción en dicho acceso para que al menos pueda averiguar sobre el "
"problema. Consulte https://mail.python.org/pipermail/python-dev/2002-"
"December/031107.html para obtener una explicación más detallada de este "
"cambio. (Implementado por Martin von Löwis.)"

#: ../Doc/whatsnew/2.3.rst:1572
msgid ""
"Calling Tcl methods through :mod:`_tkinter` no longer  returns only strings. "
"Instead, if Tcl returns other objects those objects are converted to their "
"Python equivalent, if one exists, or wrapped with a :class:`_tkinter."
"Tcl_Obj` object if no Python equivalent exists. This behavior can be "
"controlled through the :meth:`wantobjects` method of :class:`tkapp` objects."
msgstr ""
"Llamar a métodos Tcl a través del objeto :mod:`_tkinter` ya no retorna solo "
"cadena de caracteres.En vez, si Tcl retorna otros objetos esos objetos son "
"convertidos a su equivalente en Python,si uno existe, o envueltos en una "
"clase :class:`_tkinter. Tcl_Obj` si no existe un equivalente de Python. Este "
"comportamiento se puede controlar mediante el método :meth:`wantobjects` de "
"objetos :class:`tkapp`."

#: ../Doc/whatsnew/2.3.rst:1578
msgid ""
"When using :mod:`_tkinter` through the :mod:`Tkinter` module (as most "
"Tkinter applications will), this feature is always activated. It should not "
"cause compatibility problems, since Tkinter would always convert string "
"results to Python types where possible."
msgstr ""
"Cuando se usa :mod:`_tkinter` a través del módulo :mod:`Tkinter` (como lo "
"harán la mayoría de las aplicaciones de Tkinter), esta función siempre está "
"activada. No debería causar problemas de compatibilidad, ya que Tkinter "
"siempre convertiría los resultados de cadenas a tipos de Python cuando fuera "
"posible."

#: ../Doc/whatsnew/2.3.rst:1583
msgid ""
"If any incompatibilities are found, the old behavior can be restored by "
"setting the :attr:`wantobjects` variable in the :mod:`Tkinter` module to "
"false before creating the first :class:`tkapp` object. ::"
msgstr ""
"Si se encuentran incompatibilidades, se puede restaurar el comportamiento "
"anterior estableciendo la variable :attr:`wantobjects` en el módulo :mod:"
"`Tkinter` en falso antes de crear el primer objeto :class:`tkapp`. ::"

#: ../Doc/whatsnew/2.3.rst:1590
msgid "Any breakage caused by this change should be reported as a bug."
msgstr ""
"Cualquier rotura causada por este cambio debe notificarse como un error."

#: ../Doc/whatsnew/2.3.rst:1592
msgid ""
"The :mod:`UserDict` module has a new :class:`DictMixin` class which defines "
"all dictionary methods for classes that already have a minimum mapping "
"interface.  This greatly simplifies writing classes that need to be "
"substitutable for dictionaries, such as the classes in  the :mod:`shelve` "
"module."
msgstr ""
"El módulo :mod:`UserDict` tiene una nueva clase :class:`DictMixin` que "
"define todos los métodos de diccionario para las clases que ya tienen una "
"interfaz de mapeo mínima. Esto simplifica enormemente las clases de "
"escritura que deben ser sustituibles por diccionarios, como las clases del "
"módulo :mod:`shelve`."

#: ../Doc/whatsnew/2.3.rst:1598
msgid ""
"Adding the mix-in as a superclass provides the full dictionary interface "
"whenever the class defines :meth:`__getitem__`, :meth:`__setitem__`, :meth:"
"`__delitem__`, and :meth:`keys`. For example::"
msgstr ""
"Agregar la combinación como una superclase proporciona la interfaz de "
"diccionario completa siempre que la clase define :meth:`__getitem__`, :meth:"
"`__setitem__`, :meth:`__delitem__` y :meth:`keys`. Por ejemplo::"

#: ../Doc/whatsnew/2.3.rst:1639
msgid "(Contributed by Raymond Hettinger.)"
msgstr "(Parches aportados por Raymond Hettinger)"

#: ../Doc/whatsnew/2.3.rst:1641
msgid ""
"The DOM implementation in :mod:`xml.dom.minidom` can now generate XML output "
"in a particular encoding by providing an optional encoding argument to the :"
"meth:`toxml` and :meth:`toprettyxml` methods of DOM nodes."
msgstr ""
"La implementación DOM en :mod:`xml.dom.minidom` ahora puede generar salida "
"XML en una codificación particular proporcionando un argumento de "
"codificación opcional a los métodos :meth:`toxml` y :meth:`toprettyxml` de "
"los nodos DOM."

#: ../Doc/whatsnew/2.3.rst:1645
msgid ""
"The :mod:`xmlrpclib` module now supports an XML-RPC extension for handling "
"nil data values such as Python's ``None``.  Nil values are always supported "
"on unmarshalling an XML-RPC response.  To generate requests containing "
"``None``, you must supply a true value for the *allow_none* parameter when "
"creating a :class:`Marshaller` instance."
msgstr ""
"El módulo :mod:`xmlrpclib` ahora admite una extensión XML-RPC para manejar "
"valores de datos nulos como ``None`` de Python. Los valores nulos siempre se "
"admiten al desagrupar una respuesta XML-RPC. Para generar solicitudes que "
"contengan ``None``, debe proporcionar un valor verdadero para el parámetro "
"*allow_none* al crear una instancia :class:`Marshaller`."

#: ../Doc/whatsnew/2.3.rst:1651
msgid ""
"The new :mod:`DocXMLRPCServer` module allows writing self-documenting XML-"
"RPC servers. Run it in demo mode (as a program) to see it in action.   "
"Pointing the web browser to the RPC server produces pydoc-style "
"documentation; pointing xmlrpclib to the server allows invoking the actual "
"methods. (Contributed by Brian Quinlan.)"
msgstr ""
"El nuevo módulo :mod:`DocXMLRPCServer` permite escribir servidores XML-RPC "
"autodocumentados. Ejecútelo en modo de demostración (como un programa) para "
"verlo en acción. Al apuntar el navegador web al servidor RPC se produce una "
"documentación de estilo pydoc; apuntar xmlrpclib al servidor permite invocar "
"los métodos reales. (Contribuido por Brian Quinlan.)"

#: ../Doc/whatsnew/2.3.rst:1657
msgid ""
"Support for internationalized domain names (RFCs 3454, 3490, 3491, and 3492) "
"has been added. The \"idna\" encoding can be used to convert between a "
"Unicode domain name and the ASCII-compatible encoding (ACE) of that name. ::"
msgstr ""
"Se ha agregado soporte para nombres de dominio internacionalizados (RFCs "
"3454, 3490, 3491 y 3492). La codificación \"idna\" se puede utilizar para "
"convertir entre un nombre de dominio Unicode y la codificación compatible "
"con ASCII (ACE) de ese nombre. ::"

#: ../Doc/whatsnew/2.3.rst:1664
msgid ""
"The :mod:`socket` module has also been extended to transparently convert "
"Unicode hostnames to the ACE version before passing them to the C library. "
"Modules that deal with hostnames such as :mod:`httplib` and :mod:`ftplib`) "
"also support Unicode host names; :mod:`httplib` also sends HTTP ``Host`` "
"headers using the ACE version of the domain name.  :mod:`urllib` supports "
"Unicode URLs with non-ASCII host names as long as the ``path`` part of the "
"URL is ASCII only."
msgstr ""
"El módulo :mod:`socket` también se ha ampliado para convertir de forma "
"transparente los nombres de host Unicode a la versión ACE antes de pasarlos "
"a la biblioteca C. Los módulos que tratan con nombres de host como :mod:"
"`httplib` y :mod:`ftplib`) también admiten nombres de host Unicode; :mod:"
"`httplib` también envía encabezados HTTP ``Host`` utilizando la versión ACE "
"del nombre de dominio. :mod:`urllib` admite URL Unicode con nombres de host "
"que no sean ASCII siempre que la parte ``path`` de la URL sea solo ASCII."

#: ../Doc/whatsnew/2.3.rst:1672
msgid ""
"To implement this change, the :mod:`stringprep` module, the  "
"``mkstringprep`` tool and the ``punycode`` encoding have been added."
msgstr ""
"Para implementar este cambio, se han agregado el módulo :mod:`stringprep`, "
"la herramienta ``mkstringprep`` y la codificación ``punycode``."

#: ../Doc/whatsnew/2.3.rst:1679
msgid "Date/Time Type"
msgstr "Tipo de fecha / hora"

#: ../Doc/whatsnew/2.3.rst:1681
msgid ""
"Date and time types suitable for expressing timestamps were added as the :"
"mod:`datetime` module.  The types don't support different calendars or many "
"fancy features, and just stick to the basics of representing time."
msgstr ""
"Se agregaron tipos de fecha y hora adecuados para expresar marcas de tiempo "
"como módulo :mod:`datetime`. Los tipos no admiten diferentes calendarios ni "
"muchas funciones sofisticadas, y solo se ciñen a los conceptos básicos de la "
"representación del tiempo."

#: ../Doc/whatsnew/2.3.rst:1685
msgid ""
"The three primary types are: :class:`date`, representing a day, month, and "
"year; :class:`~datetime.time`, consisting of hour, minute, and second; and :"
"class:`~datetime.datetime`, which contains all the attributes of both :class:"
"`date` and :class:`~datetime.time`. There's also a :class:`timedelta` class "
"representing differences between two points in time, and time zone logic is "
"implemented by classes inheriting from the abstract :class:`tzinfo` class."
msgstr ""
"Los tres tipos principales son: :class:`date`, que representa un día, mes y "
"año; :class:`~datetime.time`, que consta de hora, minuto y segundo; y :class:"
"`~datetime.datetime`, que contiene todos los atributos de :class:`date` y :"
"class:`~datetime.time`. También hay una clase :class:`timedelta` que "
"representa las diferencias entre dos puntos en el tiempo, y la lógica de la "
"zona horaria se implementa mediante clases que heredan de la clase :class:"
"`tzinfo` abstracta."

#: ../Doc/whatsnew/2.3.rst:1692
msgid ""
"You can create instances of :class:`date` and :class:`~datetime.time` by "
"either supplying keyword arguments to the appropriate constructor, e.g. "
"``datetime.date(year=1972, month=10, day=15)``, or by using one of a number "
"of class methods.  For example, the :meth:`date.today` class method returns "
"the current local date."
msgstr ""
"Puede crear instancias de :class:`date` y :class:`~datetime.time` "
"proporcionando argumentos de palabras clave al constructor apropiado, p. Ej. "
"``datetime.date(year=1972, month=10, day=15)``, o utilizando uno de varios "
"métodos de clase. Por ejemplo, el método de clase :meth:`date.today` "
"devuelve la fecha local actual."

#: ../Doc/whatsnew/2.3.rst:1698
msgid ""
"Once created, instances of the date/time classes are all immutable. There "
"are a number of methods for producing formatted strings from objects::"
msgstr ""
"Una vez creadas, las instancias de las clases de fecha / hora son "
"inmutables. Hay varios métodos para producir cadenas formateadas a partir de "
"objetos:"

#: ../Doc/whatsnew/2.3.rst:1710
msgid ""
"The :meth:`replace` method allows modifying one or more fields  of a :class:"
"`date` or :class:`~datetime.datetime` instance, returning a new instance::"
msgstr ""
"El método :meth:`replace` permite modificar uno o más campos de una "
"instancia :class:`date` o :class:`~datetime.datetime`, devolviendo una nueva "
"instancia:"

#: ../Doc/whatsnew/2.3.rst:1720
msgid ""
"Instances can be compared, hashed, and converted to strings (the result is "
"the same as that of :meth:`isoformat`).  :class:`date` and :class:`~datetime."
"datetime` instances can be subtracted from each other, and added to :class:"
"`timedelta` instances.  The largest missing feature is that there's no "
"standard library support for parsing strings and getting back a :class:"
"`date` or :class:`~datetime.datetime`."
msgstr ""
"Las instancias se pueden comparar, aplicar hash y convertir en cadenas (el "
"resultado es el mismo que el de :meth:`isoformat`). Las instancias de :class:"
"`date` y :class:`~datetime.datetime` se pueden restar entre sí y agregarse a "
"las instancias de :class:`timedelta`. La mayor característica que falta es "
"que no hay soporte de biblioteca estándar para analizar cadenas y recuperar "
"un :class:`date` o :class:`~datetime.datetime`."

#: ../Doc/whatsnew/2.3.rst:1727
msgid ""
"For more information, refer to the module's reference documentation. "
"(Contributed by Tim Peters.)"
msgstr ""
"Para obtener más información, consulte la documentación de referencia del "
"módulo. (Contribuido por Tim Peters.)"

#: ../Doc/whatsnew/2.3.rst:1734
msgid "The optparse Module"
msgstr "El módulo optparse"

#: ../Doc/whatsnew/2.3.rst:1736
msgid ""
"The :mod:`getopt` module provides simple parsing of command-line arguments.  "
"The new :mod:`optparse` module (originally named Optik) provides more "
"elaborate command-line parsing that follows the Unix conventions, "
"automatically creates the output for :option:`!--help`, and can perform "
"different actions for different options."
msgstr ""
"El módulo :mod:`getopt` proporciona un análisis sencillo de los argumentos "
"de la línea de comandos. El nuevo módulo :mod:`optparse` (originalmente "
"llamado Optik) proporciona un análisis de línea de comandos más elaborado "
"que sigue las convenciones de Unix, crea automáticamente la salida para :"
"option:`!--help` y puede realizar diferentes acciones para diferentes "
"opciones."

#: ../Doc/whatsnew/2.3.rst:1742
msgid ""
"You start by creating an instance of :class:`OptionParser` and telling it "
"what your program's options are. ::"
msgstr ""
"Empiece creando una instancia de :class:`OptionParser` y diciéndole cuáles "
"son las opciones de su programa. ::"

#: ../Doc/whatsnew/2.3.rst:1756
msgid ""
"Parsing a command line is then done by calling the :meth:`parse_args` "
"method. ::"
msgstr ""
"Luego, el análisis de una línea de comando se realiza llamando al método :"
"meth:`parse_args`. ::"

#: ../Doc/whatsnew/2.3.rst:1762
msgid ""
"This returns an object containing all of the option values, and a list of "
"strings containing the remaining arguments."
msgstr ""
"Esto devuelve un objeto que contiene todos los valores de las opciones y una "
"lista de cadenas que contienen los argumentos restantes."

#: ../Doc/whatsnew/2.3.rst:1765
msgid ""
"Invoking the script with the various arguments now works as you'd expect it "
"to. Note that the length argument is automatically converted to an integer."
msgstr ""
"Invocar el script con los distintos argumentos ahora funciona como era de "
"esperar. Tenga en cuenta que el argumento de longitud se convierte "
"automáticamente en un número entero."

#: ../Doc/whatsnew/2.3.rst:1778
msgid "The help message is automatically generated for you:"
msgstr "El mensaje de ayuda se genera automáticamente para usted:"

#: ../Doc/whatsnew/2.3.rst:1793
msgid "See the module's documentation for more details."
msgstr "Consulte la documentación del módulo para obtener más detalles."

#: ../Doc/whatsnew/2.3.rst:1796
msgid ""
"Optik was written by Greg Ward, with suggestions from the readers of the "
"Getopt SIG."
msgstr ""
"Optik fue escrito por Greg Ward, con sugerencias de los lectores de Getopt "
"SIG."

#: ../Doc/whatsnew/2.3.rst:1805
msgid "Pymalloc: A Specialized Object Allocator"
msgstr "Pymalloc: un asignador de objetos especializado"

#: ../Doc/whatsnew/2.3.rst:1807
msgid ""
"Pymalloc, a specialized object allocator written by Vladimir Marangozov, was "
"a feature added to Python 2.1.  Pymalloc is intended to be faster than the "
"system :c:func:`malloc` and to have less memory overhead for allocation "
"patterns typical of Python programs. The allocator uses C's :c:func:`malloc` "
"function to get large pools of memory and then fulfills smaller memory "
"requests from these pools."
msgstr ""
"Pymalloc, un asignador de objetos especializado escrito por Vladimir "
"Marangozov, fue una característica agregada a Python 2.1. Pymalloc está "
"diseñado para ser más rápido que el sistema :c:func:`malloc` y tener menos "
"sobrecarga de memoria para los patrones de asignación típicos de los "
"programas Python. El asignador utiliza la función :c:func:`malloc` de C para "
"obtener grandes grupos de memoria y luego satisface las solicitudes de "
"memoria más pequeñas de estos grupos."

#: ../Doc/whatsnew/2.3.rst:1813
msgid ""
"In 2.1 and 2.2, pymalloc was an experimental feature and wasn't enabled by "
"default; you had to explicitly enable it when compiling Python by providing "
"the :option:`!--with-pymalloc` option to the :program:`configure` script.  "
"In 2.3, pymalloc has had further enhancements and is now enabled by default; "
"you'll have to supply :option:`!--without-pymalloc` to disable it."
msgstr ""
"En 2.1 y 2.2, pymalloc era una función experimental y no estaba habilitada "
"de forma predeterminada; tenía que habilitarlo explícitamente al compilar "
"Python proporcionando la opción :option:`!--with-pymalloc` al script: "
"program: `configure`. En 2.3, pymalloc ha tenido más mejoras y ahora está "
"habilitado de forma predeterminada; tendrá que suministrar :option:`!--"
"without-pymalloc` para deshabilitarlo."

#: ../Doc/whatsnew/2.3.rst:1819
msgid ""
"This change is transparent to code written in Python; however, pymalloc may "
"expose bugs in C extensions.  Authors of C extension modules should test "
"their code with pymalloc enabled, because some incorrect code may cause core "
"dumps at runtime."
msgstr ""
"Este cambio es transparente para el código escrito en Python; sin embargo, "
"pymalloc puede exponer errores en las extensiones C. Los autores de los "
"módulos de extensión C deben probar su código con pymalloc habilitado, ya "
"que algunos códigos incorrectos pueden causar volcados de núcleo en tiempo "
"de ejecución."

#: ../Doc/whatsnew/2.3.rst:1824
msgid ""
"There's one particularly common error that causes problems.  There are a "
"number of memory allocation functions in Python's C API that have previously "
"just been aliases for the C library's :c:func:`malloc` and :c:func:`free`, "
"meaning that if you accidentally called mismatched functions the error "
"wouldn't be noticeable. When the object allocator is enabled, these "
"functions aren't aliases of :c:func:`malloc` and :c:func:`free` any more, "
"and calling the wrong function to free memory may get you a core dump.  For "
"example, if memory was allocated using :c:func:`PyObject_Malloc`, it has to "
"be freed using :c:func:`PyObject_Free`, not :c:func:`free`.  A few modules "
"included with Python fell afoul of this and had to be fixed; doubtless there "
"are more third-party modules that will have the same problem."
msgstr ""
"Hay un error particularmente común que causa problemas. Hay una serie de "
"funciones de asignación de memoria en la API C de Python que anteriormente "
"solo eran alias para :c:func:`malloc` y :c:func:`free` de la biblioteca C, "
"lo que significa que si llama accidentalmente a funciones que no coinciden, "
"el error no se notará. Cuando el asignador de objetos está habilitado, estas "
"funciones ya no son alias de :c:func:`malloc` y :c:func:`free`, y llamar a "
"la función incorrecta para liberar memoria puede generar un volcado de "
"memoria. Por ejemplo, si la memoria se asignó utilizando :c:func:"
"`PyObject_Malloc`, debe liberarse utilizando :c:func:`PyObject_Free`, no :c:"
"func:`free`. Algunos módulos incluidos con Python entraron en conflicto con "
"esto y tuvieron que ser reparados; sin duda hay más módulos de terceros que "
"tendrán el mismo problema."

#: ../Doc/whatsnew/2.3.rst:1836
msgid ""
"As part of this change, the confusing multiple interfaces for allocating "
"memory have been consolidated down into two API families. Memory allocated "
"with one family must not be manipulated with functions from the other "
"family.  There is one family for allocating chunks of memory and another "
"family of functions specifically for allocating Python objects."
msgstr ""
"Como parte de este cambio, las confusas interfaces múltiples para asignar "
"memoria se han consolidado en dos familias de API. La memoria asignada a una "
"familia no debe manipularse con funciones de la otra familia. Hay una "
"familia para asignar fragmentos de memoria y otra familia de funciones "
"específicamente para asignar objetos Python."

#: ../Doc/whatsnew/2.3.rst:1842
msgid ""
"To allocate and free an undistinguished chunk of memory use the \"raw "
"memory\" family: :c:func:`PyMem_Malloc`, :c:func:`PyMem_Realloc`, and :c:"
"func:`PyMem_Free`."
msgstr ""
"Para asignar y liberar una porción de memoria no distinguida, use la familia "
"de \"memoria sin procesar\": :c:func:`PyMem_Malloc`, :c:func:`PyMem_Realloc` "
"y :c:func:`PyMem_Free`."

#: ../Doc/whatsnew/2.3.rst:1845
msgid ""
"The \"object memory\" family is the interface to the pymalloc facility "
"described above and is biased towards a large number of \"small\" "
"allocations: :c:func:`PyObject_Malloc`, :c:func:`PyObject_Realloc`, and :c:"
"func:`PyObject_Free`."
msgstr ""
"La familia de \"memoria de objetos\" es la interfaz para la instalación de "
"pymalloc descrita anteriormente y está sesgada hacia un gran número de "
"asignaciones \"pequeñas\": :c:func:`PyObject_Malloc`, :c:func:"
"`PyObject_Realloc` y :c:func:`PyObject_Free`."

#: ../Doc/whatsnew/2.3.rst:1849
msgid ""
"To allocate and free Python objects, use the \"object\" family :c:macro:"
"`PyObject_New`, :c:macro:`PyObject_NewVar`, and :c:func:`PyObject_Del`."
msgstr ""
"Para asignar y liberar objetos de Python, utilice la familia de \"objetos\" :"
"c:macro:`PyObject_New`, :c:macro:`PyObject_NewVar` y :c:func:`PyObject_Del`."

#: ../Doc/whatsnew/2.3.rst:1852
msgid ""
"Thanks to lots of work by Tim Peters, pymalloc in 2.3 also provides "
"debugging features to catch memory overwrites and doubled frees in both "
"extension modules and in the interpreter itself.  To enable this support, "
"compile a debugging version of the Python interpreter by running :program:"
"`configure` with :option:`!--with-pydebug`."
msgstr ""
"Gracias al gran trabajo de Tim Peters, pymalloc en 2.3 también proporciona "
"funciones de depuración para detectar sobrescrituras de memoria y "
"liberaciones duplicadas en ambos módulos de extensión y en el propio "
"intérprete. Para habilitar este soporte, compile una versión de depuración "
"del intérprete de Python ejecutando: programa: `configure` con :option:`!--"
"with-pydebug`."

#: ../Doc/whatsnew/2.3.rst:1858
msgid ""
"To aid extension writers, a header file :file:`Misc/pymemcompat.h` is "
"distributed with the source to Python 2.3 that allows Python extensions to "
"use the 2.3 interfaces to memory allocation while compiling against any "
"version of Python since 1.5.2.  You would copy the file from Python's source "
"distribution and bundle it with the source of your extension."
msgstr ""
"Para ayudar a los escritores de extensiones, se distribuye un archivo de "
"encabezado :file:`Misc/pymemcompat.h` con la fuente a Python 2.3 que permite "
"que las extensiones de Python usen las interfaces 2.3 para la asignación de "
"memoria mientras se compila con cualquier versión de Python desde la 1.5.2. "
"Debería copiar el archivo de la distribución fuente de Python y empaquetarlo "
"con la fuente de su extensión."

#: ../Doc/whatsnew/2.3.rst:1869
msgid "https://hg.python.org/cpython/file/default/Objects/obmalloc.c"
msgstr "https://hg.python.org/cpython/file/default/Objects/obmalloc.c"

#: ../Doc/whatsnew/2.3.rst:1868
msgid ""
"For the full details of the pymalloc implementation, see the comments at the "
"top of the file :file:`Objects/obmalloc.c` in the Python source code. The "
"above link points to the file within the python.org SVN browser."
msgstr ""
"Para obtener todos los detalles de la implementación de pymalloc, consulte "
"los comentarios en la parte superior del archivo :file:`Objects/obmalloc.c` "
"en el código fuente de Python. El enlace anterior apunta al archivo dentro "
"del navegador SVN de python.org."

#: ../Doc/whatsnew/2.3.rst:1876
msgid "Build and C API Changes"
msgstr "Cambios en la API de Build y C"

#: ../Doc/whatsnew/2.3.rst:1878
msgid "Changes to Python's build process and to the C API include:"
msgstr ""
"Los cambios en el proceso de compilación de Python y en la API de C incluyen:"

#: ../Doc/whatsnew/2.3.rst:1880
msgid ""
"The cycle detection implementation used by the garbage collection has proven "
"to be stable, so it's now been made mandatory.  You can no longer compile "
"Python without it, and the :option:`!--with-cycle-gc` switch to :program:"
"`configure` has been removed."
msgstr ""
"La implementación de detección de ciclos utilizada por la recolección de "
"basura ha demostrado ser estable, por lo que ahora se ha hecho obligatoria. "
"Ya no puede compilar Python sin él, y el cambio :option:`!--with-cycle-gc` "
"a: program: `configure` ha sido eliminado."

#: ../Doc/whatsnew/2.3.rst:1885
msgid ""
"Python can now optionally be built as a shared library (:file:`libpython2.3."
"so`) by supplying :option:`!--enable-shared` when running Python's :program:"
"`configure` script.  (Contributed by Ondrej Palkovsky.)"
msgstr ""
"Python ahora se puede construir opcionalmente como una biblioteca compartida "
"(:file:`libpython2.3.so`) proporcionando :option:`!--enable-shared` cuando "
"se ejecuta el script Python: program: `configure`. (Contribuido por Ondrej "
"Palkovsky.)"

#: ../Doc/whatsnew/2.3.rst:1889
msgid ""
"The :c:macro:`!DL_EXPORT` and :c:macro:`!DL_IMPORT` macros are now "
"deprecated. Initialization functions for Python extension modules should now "
"be declared using the new macro :c:macro:`PyMODINIT_FUNC`, while the Python "
"core will generally use the :c:macro:`!PyAPI_FUNC` and :c:macro:`!"
"PyAPI_DATA` macros."
msgstr ""
"Las macros :c:macro:`!DL_EXPORT` y :c:macro:`!DL_IMPORT` ahora están en "
"desuso. Las funciones de inicialización para los módulos de extensión de "
"Python ahora deben declararse usando la nueva macro :c:macro:"
"`PyMODINIT_FUNC`, mientras que el núcleo de Python generalmente usará las "
"macros :c:macro:`!PyAPI_FUNC` y :c:macro:`!PyAPI_DATA`."

#: ../Doc/whatsnew/2.3.rst:1894
#, python-format
msgid ""
"The interpreter can be compiled without any docstrings for the built-in "
"functions and modules by supplying :option:`!--without-doc-strings` to the :"
"program:`configure` script. This makes the Python executable about "
"10% smaller, but will also mean that you can't get help for Python's built-"
"ins.  (Contributed by Gustavo Niemeyer.)"
msgstr ""
"El intérprete se puede compilar sin ninguna cadena de documentación para las "
"funciones y módulos incorporados proporcionando :option:`!--without-doc-"
"strings` al script: program: `configure`. Esto hace que el ejecutable de "
"Python sea un 10% más pequeño, pero también significa que no puede obtener "
"ayuda para las funciones integradas de Python. (Contribución de Gustavo "
"Niemeyer.)"

#: ../Doc/whatsnew/2.3.rst:1900
msgid ""
"The :c:func:`!PyArg_NoArgs` macro is now deprecated, and code that uses it "
"should be changed.  For Python 2.2 and later, the method definition table "
"can specify the :c:macro:`METH_NOARGS` flag, signalling that there are no "
"arguments, and the argument checking can then be removed.  If compatibility "
"with pre-2.2 versions of Python is important, the code could use "
"``PyArg_ParseTuple(args, \"\")`` instead, but this will be slower than "
"using :c:macro:`METH_NOARGS`."
msgstr ""
"La macro :c:func:`!PyArg_NoArgs` ahora está en desuso y el código que la usa "
"debe cambiarse. Para Python 2.2 y versiones posteriores, la tabla de "
"definición de métodos puede especificar la marca :c:macro:`METH_NOARGS`, lo "
"que indica que no hay argumentos, y luego se puede eliminar la verificación "
"de argumentos. Si la compatibilidad con las versiones anteriores a la 2.2 de "
"Python es importante, el código podría usar ``PyArg_ParseTuple(args, \"\")`` "
"en su lugar, pero esto será más lento que usar :c:macro:`METH_NOARGS`."

#: ../Doc/whatsnew/2.3.rst:1907
msgid ""
":c:func:`PyArg_ParseTuple` accepts new format characters for various sizes "
"of unsigned integers: ``B`` for :c:expr:`unsigned char`, ``H`` for :c:expr:"
"`unsigned short int`,  ``I`` for :c:expr:`unsigned int`,  and ``K`` for :c:"
"expr:`unsigned long long`."
msgstr ""
":c:func:`PyArg_ParseTuple` acepta caracteres de nuevo formato para varios "
"tamaños de enteros sin signo: ``B`` para :c:expr:`unsigned char`, ``H`` "
"para :c:expr:`unsigned short int`, ``I`` para :c:expr:`unsigned int`, y "
"``K`` para :c:expr:`unsigned long long`."

#: ../Doc/whatsnew/2.3.rst:1912
msgid ""
"A new function, ``PyObject_DelItemString(mapping, char *key)`` was added as "
"shorthand for ``PyObject_DelItem(mapping, PyString_New(key))``."
msgstr ""
"Se agregó una nueva función, ``PyObject_DelItemString(mapping, char *key)``, "
"como abreviatura de ``PyObject_DelItem(mapping, PyString_New(key))``."

#: ../Doc/whatsnew/2.3.rst:1915
msgid ""
"File objects now manage their internal string buffer differently, increasing "
"it exponentially when needed.  This results in the benchmark tests in :file:"
"`Lib/test/test_bufio.py` speeding up considerably (from 57 seconds to 1.7 "
"seconds, according to one measurement)."
msgstr ""
"Los objetos de archivo ahora administran su búfer de cadena interno de "
"manera diferente, incrementándolo exponencialmente cuando es necesario. Esto "
"da como resultado que las pruebas de referencia en :file:`Lib/test/"
"test_bufio.py` se aceleren considerablemente (de 57 segundos a 1,7 segundos, "
"según una medición)."

#: ../Doc/whatsnew/2.3.rst:1920
msgid ""
"It's now possible to define class and static methods for a C extension type "
"by setting either the :c:macro:`METH_CLASS` or :c:macro:`METH_STATIC` flags "
"in a method's :c:type:`PyMethodDef` structure."
msgstr ""
"Ahora es posible definir métodos estáticos y de clase para un tipo de "
"extensión C configurando los indicadores :c:macro:`METH_CLASS` o :c:macro:"
"`METH_STATIC` en la estructura :c:type:`PyMethodDef` de un método."

#: ../Doc/whatsnew/2.3.rst:1924
msgid ""
"Python now includes a copy of the Expat XML parser's source code, removing "
"any dependence on a system version or local installation of Expat."
msgstr ""
"Python ahora incluye una copia del código fuente del analizador XML de "
"Expat, eliminando cualquier dependencia de una versión del sistema o "
"instalación local de Expat."

#: ../Doc/whatsnew/2.3.rst:1927
msgid ""
"If you dynamically allocate type objects in your extension, you should be "
"aware of a change in the rules relating to the :attr:`__module__` and :attr:"
"`~definition.__name__` attributes.  In summary, you will want to ensure the "
"type's dictionary contains a ``'__module__'`` key; making the module name "
"the part of the type name leading up to the final period will no longer have "
"the desired effect.  For more detail, read the API reference documentation "
"or the  source."
msgstr ""
"Si asigna dinámicamente objetos de tipo en su extensión, debe tener en "
"cuenta un cambio en las reglas relacionadas con los atributos :attr:"
"`__module__` y :attr:`~definition.__name__`. En resumen, querrá asegurarse "
"de que el diccionario del tipo contenga una clave ``'__module__'``; hacer "
"que el nombre del módulo sea la parte del nombre del tipo que conduce al "
"período final ya no tendrá el efecto deseado. Para obtener más detalles, lea "
"la documentación de referencia de la API o la fuente."

#: ../Doc/whatsnew/2.3.rst:1938
msgid "Port-Specific Changes"
msgstr "Cambios específicos del puerto"

#: ../Doc/whatsnew/2.3.rst:1940
msgid ""
"Support for a port to IBM's OS/2 using the EMX runtime environment was "
"merged into the main Python source tree.  EMX is a POSIX emulation layer "
"over the OS/2 system APIs.  The Python port for EMX tries to support all the "
"POSIX-like capability exposed by the EMX runtime, and mostly succeeds; :func:"
"`fork` and :func:`fcntl` are restricted by the limitations of the underlying "
"emulation layer.  The standard OS/2 port, which uses IBM's Visual Age "
"compiler, also gained support for case-sensitive import semantics as part of "
"the integration of the EMX port into CVS.  (Contributed by Andrew MacIntyre.)"
msgstr ""
"El soporte para un puerto para OS / 2 de IBM utilizando el entorno de "
"ejecución EMX se fusionó en el árbol de fuentes principal de Python. EMX es "
"una capa de emulación POSIX sobre las API del sistema OS / 2. El puerto de "
"Python para EMX intenta admitir toda la capacidad similar a POSIX expuesta "
"por el tiempo de ejecución de EMX y, en su mayoría, tiene éxito; :func:"
"`fork` y :func:`fcntl` están restringidos por las limitaciones de la capa de "
"emulación subyacente. El puerto estándar OS / 2, que utiliza el compilador "
"Visual Age de IBM, también obtuvo soporte para la semántica de importación "
"que distingue entre mayúsculas y minúsculas como parte de la integración del "
"puerto EMX en CVS. (Contribuido por Andrew MacIntyre.)"

#: ../Doc/whatsnew/2.3.rst:1949
msgid ""
"On MacOS, most toolbox modules have been weaklinked to improve backward "
"compatibility.  This means that modules will no longer fail to load if a "
"single routine is missing on the current OS version. Instead calling the "
"missing routine will raise an exception. (Contributed by Jack Jansen.)"
msgstr ""
"En MacOS, la mayoría de los módulos de la caja de herramientas tienen "
"vínculos débiles para mejorar la compatibilidad con versiones anteriores. "
"Esto significa que los módulos ya no dejarán de cargarse si falta una rutina "
"en la versión actual del sistema operativo. En su lugar, llamar a la rutina "
"que falta lanzará una excepción. (Contribuido por Jack Jansen.)"

#: ../Doc/whatsnew/2.3.rst:1954
msgid ""
"The RPM spec files, found in the :file:`Misc/RPM/` directory in the Python "
"source distribution, were updated for 2.3.  (Contributed by Sean "
"Reifschneider.)"
msgstr ""
"Los archivos de especificaciones de RPM, que se encuentran en el directorio :"
"file:`Misc/RPM/` en la distribución fuente de Python, se actualizaron para "
"la versión 2.3. (Contribución de Sean Reifschneider.)"

#: ../Doc/whatsnew/2.3.rst:1957
msgid ""
"Other new platforms now supported by Python include AtheOS (http://www."
"atheos.cx/), GNU/Hurd, and OpenVMS."
msgstr ""
"Otras plataformas nuevas ahora compatibles con Python incluyen AtheOS "
"(http://www.atheos.cx/), GNU / Hurd y OpenVMS."

#: ../Doc/whatsnew/2.3.rst:1966
msgid "Other Changes and Fixes"
msgstr "Otros cambios y correcciones"

#: ../Doc/whatsnew/2.3.rst:1968
msgid ""
"As usual, there were a bunch of other improvements and bugfixes scattered "
"throughout the source tree.  A search through the CVS change logs finds "
"there were 523 patches applied and 514 bugs fixed between Python 2.2 and "
"2.3.  Both figures are likely to be underestimates."
msgstr ""
"Como de costumbre, hubo un montón de otras mejoras y correcciones de errores "
"esparcidas por todo el árbol de fuentes. Una búsqueda en los registros de "
"cambios de CVS encuentra que se aplicaron 523 parches y se corrigieron 514 "
"errores entre Python 2.2 y 2.3. Es probable que ambas cifras estén "
"subestimadas."

#: ../Doc/whatsnew/2.3.rst:1973
msgid "Some of the more notable changes are:"
msgstr "Algunos de los cambios más notables son:"

#: ../Doc/whatsnew/2.3.rst:1975
msgid ""
"If the :envvar:`PYTHONINSPECT` environment variable is set, the Python "
"interpreter will enter the interactive prompt after running a Python "
"program, as if Python had been invoked with the :option:`-i` option. The "
"environment variable can be set before running the Python interpreter, or it "
"can be set by the Python program as part of its execution."
msgstr ""
"Si se establece la variable de entorno :envvar:`PYTHONINSPECT`, el "
"intérprete de Python ingresará al indicador interactivo después de ejecutar "
"un programa de Python, como si Python hubiera sido invocado con la opción :"
"option:`-i`. La variable de entorno se puede configurar antes de ejecutar el "
"intérprete de Python, o el programa Python puede configurarla como parte de "
"su ejecución."

#: ../Doc/whatsnew/2.3.rst:1981
msgid ""
"The :file:`regrtest.py` script now provides a way to allow \"all resources "
"except *foo*.\"  A resource name passed to the :option:`!-u` option can now "
"be prefixed with a hyphen (``'-'``) to mean \"remove this resource.\"  For "
"example, the option '``-uall,-bsddb``' could be used to enable the use of "
"all resources except ``bsddb``."
msgstr ""
"El script :file:`regrtest.py` ahora proporciona una forma de permitir "
"\"todos los recursos excepto *foo*\". Un nombre de recurso pasado a la "
"opción :option:`!-u` ahora se puede prefijar con un guión (``'-'``) para "
"significar \"eliminar este recurso\". Por ejemplo, la opción '``-uall,-"
"bsddb``' podría usarse para habilitar el uso de todos los recursos excepto "
"``bsddb``."

#: ../Doc/whatsnew/2.3.rst:1987
msgid ""
"The tools used to build the documentation now work under Cygwin as well as "
"Unix."
msgstr ""
"Las herramientas utilizadas para crear la documentación ahora funcionan "
"tanto en Cygwin como en Unix."

#: ../Doc/whatsnew/2.3.rst:1990
msgid ""
"The ``SET_LINENO`` opcode has been removed.  Back in the mists of time, this "
"opcode was needed to produce line numbers in tracebacks and support trace "
"functions (for, e.g., :mod:`pdb`). Since Python 1.5, the line numbers in "
"tracebacks have been computed using a different mechanism that works with "
"\"python -O\".  For Python 2.3 Michael Hudson implemented a similar scheme "
"to determine when to call the trace function, removing the need for "
"``SET_LINENO`` entirely."
msgstr ""
"Se ha eliminado el código de operación ``SET_LINENO``. En la noche de los "
"tiempos, este código de operación era necesario para producir números de "
"línea en rastreos y admitir funciones de rastreo (para, por ejemplo, :mod:"
"`pdb`). Desde Python 1.5, los números de línea en los rastreos se han "
"calculado utilizando un mecanismo diferente que funciona con \"python -O\". "
"Para Python 2.3, Michael Hudson implementó un esquema similar para "
"determinar cuándo llamar a la función de seguimiento, eliminando por "
"completo la necesidad de ``SET_LINENO``."

#: ../Doc/whatsnew/2.3.rst:1998
msgid ""
"It would be difficult to detect any resulting difference from Python code, "
"apart from a slight speed up when Python is run without :option:`-O`."
msgstr ""
"Sería difícil detectar cualquier diferencia resultante del código Python, "
"aparte de una ligera aceleración cuando Python se ejecuta sin :option:`-O`."

#: ../Doc/whatsnew/2.3.rst:2001
msgid ""
"C extensions that access the :attr:`f_lineno` field of frame objects should "
"instead call ``PyCode_Addr2Line(f->f_code, f->f_lasti)``. This will have the "
"added effect of making the code work as desired under \"python -O\" in "
"earlier versions of Python."
msgstr ""
"Las extensiones C que acceden al campo :attr:`f_lineno` de objetos de marco "
"deben llamar a ``PyCode_Addr2Line(f->f_code, f->f_lasti)``. Esto tendrá el "
"efecto adicional de hacer que el código funcione como se desea en \"python -"
"O\" en versiones anteriores de Python."

#: ../Doc/whatsnew/2.3.rst:2006
msgid ""
"A nifty new feature is that trace functions can now assign to the :attr:"
"`f_lineno` attribute of frame objects, changing the line that will be "
"executed next.  A ``jump`` command has been added to the :mod:`pdb` debugger "
"taking advantage of this new feature. (Implemented by Richie Hindle.)"
msgstr ""
"Una característica nueva e ingeniosa es que las funciones de seguimiento "
"ahora se pueden asignar al atributo :attr:`f_lineno` de los objetos de "
"marco, cambiando la línea que se ejecutará a continuación. Se ha agregado un "
"comando ``jump`` al depurador :mod:`pdb` aprovechando esta nueva "
"característica. (Implementado por Richie Hindle.)"

#: ../Doc/whatsnew/2.3.rst:2015
msgid "Porting to Python 2.3"
msgstr "Portar a Python 2.3"

#: ../Doc/whatsnew/2.3.rst:2017
msgid ""
"This section lists previously described changes that may require changes to "
"your code:"
msgstr ""
"Esta sección enumera los cambios descritos anteriormente que pueden requerir "
"cambios en su código:"

#: ../Doc/whatsnew/2.3.rst:2020
msgid ""
":keyword:`yield` is now always a keyword; if it's used as a variable name in "
"your code, a different name must be chosen."
msgstr ""
":keyword:`yield` ahora es siempre una palabra clave; si se usa como nombre "
"de variable en su código, se debe elegir un nombre diferente."

#: ../Doc/whatsnew/2.3.rst:2023
msgid ""
"For strings *X* and *Y*, ``X in Y`` now works if *X* is more than one "
"character long."
msgstr ""
"Para cadenas, *X* and *Y*, ASDF00 now works if *X* tiene más de un carácter."

#: ../Doc/whatsnew/2.3.rst:2026
msgid ""
"The :func:`int` type constructor will now return a long integer instead of "
"raising an :exc:`OverflowError` when a string or floating-point number is "
"too large to fit into an integer."
msgstr ""
"El constructor de tipo :func:`int` ahora retornará un entero largo en lugar "
"de lanzar un :exc:`OverflowError` cuando una cadena o un número de punto "
"flotante es demasiado grande para caber en un entero.  Esto puede llevar al "
"resultado paradójico de que ``isinstance(int(expresión), int)`` sea falso, "
"pero parece poco probable que cause problemas en la práctica."

#: ../Doc/whatsnew/2.3.rst:2030
msgid ""
"If you have Unicode strings that contain 8-bit characters, you must declare "
"the file's encoding (UTF-8, Latin-1, or whatever) by adding a comment to the "
"top of the file.  See section :ref:`section-encodings` for more information."
msgstr ""
"Si tiene cadenas Unicode que contienen caracteres de 8 bits, debe declarar "
"la codificación del archivo (UTF-8, Latin-1 o lo que sea) agregando un "
"comentario en la parte superior del archivo. Consulte la sección :ref:"
"`section-encodings` para obtener más información."

#: ../Doc/whatsnew/2.3.rst:2034
msgid ""
"Calling Tcl methods through :mod:`_tkinter` no longer  returns only strings. "
"Instead, if Tcl returns other objects those objects are converted to their "
"Python equivalent, if one exists, or wrapped with a :class:`_tkinter."
"Tcl_Obj` object if no Python equivalent exists."
msgstr ""
"Llamar a métodos Tcl a través del objeto :mod:`_tkinter` ya no retornan solo "
"cadenas de caracteres.En vez, si Tcl retorna otros objetos esos objetos son "
"convertidos a su equivalente en Python, si uno existe, o está envuelto con "
"un :class:`_tkinter.Tcl_Obj` si no existe un equivalente de Python."

#: ../Doc/whatsnew/2.3.rst:2039
msgid ""
"Large octal and hex literals such as ``0xffffffff`` now trigger a :exc:"
"`FutureWarning`. Currently they're stored as 32-bit numbers and result in a "
"negative value, but in Python 2.4 they'll become positive long integers."
msgstr ""
"Grandes literales octales y hexadecimales como ``0xffffffff`` ahora activan "
"un :exc:`FutureWarning`. Actualmente se almacenan como números de 32 bits y "
"dan como resultado un valor negativo, pero en Python 2.4 se convertirán en "
"enteros largos positivos."

#: ../Doc/whatsnew/2.3.rst:2043
msgid ""
"There are a few ways to fix this warning.  If you really need a positive "
"number, just add an ``L`` to the end of the literal.  If you're trying to "
"get a 32-bit integer with low bits set and have previously used an "
"expression such as ``~(1 << 31)``, it's probably clearest to start with all "
"bits set and clear the desired upper bits. For example, to clear just the "
"top bit (bit 31), you could write ``0xffffffffL &~(1L<<31)``."
msgstr ""
"Hay varias formas de corregir esta advertencia. Si realmente necesita un "
"número positivo, simplemente agregue un ``L`` al final del literal. Si está "
"tratando de obtener un entero de 32 bits con bits bajos establecidos y ha "
"usado previamente una expresión como ``~(1 << 31)``, probablemente sea más "
"claro comenzar con todos los bits establecidos y borrar los bits superiores "
"deseados. Por ejemplo, para borrar solo el bit superior (bit 31), puede "
"escribir ``0xffffffffL &~(1L<<31)``."

#: ../Doc/whatsnew/2.3.rst:2050
msgid "You can no longer disable assertions by assigning to ``__debug__``."
msgstr "Ya no puede deshabilitar las aserciones asignando a ``__debug__``."

#: ../Doc/whatsnew/2.3.rst:2052
msgid ""
"The Distutils :func:`setup` function has gained various new keyword "
"arguments such as *depends*.  Old versions of the Distutils will abort if "
"passed unknown keywords.  A solution is to check for the presence of the "
"new :func:`get_distutil_options` function in your :file:`setup.py` and only "
"uses the new keywords with a version of the Distutils that supports them::"
msgstr ""
"La función Distutils :func:`setup` ha ganado varios argumentos de palabras "
"clave nuevas, como *depends*. Las versiones antiguas de Distutils se "
"abortarán si se pasan palabras clave desconocidas. Una solución es verificar "
"la presencia de la nueva función :func:`get_distutil_options` en su :file:"
"`setup.py` y solo usa las nuevas palabras clave con una versión de Distutils "
"que las admita:"

#: ../Doc/whatsnew/2.3.rst:2065
msgid ""
"Using ``None`` as a variable name will now result in a :exc:`SyntaxWarning` "
"warning."
msgstr ""
"El uso de ``None`` como nombre de una variable ahora resultará en una "
"advertencia :exc:`SyntaxWarning`.  En una futura versión de Python, ``None`` "
"podría convertirse en una palabra clave."

#: ../Doc/whatsnew/2.3.rst:2068
msgid ""
"Names of extension types defined by the modules included with Python now "
"contain the module and a ``'.'`` in front of the type name."
msgstr ""
"Los nombres de los tipos de extensión definidos por los módulos incluidos "
"con Python ahora contienen el módulo y un ``'.'`` delante del nombre del "
"tipo."

#: ../Doc/whatsnew/2.3.rst:2077
msgid "Acknowledgements"
msgstr "Agradecimientos"

#: ../Doc/whatsnew/2.3.rst:2079
msgid ""
"The author would like to thank the following people for offering "
"suggestions, corrections and assistance with various drafts of this article: "
"Jeff Bauer, Simon Brunning, Brett Cannon, Michael Chermside, Andrew Dalke, "
"Scott David Daniels, Fred L. Drake, Jr., David Fraser,  Kelly Gerber, "
"Raymond Hettinger, Michael Hudson, Chris Lambert, Detlef Lannert, Martin von "
"Löwis, Andrew MacIntyre, Lalo Martins, Chad Netzer, Gustavo Niemeyer, Neal "
"Norwitz, Hans Nowak, Chris Reedy, Francesco Ricciardi, Vinay Sajip, Neil "
"Schemenauer, Roman Suzi, Jason Tishler, Just van Rossum."
msgstr ""
"El autor desea agradecer a las siguientes personas por ofrecer sugerencias, "
"correcciones y ayuda con varios borradores de este artículo: Jeff Bauer, "
"Simon Brunning, Brett Cannon, Michael Chermside, Andrew Dalke, Scott David "
"Daniels, Fred L. Drake, Jr., David Fraser, Kelly Gerber, Raymond Hettinger, "
"Michael Hudson, Chris Lambert, Detlef Lannert, Martin von Löwis, Andrew "
"MacIntyre, Lalo Martins, Chad Netzer, Gustavo Niemeyer, Neal Norwitz, Hans "
"Nowak, Chris Reedy, Francesco Ricciardi, Vinay Sajip, Neil Schemenauer, "
"Roman Suzi, Jason Tishler, Just van Rossum."

#: ../Doc/whatsnew/2.3.rst:371
msgid "universal newlines"
msgstr "saltos de línea universal"

#: ../Doc/whatsnew/2.3.rst:371
msgid "What's new"
msgstr "Qué hay de nuevo"