# 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: 2022-10-25 19:47+0200\n"

"PO-Revision-Date: 2020-11-29 11:59-0300\n"

"Last-Translator: \n"

"Language: es_ES\n"

"Language-Team: python-doc-es\n"

"Plural-Forms: nplurals=2; plural=(n != 1);\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=utf-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Generated-By: Babel 2.10.3\n"

#: ../Doc/whatsnew/3.0.rst:3

msgid "What's New In Python 3.0"

msgstr "Qué hay de nuevo en Python 3.0"

#: ../Doc/whatsnew/3.0.rst

msgid "Author"

msgstr "Autor"

#: ../Doc/whatsnew/3.0.rst:7

msgid "Guido van Rossum"

msgstr "Guido van Rossum"

#: ../Doc/whatsnew/3.0.rst:54

#, fuzzy

msgid ""

"This article explains the new features in Python 3.0, compared to 2.6. "

"Python 3.0, also known as \"Python 3000\" or \"Py3K\", is the first ever "

"*intentionally backwards incompatible* Python release. Python 3.0 was "

"released on December 3, 2008. There are more changes than in a typical "

"release, and more that are important for all Python users. Nevertheless, "

"after digesting the changes, you'll find that Python really hasn't changed "

"all that much -- by and large, we're mostly fixing well-known annoyances and "

"warts, and removing a lot of old cruft."

msgstr ""

"En este artículo se explican las nuevas características de Python 3.0, en "

"comparación con las de 2.6. Python 3.0, también conocido como \"Python "

"3000\" o \"Py3K\". Es la primera versión de Python *intencionalmente "

"incompatible hacia atrás*. Hay más cambios que en una versión típica y más "

"que son importantes para todos los usuarios de Python. Sin embargo, después "

"de digerir los cambios, se comprobará que Python no ha cambiado tanto "

"realmente -- en general, estamos arreglando en su mayoría molestias y "

"defectos bien conocidos, y la eliminación de una gran cantidad de sobras "

"antiguas."

#: ../Doc/whatsnew/3.0.rst:63

msgid ""

"This article doesn't attempt to provide a complete specification of all new "

"features, but instead tries to give a convenient overview. For full details, "

"you should refer to the documentation for Python 3.0, and/or the many PEPs "

"referenced in the text. If you want to understand the complete "

"implementation and design rationale for a particular feature, PEPs usually "

"have more details than the regular documentation; but note that PEPs usually "

"are not kept up-to-date once a feature has been fully implemented."

msgstr ""

"Este artículo no intenta proporcionar una especificación completa de todas "

"las características nuevas, sino que intenta proporcionar una visión general "

"conveniente. Para obtener más información, se debe consultar la "

"documentación de Python 3.0 y/o los muchos PEP a los que se hace referencia "

"en el texto. Si se desea comprender la lógica completa de implementación y "

"diseño para una característica determinada, los PEP suelen tener más "

"detalles que la documentación regular, pero téngase en cuenta que los PEP "

"generalmente no se mantienen actualizados una vez que una característica se "

"ha implementado completamente."

#: ../Doc/whatsnew/3.0.rst:72

msgid ""

"Due to time constraints this document is not as complete as it should have "

"been. As always for a new release, the ``Misc/NEWS`` file in the source "

"distribution contains a wealth of detailed information about every small "

"thing that was changed."

msgstr ""

"Debido a restricciones de tiempo, este documento no es tan completo como "

"debería haber sido. Como siempre para una nueva versión, el archivo ``Misc/"

"NEWS`` en la distribución de origen contiene una gran cantidad de "

"información detallada sobre cada pequeña cosa que se cambió."

#: ../Doc/whatsnew/3.0.rst:89

msgid "Common Stumbling Blocks"

msgstr "Escollos comunes"

#: ../Doc/whatsnew/3.0.rst:91

msgid ""

"This section lists those few changes that are most likely to trip you up if "

"you're used to Python 2.5."

msgstr ""

"Esta sección contiene esos pequeños cambios que probablemente generarán "

"tropiezos si se está acostumbrado a Python 2.5."

#: ../Doc/whatsnew/3.0.rst:95

msgid "Print Is A Function"

msgstr "*Print* es una función"

#: ../Doc/whatsnew/3.0.rst:97

msgid ""

"The ``print`` statement has been replaced with a :func:`print` function, "

"with keyword arguments to replace most of the special syntax of the old "

"``print`` statement (:pep:`3105`). Examples::"

msgstr ""

"La declaración ``print`` se ha sustituido por una función :func:`print`, con "

"argumentos de palabra clave para reemplazar la mayor parte de la sintaxis "

"especial de la antigua declaración ``print`` (:pep:`3105`). Ejemplos::"

#: ../Doc/whatsnew/3.0.rst:116

msgid "You can also customize the separator between items, e.g.::"

msgstr "También se puede personalizar el separador entre ítems, por ejemplo::"

#: ../Doc/whatsnew/3.0.rst:120

msgid "which produces:"

msgstr "que genera:"

#: ../Doc/whatsnew/3.0.rst:126

msgid "Note:"

msgstr "Nota:"

#: ../Doc/whatsnew/3.0.rst:128

msgid ""

"The :func:`print` function doesn't support the \"softspace\" feature of the "

"old ``print`` statement. For example, in Python 2.x, ``print \"A\\n\", "

"\"B\"`` would write ``\"A\\nB\\n\"``; but in Python 3.0, ``print(\"A\\n\", "

"\"B\")`` writes ``\"A\\n B\\n\"``."

msgstr ""

"La función :func:`print` no soporta la característica \"softspace\" de la "

"declaración ``print`` vieja. Por ejemplo, en Python 2.x ``print \"A\\n\", "

"\"B\"`` escribiría ``\"A\\nB\\n\"``; pero en Python 3.0, ``print(\"A\\n\", "

"\"B\")`` escribe ``\"A\\n B\\n\"``."

#: ../Doc/whatsnew/3.0.rst:133

msgid ""

"Initially, you'll be finding yourself typing the old ``print x`` a lot in "

"interactive mode. Time to retrain your fingers to type ``print(x)`` instead!"

msgstr ""

"Inicialmente, te encontrarás escribiendo mucho la antigua ``print x`` en "

"modo interactivo. ¡Es hora de volver a entrenar los dedos para escribir "

"``print(x)`` en su lugar!"

#: ../Doc/whatsnew/3.0.rst:137

msgid ""

"When using the ``2to3`` source-to-source conversion tool, all ``print`` "

"statements are automatically converted to :func:`print` function calls, so "

"this is mostly a non-issue for larger projects."

msgstr ""

"En el uso de la herramienta de conversión fuente-a-fuente ``2to3``, todos "

"las declaraciones ``print`` son automáticamente convertidas a una llamada de "

"la función :func:`print`, por lo que en general esto no es un problema para "

"proyectos más grandes."

#: ../Doc/whatsnew/3.0.rst:143

msgid "Views And Iterators Instead Of Lists"

msgstr "Vistas e iteradores en lugar de listas"

#: ../Doc/whatsnew/3.0.rst:145

msgid "Some well-known APIs no longer return lists:"

msgstr "Algunas APIs bien conocidas no retornan más listas:"

#: ../Doc/whatsnew/3.0.rst:147

msgid ""

":class:`dict` methods :meth:`dict.keys`, :meth:`dict.items` and :meth:`dict."

"values` return \"views\" instead of lists. For example, this no longer "

"works: ``k = d.keys(); k.sort()``. Use ``k = sorted(d)`` instead (this "

"works in Python 2.5 too and is just as efficient)."

msgstr ""

"Los métodos :class:`dict` :meth:`dict.keys`, :meth:`dict.items` y :meth:"

"`dict.values` retornan \"vistas\" en lugar de listas. Por ejemplo, esto no "

"funciona más: ``k = d.keys(); k.sort()``. Se usa ``k = sorted(d)`` en su "

"lugar (esto funciona también en Python 2.5 y es igual de eficiente)."

#: ../Doc/whatsnew/3.0.rst:153

msgid ""

"Also, the :meth:`dict.iterkeys`, :meth:`dict.iteritems` and :meth:`dict."

"itervalues` methods are no longer supported."

msgstr ""

"Además, los métodos :meth:`dict.iterkeys`, :meth:`dict.iteritems` y :meth:"

"`dict.itervalues` ya no son compatibles."

#: ../Doc/whatsnew/3.0.rst:156

msgid ""

":func:`map` and :func:`filter` return iterators. If you really need a list "

"and the input sequences are all of equal length, a quick fix is to wrap :"

"func:`map` in :func:`list`, e.g. ``list(map(...))``, but a better fix is "

"often to use a list comprehension (especially when the original code uses :"

"keyword:`lambda`), or rewriting the code so it doesn't need a list at all. "

"Particularly tricky is :func:`map` invoked for the side effects of the "

"function; the correct transformation is to use a regular :keyword:`for` loop "

"(since creating a list would just be wasteful)."

msgstr ""

":func:`map` y :func:`filter` retornan iteradores. Si realmente se necesita "

"una lista y las secuencias de entrada son todas de igual longitud, una "

"solución rápida es envolver :func:`map` en :func:`list`, por ejemplo "

"``list(map(...))``, pero una mejor solución es a menudo utilizar una lista "

"por comprensión (especialmente cuando el código original utiliza :keyword:"

"`lambda`), o reescribir el código para que no necesite una lista en "

"absoluto. Particularmente complicado es :func:`map` invocado para los "

"efectos secundarios de la función; la transformación correcta es usar un "

"bucle :keyword:`for` normal (ya que crear una lista sería simplemente un "

"desperdicio)."

#: ../Doc/whatsnew/3.0.rst:167

msgid ""

"If the input sequences are not of equal length, :func:`map` will stop at the "

"termination of the shortest of the sequences. For full compatibility with :"

"func:`map` from Python 2.x, also wrap the sequences in :func:`itertools."

"zip_longest`, e.g. ``map(func, *sequences)`` becomes ``list(map(func, "

"itertools.zip_longest(*sequences)))``."

msgstr ""

"Si las secuencias de entrada no tienen la misma longitud, :func:`map` se "

"detendrá en la terminación de la más corta de las secuencias. Para una "

"compatibilidad completa con :func:`map` de Python 2.x, también se envuelve "

"las secuencias en :func:`itertools.zip_longest`, por ejemplo ``map(func, "

"*sequences)`` se convierte en ``list(map(func, itertools."

"zip_longest(*sequences)))``."

#: ../Doc/whatsnew/3.0.rst:173

msgid ""

":func:`range` now behaves like :func:`xrange` used to behave, except it "

"works with values of arbitrary size. The latter no longer exists."

msgstr ""

":func:`range` ahora se comporta como :func:`xrange` solía comportarse, "

"excepto que funciona con valores de tamaño arbitrario. Este último ya no "

"existe."

#: ../Doc/whatsnew/3.0.rst:177

msgid ":func:`zip` now returns an iterator."

msgstr ":func:`zip` ahora retorna un iterador."

#: ../Doc/whatsnew/3.0.rst:180

msgid "Ordering Comparisons"

msgstr "Comparaciones de ordenamiento"

#: ../Doc/whatsnew/3.0.rst:182

msgid "Python 3.0 has simplified the rules for ordering comparisons:"

msgstr ""

"Python 3.0 ha simplificado las reglas para las comparaciones de ordenamiento:"

#: ../Doc/whatsnew/3.0.rst:184

msgid ""

"The ordering comparison operators (``<``, ``<=``, ``>=``, ``>``) raise a "

"TypeError exception when the operands don't have a meaningful natural "

"ordering. Thus, expressions like ``1 < ''``, ``0 > None`` or ``len <= len`` "

"are no longer valid, and e.g. ``None < None`` raises :exc:`TypeError` "

"instead of returning ``False``. A corollary is that sorting a heterogeneous "

"list no longer makes sense -- all the elements must be comparable to each "

"other. Note that this does not apply to the ``==`` and ``!=`` operators: "

"objects of different incomparable types always compare unequal to each other."

msgstr ""

"Los operadores de comparaciones de ordenamiento (``<``, ``<``,``'>``, ``>``) "

"lanzan una excepción *TypeError* cuando los operandos no tienen un orden "

"natural significativo. Por lo tanto, expresiones como ``1 < ''``, ``0 > "

"None`` o ``len <= len`` ya no son válidas, y por ejemplo ``Ninguno < "

"Ninguno`` lanza :exc:`TypeError` en lugar de retornar ``False``. Un "

"corolario es que ordenar una lista heterogénea ya no tiene sentido -- todos "

"los elementos deben ser comparables entre sí. Tener en cuenta que esto no se "

"aplica a los operadores ``==`` y ``!=``: los objetos de diferentes tipos "

"incomparables siempre se comparan desiguales entre sí."

#: ../Doc/whatsnew/3.0.rst:195

msgid ""

":meth:`builtin.sorted` and :meth:`list.sort` no longer accept the *cmp* "

"argument providing a comparison function. Use the *key* argument instead. N."

"B. the *key* and *reverse* arguments are now \"keyword-only\"."

msgstr ""

":meth:`builtin.sorted` y :meth:`list.sort` ya no aceptan el argumento *cmp* "

"que proporciona una función de comparación. Utilice el argumento *key* en su "

"lugar. N.B. los argumentos *key* y *reverse* ahora son \"argumentos por "

"palabra clave\"."

#: ../Doc/whatsnew/3.0.rst:200

msgid ""

"The :func:`cmp` function should be treated as gone, and the :meth:`__cmp__` "

"special method is no longer supported. Use :meth:`__lt__` for sorting, :"

"meth:`__eq__` with :meth:`__hash__`, and other rich comparisons as needed. "

"(If you really need the :func:`cmp` functionality, you could use the "

"expression ``(a > b) - (a < b)`` as the equivalent for ``cmp(a, b)``.)"

msgstr ""

"La función :func:`cmp` debe tratarse como quitada, y el método especial :"

"meth:`__cmp__` ya no es compatible. Utilizar :meth:`__lt__` para el "

"ordenamiento, :meth:`__eq__` con :meth:`__hash__`, y otras comparaciones "

"costosas según sea necesario. (Si realmente se necesita la funcionalidad :"

"func:`cmp`, se puede utilizar la expresión ``(a > b) - (a < b)`` como el "

"equivalente para ``cmp(a, b)``.)"

#: ../Doc/whatsnew/3.0.rst:207

msgid "Integers"

msgstr "Enteros"

#: ../Doc/whatsnew/3.0.rst:209

msgid ""

":pep:`237`: Essentially, :class:`long` renamed to :class:`int`. That is, "

"there is only one built-in integral type, named :class:`int`; but it behaves "

"mostly like the old :class:`long` type."

msgstr ""

":pep:`237`: Esencialmente, :class:`long` renombrado a :class:`int`. Es "

"decir, solo hay un tipo integral incorporado, denominado :class:`int`; pero "

"se comporta sobre todo como el viejo tipo :class:`long`."

#: ../Doc/whatsnew/3.0.rst:213

msgid ""

":pep:`238`: An expression like ``1/2`` returns a float. Use ``1//2`` to get "

"the truncating behavior. (The latter syntax has existed for years, at least "

"since Python 2.2.)"

msgstr ""

":pep:`238`: Una expresión como ``1/2`` retorna un float. Utilizar ``1//2`` "

"para obtener el comportamiento de truncamiento. (Esta última sintaxis ha "

"existido durante años, al menos desde Python 2.2.)"

#: ../Doc/whatsnew/3.0.rst:217

msgid ""

"The :data:`sys.maxint` constant was removed, since there is no longer a "

"limit to the value of integers. However, :data:`sys.maxsize` can be used as "

"an integer larger than any practical list or string index. It conforms to "

"the implementation's \"natural\" integer size and is typically the same as :"

"data:`sys.maxint` in previous releases on the same platform (assuming the "

"same build options)."

msgstr ""

"Se eliminó la constante :data:`sys.maxint`, ya que ya no hay un límite para "

"el valor de los enteros. Sin embargo, :data:`sys.maxsize` se puede utilizar "

"como un entero mayor que cualquier lista práctica o índice de cadena de "

"caracteres. Se ajusta al tamaño entero \"natural\" de la implementación y "

"suele ser el mismo que :data:`sys.maxint` en versiones anteriores de la "

"misma plataforma (suponiendo las mismas opciones de compilación)."

#: ../Doc/whatsnew/3.0.rst:224

msgid ""

"The :func:`repr` of a long integer doesn't include the trailing ``L`` "

"anymore, so code that unconditionally strips that character will chop off "

"the last digit instead. (Use :func:`str` instead.)"

msgstr ""

"El :func:`repr` de un entero largo ya no incluye la ``L`` final, por lo que "

"el código que elimina incondicionalmente ese carácter cortará el último "

"dígito en su lugar. (Utilizar :func:`str` en su lugar.)"

#: ../Doc/whatsnew/3.0.rst:228

msgid ""

"Octal literals are no longer of the form ``0720``; use ``0o720`` instead."

msgstr ""

"Los literales octales ya no usan la forma ``0720``; úsese ``0o720`` en su "

"lugar."

#: ../Doc/whatsnew/3.0.rst:232

msgid "Text Vs. Data Instead Of Unicode Vs. 8-bit"

msgstr "Texto vs. datos en lugar de unicode vs. 8 bits"

#: ../Doc/whatsnew/3.0.rst:234

msgid ""

"Everything you thought you knew about binary data and Unicode has changed."

msgstr "Todo lo que pensabas saber sobre datos binarios y Unicode ha cambiado."

#: ../Doc/whatsnew/3.0.rst:237

msgid ""

"Python 3.0 uses the concepts of *text* and (binary) *data* instead of "

"Unicode strings and 8-bit strings. All text is Unicode; however *encoded* "

"Unicode is represented as binary data. The type used to hold text is :class:"

"`str`, the type used to hold data is :class:`bytes`. The biggest difference "

"with the 2.x situation is that any attempt to mix text and data in Python "

"3.0 raises :exc:`TypeError`, whereas if you were to mix Unicode and 8-bit "

"strings in Python 2.x, it would work if the 8-bit string happened to contain "

"only 7-bit (ASCII) bytes, but you would get :exc:`UnicodeDecodeError` if it "

"contained non-ASCII values. This value-specific behavior has caused "

"numerous sad faces over the years."

msgstr ""

"Python 3.0 utiliza los conceptos de *text* y *datos* (binarios) en lugar de "

"cadenas de caracteres Unicode y cadenas de caracteres de 8 bits. Todo el "

"texto es Unicode; sin embargo el Unicode *codificado* se representa como "

"datos binarios. El tipo utilizado para contener texto es :class:`str`, el "

"tipo utilizado para contener datos es :class:`bytes`. La mayor diferencia "

"con la situación 2.x es que cualquier intento de mezclar texto y datos en "

"Python 3.0 lanza un :exc:`TypeError`, mientras que si se mezclan cadenas "

"Unicode y de 8 bits en Python 2.x, funcionaría si la cadena de 8 bits "

"contuviera sólo bytes de 7 bits (ASCII), pero se obtendría un :exc:"

"`UnicodeDecodeError` si contenía valores no ASCII. Este comportamiento "

"específico del valor ha causado numerosas caras tristes a lo largo de los "

"años."

#: ../Doc/whatsnew/3.0.rst:250

msgid ""

"As a consequence of this change in philosophy, pretty much all code that "

"uses Unicode, encodings or binary data most likely has to change. The "

"change is for the better, as in the 2.x world there were numerous bugs "

"having to do with mixing encoded and unencoded text. To be prepared in "

"Python 2.x, start using :class:`unicode` for all unencoded text, and :class:"

"`str` for binary or encoded data only. Then the ``2to3`` tool will do most "

"of the work for you."

msgstr ""

"Como consecuencia de este cambio en la filosofía, prácticamente todo el "

"código que utiliza Unicode, codificaciones o datos binarios muy "

"probablemente tiene que cambiar. El cambio es para mejor, ya que en el mundo "

"2.x había numerosos errores que tenían que ver con la mezcla de texto "

"codificado y sin codificar. Para estar preparado en Python 2.x, comienza a "

"usar :class:`unicode` para todo el texto sin codificar, y :class:`str` solo "

"para datos binarios o codificados. Luego , la herramienta ``2to3`` hará la "

"mayor parte del trabajo por ti."

#: ../Doc/whatsnew/3.0.rst:258

msgid ""

"You can no longer use ``u\"...\"`` literals for Unicode text. However, you "

"must use ``b\"...\"`` literals for binary data."

msgstr ""

"Ya no se puede utilizar literales ``u\"...\"`` para texto Unicode. Sin "

"embargo, se debe usar literales ``b\"...\"`` para los datos binarios."

#: ../Doc/whatsnew/3.0.rst:261

msgid ""

"As the :class:`str` and :class:`bytes` types cannot be mixed, you must "

"always explicitly convert between them. Use :meth:`str.encode` to go from :"

"class:`str` to :class:`bytes`, and :meth:`bytes.decode` to go from :class:"

"`bytes` to :class:`str`. You can also use ``bytes(s, encoding=...)`` and "

"``str(b, encoding=...)``, respectively."

msgstr ""

"Como los tipos :class:`str` y :class:`bytes` no se pueden mezclar, siempre "

"se deben convertir explícitamente entre ellos. Utilizar :meth:`str.encode` "

"para pasar de :class:`str` a :class:`bytes`, y :meth:`bytes.decode` para "

"pasar de :class:`bytes` a :class:`str`. También se puede utilizar ``bytes(s, "

"encoding=...)`` y ``str(b, encoding=...)``, respectivamente."

#: ../Doc/whatsnew/3.0.rst:268

msgid ""

"Like :class:`str`, the :class:`bytes` type is immutable. There is a "

"separate *mutable* type to hold buffered binary data, :class:`bytearray`. "

"Nearly all APIs that accept :class:`bytes` also accept :class:`bytearray`. "

"The mutable API is based on :class:`collections.MutableSequence`."

msgstr ""

"Al igual que :class:`str`, el tipo :class:`bytes` es inmutable. Hay un tipo "

"*mutable* independiente para contener datos binarios almacenados en búfer, :"

"class:`bytearray`. Casi todas las API que aceptan :class:`bytes` también "

"aceptan :class:`bytearray`. La API mutable se basa en :class:`collections. "

"MutableSequence`."

#: ../Doc/whatsnew/3.0.rst:274

msgid ""

"All backslashes in raw string literals are interpreted literally. This means "

"that ``'\\U'`` and ``'\\u'`` escapes in raw strings are not treated "

"specially. For example, ``r'\\u20ac'`` is a string of 6 characters in "

"Python 3.0, whereas in 2.6, ``ur'\\u20ac'`` was the single \"euro\" "

"character. (Of course, this change only affects raw string literals; the "

"euro character is ``'\\u20ac'`` in Python 3.0.)"

msgstr ""

"Todas las barras invertidas en literales de cadena de caracteres sin formato "

"se interpretan literalmente. Esto significa que los escapes ``'\\U'`` y "

"``'\\u'`` en cadenas de caracteres sin formato no se tratan especialmente. "

"Por ejemplo, ``r'\\u20ac'`` es una cadena de 6 caracteres en Python 3.0, "

"mientras que en 2.6, ``ur'\\u20ac'`` era el único carácter \"euro\". (Por "

"supuesto, este cambio sólo afecta a los literales de cadena de caracteres "

"sin formato; el carácter del euro es ``'\\u20ac'`` en Python 3.0.)"

#: ../Doc/whatsnew/3.0.rst:281

msgid ""

"The built-in :class:`basestring` abstract type was removed. Use :class:"

"`str` instead. The :class:`str` and :class:`bytes` types don't have "

"functionality enough in common to warrant a shared base class. The ``2to3`` "

"tool (see below) replaces every occurrence of :class:`basestring` with :"

"class:`str`."

msgstr ""

"Se eliminó el tipo abstracto :class:`basestring` incorporado. Se utiliza :"

"class:`str` en su lugar. Los tipos :class:`str` y :class:`bytes` no tienen "

"suficiente funcionalidad en común para garantizar una clase base compartida. "

"La herramienta ``2to3`` (ver más abajo) reemplaza cada aparición de :class:"

"`basestring` por :class:`str`."

#: ../Doc/whatsnew/3.0.rst:287

msgid ""

"Files opened as text files (still the default mode for :func:`open`) always "

"use an encoding to map between strings (in memory) and bytes (on disk). "

"Binary files (opened with a ``b`` in the mode argument) always use bytes in "

"memory. This means that if a file is opened using an incorrect mode or "

"encoding, I/O will likely fail loudly, instead of silently producing "

"incorrect data. It also means that even Unix users will have to specify the "

"correct mode (text or binary) when opening a file. There is a platform-"

"dependent default encoding, which on Unixy platforms can be set with the "

"``LANG`` environment variable (and sometimes also with some other platform-"

"specific locale-related environment variables). In many cases, but not all, "

"the system default is UTF-8; you should never count on this default. Any "

"application reading or writing more than pure ASCII text should probably "

"have a way to override the encoding. There is no longer any need for using "

"the encoding-aware streams in the :mod:`codecs` module."

msgstr ""

"Los archivos abiertos como archivos de texto (todavía el modo predeterminado "

"para :func:`open`) siempre utilizan una codificación para asignar entre "

"cadenas de caracteres(en memoria) y bytes (en disco). Los archivos binarios "

"(abiertos con una ``b`` en el argumento modo) siempre utilizan bytes en la "

"memoria. Esto significa que si un archivo se abre utilizando un modo o "

"codificación incorrectos, es probable que la E/S falle ruidosamente, en "

"lugar de producir datos incorrectos de forma silenciosa. También significa "

"que incluso los usuarios de Unix tendrán que especificar el modo correcto "

"(texto o binario) al abrir un archivo. Hay una codificación predeterminada "

"dependiente de la plataforma, que en las plataformas Unix se puede "

"establecer con la variable de entorno ``LANG`` (y a veces también con "

"algunas otras variables de entorno relacionadas con la configuración "

"regional específicas de la plataforma). En muchos casos, pero no en todos, "

"el valor predeterminado del sistema es UTF-8; nunca se debe contar con este "

"valor predeterminado. Cualquier aplicación que lea o escriba más que texto "

"ASCII puro probablemente debería tener una manera de invalidar la "

"codificación. Ya no es necesario utilizar las secuencias compatibles con la "

"codificación en el módulo :mod:`codecs`."

#: ../Doc/whatsnew/3.0.rst:304

msgid ""

"The initial values of :data:`sys.stdin`, :data:`sys.stdout` and :data:`sys."

"stderr` are now unicode-only text files (i.e., they are instances of :class:"

"`io.TextIOBase`). To read and write bytes data with these streams, you need "

"to use their :data:`io.TextIOBase.buffer` attribute."

msgstr ""

"Los valores iniciales de :data:`sys.stdin`, :data:`sys.stdout` y :data:`sys."

"stderr` ahora son archivos de texto solo unicode (es decir, son instancias "

"de :class:`io.TextIOBase`). Para leer y escribir datos de bytes con estas "

"secuencias, se debe usar su atributo :data:`io.TextIOBase.buffer`."

#: ../Doc/whatsnew/3.0.rst:310

msgid ""

"Filenames are passed to and returned from APIs as (Unicode) strings. This "

"can present platform-specific problems because on some platforms filenames "

"are arbitrary byte strings. (On the other hand, on Windows filenames are "

"natively stored as Unicode.) As a work-around, most APIs (e.g. :func:`open` "

"and many functions in the :mod:`os` module) that take filenames accept :"

"class:`bytes` objects as well as strings, and a few APIs have a way to ask "

"for a :class:`bytes` return value. Thus, :func:`os.listdir` returns a list "

"of :class:`bytes` instances if the argument is a :class:`bytes` instance, "

"and :func:`os.getcwdb` returns the current working directory as a :class:"

"`bytes` instance. Note that when :func:`os.listdir` returns a list of "

"strings, filenames that cannot be decoded properly are omitted rather than "

"raising :exc:`UnicodeError`."

msgstr ""

"Los nombres de archivos son pasados y retornados de cadenas desde APIs como "

"cadenas de caracteres (Unicode). Esto puede presentar problemas específicos "

"de plataformas porque en algunas plataformas los nombres de archivos son "

"cadenas de caracteres de bytes arbitrarios. (Por otro lado, en Windows los "

"nombres de archivos son almacenados de forma nativa como Unicode.) Como "

"solución alternativa, la mayoría de las APIs (por ejemplo :func:`open` y "

"muchas otras funciones en el módulo :mod:`os`) que toman nombres de archivos "

"aceptan tanto objetos :class:`bytes` como cadenas de caracteres, y algunas "

"APIs tienen una forma de demandar por un valor de retorno :class:`bytes`. "

"Por lo tanto, :func:`os.listdir` retorna una lista de instancias :class:"

"`bytes` si el argumento es una instancia :class:`bytes`, y :func:`os."

"getcwdb` retorna el directorio de trabajo actual como una instancia :class:"

"`bytes`. Tener en cuenta que cuando :func:`os.listdir` retorna una lista de "

"cadenas de caracteres, los nombres de archivo que no se pueden decodificar "

"correctamente se omiten en lugar de lanzar :exc:`UnicodeError`."

#: ../Doc/whatsnew/3.0.rst:325

msgid ""

"Some system APIs like :data:`os.environ` and :data:`sys.argv` can also "

"present problems when the bytes made available by the system is not "

"interpretable using the default encoding. Setting the ``LANG`` variable and "

"rerunning the program is probably the best approach."

msgstr ""

"Algunas APIs del sistema como :data:`os.environ` y :data:`sys.argv` también "

"pueden presentar problemas cuando los bytes puestos a disposición por el "

"sistema no son interpretables usando la codificación predeterminada. "

"Probablemente el mejor abordaje sea asignando la variable ``LANG`` y "

"volviendo a ejecutar el programa."

#: ../Doc/whatsnew/3.0.rst:330

msgid ""

":pep:`3138`: The :func:`repr` of a string no longer escapes non-ASCII "

"characters. It still escapes control characters and code points with non-"

"printable status in the Unicode standard, however."

msgstr ""

":pep:`3138`: El :func:`repr` de una cadena de caracteres ya no escapa "

"caracteres no ASCII. Sin embargo, todavía escapa caracteres de control "

"caracteres y puntos de código con estado no imprimible en el estándar the "

"Unicode."

#: ../Doc/whatsnew/3.0.rst:334

msgid ":pep:`3120`: The default source encoding is now UTF-8."

msgstr ":pep:`3120`: La codificación de fuente predeterminada ahora es UTF-8."

#: ../Doc/whatsnew/3.0.rst:336

msgid ""

":pep:`3131`: Non-ASCII letters are now allowed in identifiers. (However, the "

"standard library remains ASCII-only with the exception of contributor names "

"in comments.)"

msgstr ""

":pep:`3131`: Letras no ASCII ahora están permitidas en identificadores. (De "

"todas maneras, la librería estándar permanece como sólo ASCII con la "

"excepción de nombres de colaboradores en comentarios.)"

#: ../Doc/whatsnew/3.0.rst:340

msgid ""

"The :mod:`StringIO` and :mod:`cStringIO` modules are gone. Instead, import "

"the :mod:`io` module and use :class:`io.StringIO` or :class:`io.BytesIO` for "

"text and data respectively."

msgstr ""

"Los módulos :mod:`StringIO` and :mod:`cStringIO` ya no están. En su lugar, "

"se importa el módulo the :mod:`io` y se usa :class:`io.StringIO` o :class:"

"`io.BytesIO` para texto y datos respectivamente."

#: ../Doc/whatsnew/3.0.rst:344

msgid "See also the :ref:`unicode-howto`, which was updated for Python 3.0."

msgstr "Ver también :ref:`unicode-howto`, que fue actualizado para Python 3.0."

#: ../Doc/whatsnew/3.0.rst:348

msgid "Overview Of Syntax Changes"

msgstr "Descripción general de los cambios de sintaxis"

#: ../Doc/whatsnew/3.0.rst:350

msgid ""

"This section gives a brief overview of every *syntactic* change in Python "

"3.0."

msgstr ""

"Esta sección brinda una descripción general breve de cada cambio "

"*sintáctico* en Python 3.0."

#: ../Doc/whatsnew/3.0.rst:354

msgid "New Syntax"

msgstr "Nueva sintaxis"

#: ../Doc/whatsnew/3.0.rst:356

msgid ""

":pep:`3107`: Function argument and return value annotations. This provides "

"a standardized way of annotating a function's parameters and return value. "

"There are no semantics attached to such annotations except that they can be "

"introspected at runtime using the :attr:`__annotations__` attribute. The "

"intent is to encourage experimentation through metaclasses, decorators or "

"frameworks."

msgstr ""

":pep:`3107`: Argumento de función y anotaciones de valor retornado. Esto "

"proporciona una forma estandarizada de anotar los parámetros y el valor "

"retornado de una función. No hay semántica asociada a estas anotaciones, "

"excepto que se pueden introspeccionar en tiempo de ejecución mediante el "

"atributo :attr:`__annotations__`. La intención es fomentar la "

"experimentación a través de metaclases, decoradores o *frameworks*."

#: ../Doc/whatsnew/3.0.rst:363

msgid ""

":pep:`3102`: Keyword-only arguments. Named parameters occurring after "

"``*args`` in the parameter list *must* be specified using keyword syntax in "

"the call. You can also use a bare ``*`` in the parameter list to indicate "

"that you don't accept a variable-length argument list, but you do have "

"keyword-only arguments."

msgstr ""

":pep:`3102`: Argumentos de sólo palabra clave. Los parámetros con nombre que "

"se producen después de ``*args`` en la lista de parámetros *deben* "

"especificarse mediante la sintaxis de palabra clave en la llamada. También "

"puede usarse apenas un``*`` sólo en la lista de parámetros para indicar que "

"no se acepta una lista de argumentos de longitud variable, pero se tiene "

"argumentos de sólo palabra clave."

#: ../Doc/whatsnew/3.0.rst:369

msgid ""

"Keyword arguments are allowed after the list of base classes in a class "

"definition. This is used by the new convention for specifying a metaclass "

"(see next section), but can be used for other purposes as well, as long as "

"the metaclass supports it."

msgstr ""

"Los argumentos de palabra clave se permiten después de la lista de clases "

"base en una definición de clase. Esto lo usa la nueva convención para "

"especificar una metaclase (consultar la sección siguiente), pero también se "

"puede usar para otros fines, siempre y cuando la metaclase la admita."

#: ../Doc/whatsnew/3.0.rst:374

msgid ""

":pep:`3104`: :keyword:`nonlocal` statement. Using ``nonlocal x`` you can "

"now assign directly to a variable in an outer (but non-global) scope. :"

"keyword:`!nonlocal` is a new reserved word."

msgstr ""

":pep:`3104`: Declaración :keyword:`nonlocal`. Utilizando ``nonlocal x`` "

"ahora se puede asignar directamente a una variable en un entorno externo "

"(pero no global). :keyword:`!nonlocal` es una nueva palabra reservada."

#: ../Doc/whatsnew/3.0.rst:378

msgid ""

":pep:`3132`: Extended Iterable Unpacking. You can now write things like "

"``a, b, *rest = some_sequence``. And even ``*rest, a = stuff``. The "

"``rest`` object is always a (possibly empty) list; the right-hand side may "

"be any iterable. Example::"

msgstr ""

":pep:`3132`: Desempaque iterable extendido. Ahora se puede escribir cosas "

"como ``a, b, *rest = some_sequence``. E incluso ``*rest, a = cosas``. El "

"objeto ``rest`` es siempre una lista (posiblemente vacía); el lado derecho "

"puede ser cualquier iterable. Ejemplo::"

#: ../Doc/whatsnew/3.0.rst:385

msgid "This sets *a* to ``0``, *b* to ``4``, and *rest* to ``[1, 2, 3]``."

msgstr "Esto asigna *a* a ``0``, *b* a ``4``, y *rest* a ``[1, 2, 3]``."

#: ../Doc/whatsnew/3.0.rst:387

msgid ""

"Dictionary comprehensions: ``{k: v for k, v in stuff}`` means the same thing "

"as ``dict(stuff)`` but is more flexible. (This is :pep:`274` vindicated. :-)"

msgstr ""

"Comprensiones por diccionario: ``{k: v for k, v in cosas}`` significa lo "

"mismo que ``dict(cosas)``, pero es más flexible. (Esto es :pep:`274` "

"reivindicado. :-)"

#: ../Doc/whatsnew/3.0.rst:391

msgid ""

"Set literals, e.g. ``{1, 2}``. Note that ``{}`` is an empty dictionary; use "

"``set()`` for an empty set. Set comprehensions are also supported; e.g., "

"``{x for x in stuff}`` means the same thing as ``set(stuff)`` but is more "

"flexible."

msgstr ""

"Asignar los literales, por ejemplo, ``{1, 2}``. Tener en cuenta que ``{}`` "

"es un diccionario vacío; utilizar ``set()`` para un conjunto vacío. También "

"se admiten las comprensiones de conjunto; por ejemplo, ``x for x in cosas`` "

"significa lo mismo que ``set(cosas)``, pero es más flexible."

#: ../Doc/whatsnew/3.0.rst:396

msgid ""

"New octal literals, e.g. ``0o720`` (already in 2.6). The old octal literals "

"(``0720``) are gone."

msgstr ""

"Nuevos octales literales, por ejemplo, ``0o720`` (ya en 2.6). Los octales "

"literales viejos (``0720``) se eliminaron."

#: ../Doc/whatsnew/3.0.rst:399

msgid ""

"New binary literals, e.g. ``0b1010`` (already in 2.6), and there is a new "

"corresponding built-in function, :func:`bin`."

msgstr ""

"Nuevos literales binarios, por ejemplo, ``0b1010`` (ya en 2.6), y hay una "

"nueva función incorporada correspondiente, :func:`bin`."

#: ../Doc/whatsnew/3.0.rst:402

msgid ""

"Bytes literals are introduced with a leading ``b`` or ``B``, and there is a "

"new corresponding built-in function, :func:`bytes`."

msgstr ""

"Los literales de bytes se introducen con un ``b`` o ``B`` delantero, y hay "

"una nueva función incorporada correspondiente, :func:`bytes`."

#: ../Doc/whatsnew/3.0.rst:406

msgid "Changed Syntax"

msgstr "Sintaxis modificada"

#: ../Doc/whatsnew/3.0.rst:408

msgid ""

":pep:`3109` and :pep:`3134`: new :keyword:`raise` statement syntax: :samp:"

"`raise [{expr} [from {expr}]]`. See below."

msgstr ""

":pep:`3109` y :pep:`3134`: Nueva sintaxis de la instrucción :keyword:"

"`raise`: :samp:`raise [{expr} [from {expr}]]`. Ver a continuación."

#: ../Doc/whatsnew/3.0.rst:411

msgid ""

":keyword:`!as` and :keyword:`with` are now reserved words. (Since 2.6, "

"actually.)"

msgstr ""

":keyword:`!as` y :keyword:`with` ahora son palabras reservadas. (Desde 2.6, "

"de hecho.)"

#: ../Doc/whatsnew/3.0.rst:414

msgid ""

"``True``, ``False``, and ``None`` are reserved words. (2.6 partially "

"enforced the restrictions on ``None`` already.)"

msgstr ""

"``True``, ``False`` y ``None`` son palabras reservadas. (2.6 parcialmente "

"estableció restricciones ya en ``None``.)"

#: ../Doc/whatsnew/3.0.rst:417

msgid ""

"Change from :keyword:`except` *exc*, *var* to :keyword:`!except` *exc* :"

"keyword:`!as` *var*. See :pep:`3110`."

msgstr ""

"Cambio de :keyword:`except` *exc*, *var* a :keyword:`!except` *exc* :keyword:"

"`!as` *var*.Ver :pep:`3110`."

#: ../Doc/whatsnew/3.0.rst:420

msgid ":pep:`3115`: New Metaclass Syntax. Instead of::"

msgstr ":pep:`3115`: Nueva sintaxis de metaclase. En lugar de::"

#: ../Doc/whatsnew/3.0.rst:426

msgid "you must now use::"

msgstr "ahora se debe usar:"

#: ../Doc/whatsnew/3.0.rst:431

msgid ""

"The module-global :data:`__metaclass__` variable is no longer supported. "

"(It was a crutch to make it easier to default to new-style classes without "

"deriving every class from :class:`object`.)"

msgstr ""

"Ya no se admite la variable de módulo global :data:`__metaclass__`. (Era una "

"muleta para facilitar al valor predeterminado a las clases de estilo nuevo "

"sin derivar todas las clases de :class:`object`.)"

#: ../Doc/whatsnew/3.0.rst:436

msgid ""

"List comprehensions no longer support the syntactic form :samp:`[... for "

"{var} in {item1}, {item2}, ...]`. Use :samp:`[... for {var} in ({item1}, "

"{item2}, ...)]` instead. Also note that list comprehensions have different "

"semantics: they are closer to syntactic sugar for a generator expression "

"inside a :func:`list` constructor, and in particular the loop control "

"variables are no longer leaked into the surrounding scope."

msgstr ""

"Las listas por comprensión ya no admiten la forma sintáctica :samp:`[... for "

"{var} in {item1}, {item2}, ...]`. Utilizar :samp:`[... for{var} in ({item1}, "

"{item2}, ...)]` en su lugar. También tener en cuenta que las listas por "

"comprensión tienen semántica diferente: están más cerca del azúcar "

"sintáctico para una expresión de generador dentro de un constructor :func:"

"`list` y, en particular, las variables de control de bucle ya no se filtran "

"en el ámbito circundante."

#: ../Doc/whatsnew/3.0.rst:444

msgid ""

"The *ellipsis* (``...``) can be used as an atomic expression anywhere. "

"(Previously it was only allowed in slices.) Also, it *must* now be spelled "

"as ``...``. (Previously it could also be spelled as ``. . .``, by a mere "

"accident of the grammar.)"

msgstr ""

"La *elipsis* (``...``) puede ser utilizada como una expresión atómica en "

"cualquier lugar. (Previamente sólo estaba permitida en segmentos.) Asimismo, "

"esto ahora *debe* ser escrito como ``...``. (Anteriormente, también podía "

"ser escrito como ``. . .``, por un mero accidente de la gramática.)"

#: ../Doc/whatsnew/3.0.rst:450

msgid "Removed Syntax"

msgstr "Sintaxis eliminada"

#: ../Doc/whatsnew/3.0.rst:452

msgid ""

":pep:`3113`: Tuple parameter unpacking removed. You can no longer write "

"``def foo(a, (b, c)): ...``. Use ``def foo(a, b_c): b, c = b_c`` instead."

msgstr ""

":pep:`3113`: Desempaque de parámetros de tupla eliminados. Ya no se puede "

"escribir ``def foo(a, (b, c)): ...``. Utilizar ``def foo(a, b_c): b, c = "

"b_c`` en su lugar."

#: ../Doc/whatsnew/3.0.rst:456

msgid "Removed backticks (use :func:`repr` instead)."

msgstr "Comillas invertidas eliminadas (usar :func:`repr` en su lugar)."

#: ../Doc/whatsnew/3.0.rst:458

msgid "Removed ``<>`` (use ``!=`` instead)."

msgstr "Eliminados ``<>`` (usar ``!=`` en su lugar)."

#: ../Doc/whatsnew/3.0.rst:460

msgid ""

"Removed keyword: :func:`exec` is no longer a keyword; it remains as a "

"function. (Fortunately the function syntax was also accepted in 2.x.) Also "

"note that :func:`exec` no longer takes a stream argument; instead of "

"``exec(f)`` you can use ``exec(f.read())``."

msgstr ""

"Palabra clave eliminada: :func:`exec` ya no es una palabra clave; continúa "

"siendo una función. (Afortunadamente la sintaxis de la función también era "

"aceptada en 2.x.) Asimismo, nótese que la :func:`exec` ya no toma un "

"argumento de flujo; en lugar de ``exec(f)`` se puede utilizar ``exec(f."

"read())``."

#: ../Doc/whatsnew/3.0.rst:465

msgid "Integer literals no longer support a trailing ``l`` or ``L``."

msgstr "Literales enteros no admiten más ``l`` o ``L`` finales."

#: ../Doc/whatsnew/3.0.rst:467

msgid "String literals no longer support a leading ``u`` or ``U``."

msgstr ""

"Literales de cadena de caracteres no admiten más ``u`` or ``U`` iniciales."

#: ../Doc/whatsnew/3.0.rst:469

msgid ""

"The :keyword:`from` *module* :keyword:`import` ``*`` syntax is only allowed "

"at the module level, no longer inside functions."

msgstr ""

"La sintaxis :keyword:`from` *module* :keyword:`import` ``*`` solo se permite "

"en el nivel de módulo, ya no dentro de las funciones."

#: ../Doc/whatsnew/3.0.rst:472

msgid ""

"The only acceptable syntax for relative imports is :samp:`from .[{module}] "

"import {name}`. All :keyword:`import` forms not starting with ``.`` are "

"interpreted as absolute imports. (:pep:`328`)"

msgstr ""

"La única sintaxis aceptable para *imports* relativos es :samp:`from ."

"[{module}] import {name}`. Todos los formularios :keyword:`import` que no "

"comienzan con ``.`` son interpretados como *imports* absolutos"

#: ../Doc/whatsnew/3.0.rst:476

msgid "Classic classes are gone."

msgstr "Se eliminaron las clases clásicas."

#: ../Doc/whatsnew/3.0.rst:480

msgid "Changes Already Present In Python 2.6"

msgstr "Cambios ya presentes en Python 2.6"

#: ../Doc/whatsnew/3.0.rst:482

msgid ""

"Since many users presumably make the jump straight from Python 2.5 to Python "

"3.0, this section reminds the reader of new features that were originally "

"designed for Python 3.0 but that were back-ported to Python 2.6. The "

"corresponding sections in :ref:`whats-new-in-2.6` should be consulted for "

"longer descriptions."

msgstr ""

"Dado que es de suponer que muchos usuarios saltan directamente de Python 2.5 "

"a Python 3.0, esta sección recuerda al lector nuevas características que se "

"diseñaron originalmente para Python 3.0 pero que fueron llevadas hacia atrás "

"a Python 2.6. Las secciones correspondientes en :ref:`whats-new-in-2.6` "

"deberían ser consultadas para descripciones más largas."

#: ../Doc/whatsnew/3.0.rst:488

msgid ""

":ref:`pep-0343`. The :keyword:`with` statement is now a standard feature "

"and no longer needs to be imported from the :mod:`__future__`. Also check "

"out :ref:`new-26-context-managers` and :ref:`new-module-contextlib`."

msgstr ""

":ref:`pep-0343`.La declaración :keyword:`with` ahora es una característica "

"estándar y ya no necesita ser importada del :mod:`__future__`. También puede "

"revisarse :ref:`new-26-context-managers` y :ref:`new-module-contextlib`."

#: ../Doc/whatsnew/3.0.rst:493

msgid ""

":ref:`pep-0366`. This enhances the usefulness of the :option:`-m` option "

"when the referenced module lives in a package."

msgstr ""

":ref:`pep-0366`. Esto mejora la utilidad de opción :option:`-m` cuando el "

"módulo al que se hace referencia vive en un paquete."

#: ../Doc/whatsnew/3.0.rst:496

msgid ":ref:`pep-0370`."

msgstr ":ref:`pep-0370`."

#: ../Doc/whatsnew/3.0.rst:498

msgid ":ref:`pep-0371`."

msgstr ":ref:`pep-0371`."

#: ../Doc/whatsnew/3.0.rst:500

msgid ""

":ref:`pep-3101`. Note: the 2.6 description mentions the :meth:`format` "

"method for both 8-bit and Unicode strings. In 3.0, only the :class:`str` "

"type (text strings with Unicode support) supports this method; the :class:"

"`bytes` type does not. The plan is to eventually make this the only API for "

"string formatting, and to start deprecating the ``%`` operator in Python 3.1."

msgstr ""

":ref:`pep-3101`. Nota: la descripción 2.6 menciona el método :meth:`format` "

"tanto para cadenas de caracteres 8 bits como de Unicode. En 3.0, solo el "

"tipo :class:`str` (cadenas de texto con compatibilidad con Unicode) admite "

"este método; el tipo :class:`bytes` no. El plan es a la larga convertir esta "

"en la única API para el formato de cadena de caracteres y comenzar a dejar "

"de utilizar el operador ``%`` en Python 3.1."

#: ../Doc/whatsnew/3.0.rst:507

msgid ""

":ref:`pep-3105`. This is now a standard feature and no longer needs to be "

"imported from :mod:`__future__`. More details were given above."

msgstr ""

":ref:`pep-3105`. Esta ahora es una característica estándar y ya no necesita "

"ser importada de :mod:`__future__`. Más detalles fueron dados anteriormente."

#: ../Doc/whatsnew/3.0.rst:510

msgid ""

":ref:`pep-3110`. The :keyword:`except` *exc* :keyword:`!as` *var* syntax is "

"now standard and :keyword:`!except` *exc*, *var* is no longer supported. "

"(Of course, the :keyword:`!as` *var* part is still optional.)"

msgstr ""

":ref:`pep-3110`. La sintaxis :keyword:`except` *exc* :keyword:`!as` *var* "

"ahora es estándar y :keyword:`!except` *exc*, *var* ya no es compatible. "

"(Por supuesto, la parte :keyword:`!as` *var* sigue siendo opcional.)"

#: ../Doc/whatsnew/3.0.rst:515

msgid ""

":ref:`pep-3112`. The ``b\"...\"`` string literal notation (and its variants "

"like ``b'...'``, ``b\"\"\"...\"\"\"``, and ``br\"...\"``) now produces a "

"literal of type :class:`bytes`."

msgstr ""

":ref:`pep-3112`. La notación literal de cadena de caracteres ``b\"...\"`` (y "

"sus variantes como ``b'...'``, ``b\"\"\"...\"\"\"``, y ``br\"...\"``) ahora "

"genera un literal de tipo :class:`bytes`."

#: ../Doc/whatsnew/3.0.rst:519

msgid ""

":ref:`pep-3116`. The :mod:`io` module is now the standard way of doing file "

"I/O. The built-in :func:`open` function is now an alias for :func:`io.open` "

"and has additional keyword arguments *encoding*, *errors*, *newline* and "

"*closefd*. Also note that an invalid *mode* argument now raises :exc:"

"`ValueError`, not :exc:`IOError`. The binary file object underlying a text "

"file object can be accessed as :attr:`f.buffer` (but beware that the text "

"object maintains a buffer of itself in order to speed up the encoding and "

"decoding operations)."

msgstr ""

":ref:`pep-3116`. El módulo :mod:`io` ahora es la forma estándar de hacer E/S "

"de archivos. La función incorporada :func:`open` ahora es un alias para :"

"func:`io.open` y tiene argumentos de palabra clave adicionales *encoding*, "

"*errors*, *newline* y *closefd*. Tener en cuenta también que un argumento "

"*mode* inválido ahora lanza :exc:`ValueError`, no :exc:`IOError`. Se puede "

"acceder al objeto de archivo binario subyacente a un objeto de archivo de "

"texto como :attr:`f.buffer` (pero tener en cuenta que el objeto de texto "

"mantiene un búfer de sí mismo para acelerar las operaciones de codificación "

"y descodificación)."

#: ../Doc/whatsnew/3.0.rst:529

msgid ""

":ref:`pep-3118`. The old builtin :func:`buffer` is now really gone; the new "

"builtin :func:`memoryview` provides (mostly) similar functionality."

msgstr ""

":ref:`pep-3118`. El antiguo :func:`buffer` incorporado ahora realmente se ha "

"eliminado; el :func:`memoryview` incorporado nuevo proporciona (mayormente) "

"una funcionalidad similar."

#: ../Doc/whatsnew/3.0.rst:533

msgid ""

":ref:`pep-3119`. The :mod:`abc` module and the ABCs defined in the :mod:"

"`collections` module plays a somewhat more prominent role in the language "