diff --git a/.overrides/translation-memory.rst b/.overrides/translation-memory.rst index b8bff55117..5bdabf855b 100644 --- a/.overrides/translation-memory.rst +++ b/.overrides/translation-memory.rst @@ -37,3 +37,30 @@ Si quieres ver cómo se ha utilizado un término anteriormente, puedes utilizar docstring docstring. ``library/idle.po`` + + path + Ruta. ``glossary.po`` + + named tuple. + tupla nombrada ``glossary.po`` + + bytecodes + queda igual ``glossary.po`` + + deallocated + desalojable ``glossary.po`` + + callable + invocable ``glossary.po`` + + built-in + incorporada ``glossary.po`` + + mapping + mapeo ``glossary.po`` + + underscore + guión bajo ``glossary.po`` + + awaitable + aguardable ``glossary`` diff --git a/TRANSLATORS b/TRANSLATORS index b9cb1279eb..c49b83c7e7 100644 --- a/TRANSLATORS +++ b/TRANSLATORS @@ -2,4 +2,5 @@ Héctor Canto (@hectorcanto_dev) Raúl Cumplido (@raulcd) Nicolás Demarchi (@gilgamezh) Manuel Kaufmann (@humitos) +María Andrea Vignau (@mavignau @marian-vignau) Marco Richetta (@marcorichetta) diff --git a/glossary.po b/glossary.po index 58010de5b1..c2ef858b76 100644 --- a/glossary.po +++ b/glossary.po @@ -1,58 +1,72 @@ # 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. +# 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/PyCampES/python-docs-es/blob/3.7/TRANSLATORS to get the list of volunteers # -#, fuzzy msgid "" msgstr "" "Project-Id-Version: Python 3.7\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2019-05-06 11:59-0400\n" -"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" -"Last-Translator: FULL NAME \n" -"Language-Team: python-doc-es (https://mail.python.org/mailman3/lists/docs-es.python.org)\n" +"PO-Revision-Date: 2020-05-06 03:50-0300\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" +"Last-Translator: María Andrea Vignau\n" +"Language-Team: python-doc-es (https://mail.python.org/mailman3/lists/docs-es." +"python.org)\n" +"Language: es\n" +"X-Generator: Poedit 2.0.6\n" +"X-Poedit-Bookmarks: 252,222,9,62,-1,-1,-1,-1,-1,-1\n" #: ../Doc/glossary.rst:5 msgid "Glossary" -msgstr "" +msgstr "Glosario" #: ../Doc/glossary.rst:10 msgid "``>>>``" -msgstr "" +msgstr "``>>>``" #: ../Doc/glossary.rst:12 msgid "" "The default Python prompt of the interactive shell. Often seen for code " "examples which can be executed interactively in the interpreter." msgstr "" +"El prompt en el shell interactivo de Python por omisión. Frecuentemente vistos " +"en ejemplos de código que pueden ser ejecutados interactivamente en el " +"intérprete." #: ../Doc/glossary.rst:14 msgid "``...``" -msgstr "" +msgstr "``...``" #: ../Doc/glossary.rst:16 msgid "" "The default Python prompt of the interactive shell when entering code for an " -"indented code block, when within a pair of matching left and right " -"delimiters (parentheses, square brackets, curly braces or triple quotes), or " -"after specifying a decorator." +"indented code block, when within a pair of matching left and right delimiters " +"(parentheses, square brackets, curly braces or triple quotes), or after " +"specifying a decorator." msgstr "" +"El prompt en el shell interactivo de Python por omisión cuando se ingresa " +"código para un bloque indentado de código, y cuando se encuentra entre dos " +"delimitadores que emparejan (paréntesis, corchetes, llaves o comillas " +"triples), o después de especificar un decorador." #: ../Doc/glossary.rst:20 msgid "2to3" -msgstr "" +msgstr "2to3" #: ../Doc/glossary.rst:22 msgid "" "A tool that tries to convert Python 2.x code to Python 3.x code by handling " -"most of the incompatibilities which can be detected by parsing the source " -"and traversing the parse tree." +"most of the incompatibilities which can be detected by parsing the source and " +"traversing the parse tree." msgstr "" +"Una herramienta que intenta convertir código de Python 2.x a Python 3.x " +"arreglando la mayoría de las incompatibilidades que pueden ser detectadas " +"analizando el código y recorriendo el árbol de análisis sintáctico." #: ../Doc/glossary.rst:26 msgid "" @@ -60,74 +74,107 @@ msgid "" "entry point is provided as :file:`Tools/scripts/2to3`. See :ref:`2to3-" "reference`." msgstr "" +"2to3 está disponible en la biblioteca estándar como :mod:`lib2to3`; un punto " +"de entrada independiente es provisto como :file:`Tools/scripts/2to3`. Vea :" +"ref:`2to3-reference`." #: ../Doc/glossary.rst:29 msgid "abstract base class" -msgstr "" +msgstr "clase base abstracta" #: ../Doc/glossary.rst:31 msgid "" "Abstract base classes complement :term:`duck-typing` by providing a way to " "define interfaces when other techniques like :func:`hasattr` would be clumsy " "or subtly wrong (for example with :ref:`magic methods `). " -"ABCs introduce virtual subclasses, which are classes that don't inherit from " -"a class but are still recognized by :func:`isinstance` and :func:" -"`issubclass`; see the :mod:`abc` module documentation. Python comes with " -"many built-in ABCs for data structures (in the :mod:`collections.abc` " -"module), numbers (in the :mod:`numbers` module), streams (in the :mod:`io` " -"module), import finders and loaders (in the :mod:`importlib.abc` module). " -"You can create your own ABCs with the :mod:`abc` module." -msgstr "" +"ABCs introduce virtual subclasses, which are classes that don't inherit from a " +"class but are still recognized by :func:`isinstance` and :func:`issubclass`; " +"see the :mod:`abc` module documentation. Python comes with many built-in ABCs " +"for data structures (in the :mod:`collections.abc` module), numbers (in the :" +"mod:`numbers` module), streams (in the :mod:`io` module), import finders and " +"loaders (in the :mod:`importlib.abc` module). You can create your own ABCs " +"with the :mod:`abc` module." +msgstr "" +"Las clases base abstractas (ABC, por sus siglas en inglés `Abstract Base " +"Class`) complementan al :term:`duck-typing` brindando un forma de definir " +"interfaces con técnicas como :func:`hasattr` que serían confusas o sutilmente " +"erróneas (por ejemplo con :ref:`magic methods `). Las ABC " +"introduce subclases virtuales, las cuales son clases que no heredan desde una " +"clase pero aún así son reconocidas por :func:`isinstance` y :func:" +"`issubclass`; vea la documentación del módulo :mod:`abc`. Python viene con " +"muchas ABC incorporadas para las estructuras de datos( en el módulo :mod:" +"`collections.abc`), números (en el módulo :mod:`numbers` ) , flujos de datos " +"(en el módulo :mod:`io` ) , buscadores y cargadores de importaciones (en el " +"módulo :mod:`importlib.abc` ) . Puede crear sus propios ABCs con el módulo :" +"mod:`abc`." #: ../Doc/glossary.rst:42 msgid "annotation" -msgstr "" +msgstr "anotación" #: ../Doc/glossary.rst:44 msgid "" -"A label associated with a variable, a class attribute or a function " -"parameter or return value, used by convention as a :term:`type hint`." +"A label associated with a variable, a class attribute or a function parameter " +"or return value, used by convention as a :term:`type hint`." msgstr "" +"Una etiqueta asociada a una variable, atributo de clase, parámetro de función " +"o valor de retorno, usado por convención como un :term:`type hint`." #: ../Doc/glossary.rst:48 msgid "" -"Annotations of local variables cannot be accessed at runtime, but " -"annotations of global variables, class attributes, and functions are stored " -"in the :attr:`__annotations__` special attribute of modules, classes, and " -"functions, respectively." +"Annotations of local variables cannot be accessed at runtime, but annotations " +"of global variables, class attributes, and functions are stored in the :attr:" +"`__annotations__` special attribute of modules, classes, and functions, " +"respectively." msgstr "" +"Las anotaciones de variables no pueden ser accedidas en tiempo de ejecución, " +"pero las anotaciones de variables globales, atributos de clase, y funciones " +"son almacenadas en el atributo especial :attr:`__annotations__` de módulos, " +"clases y funciones, respectivamente." #: ../Doc/glossary.rst:54 msgid "" -"See :term:`variable annotation`, :term:`function annotation`, :pep:`484` " -"and :pep:`526`, which describe this functionality." +"See :term:`variable annotation`, :term:`function annotation`, :pep:`484` and :" +"pep:`526`, which describe this functionality." msgstr "" +"Vea :term:`variable annotation`, :term:`function annotation`, :pep:`484` y :" +"pep:`526`, los cuales describen esta funcionalidad." #: ../Doc/glossary.rst:56 msgid "argument" -msgstr "" +msgstr "argumento" #: ../Doc/glossary.rst:58 msgid "" "A value passed to a :term:`function` (or :term:`method`) when calling the " "function. There are two kinds of argument:" msgstr "" +"Un valor pasado a una :term:`function` (o :term:`method`) cuando se llama a la " +"función. Hay dos clases de argumentos:" #: ../Doc/glossary.rst:61 msgid "" ":dfn:`keyword argument`: an argument preceded by an identifier (e.g. " -"``name=``) in a function call or passed as a value in a dictionary preceded " -"by ``**``. For example, ``3`` and ``5`` are both keyword arguments in the " +"``name=``) in a function call or passed as a value in a dictionary preceded by " +"``**``. For example, ``3`` and ``5`` are both keyword arguments in the " "following calls to :func:`complex`::" msgstr "" +":dfn:`argumento nombrado`: es un argumento precedido por un identificador (por " +"ejemplo, ``nombre=``) en una llamada a una función o pasado como valor en un " +"diccionario precedido por ``**``. Por ejemplo ``3`` y ``5`` son argumentos " +"nombrados en las llamadas a :func:`complex`::" #: ../Doc/glossary.rst:69 msgid "" ":dfn:`positional argument`: an argument that is not a keyword argument. " -"Positional arguments can appear at the beginning of an argument list and/or " -"be passed as elements of an :term:`iterable` preceded by ``*``. For example, " +"Positional arguments can appear at the beginning of an argument list and/or be " +"passed as elements of an :term:`iterable` preceded by ``*``. For example, " "``3`` and ``5`` are both positional arguments in the following calls::" msgstr "" +":dfn:`argumento posicional` son aquellos que no son nombrados. Los argumentos " +"posicionales deben aparecer al principio de una lista de argumentos o ser " +"pasados como elementos de un :term:`iterable` precedido por ``*``. Por " +"ejemplo, ``3`` y ``5`` son argumentos posicionales en las siguientes llamadas:" #: ../Doc/glossary.rst:78 msgid "" @@ -136,17 +183,24 @@ msgid "" "Syntactically, any expression can be used to represent an argument; the " "evaluated value is assigned to the local variable." msgstr "" +"Los argumentos son asignados a las variables locales en el cuerpo de la " +"función. Vea en la sección :ref:`calls` las reglas que rigen estas " +"asignaciones. Sintácticamente, cualquier expresión puede ser usada para " +"representar un argumento; el valor evaluado es asignado a la variable local." #: ../Doc/glossary.rst:83 msgid "" "See also the :term:`parameter` glossary entry, the FAQ question on :ref:`the " -"difference between arguments and parameters `, " -"and :pep:`362`." +"difference between arguments and parameters `, and :" +"pep:`362`." msgstr "" +"Vea también el :term:`parameter` en el glosario, la pregunta frecuente :ref:" +"`la diferencia entre argumentos y parámetros `, y :" +"pep:`362`." #: ../Doc/glossary.rst:86 msgid "asynchronous context manager" -msgstr "" +msgstr "administrador asincrónico de contexto" #: ../Doc/glossary.rst:88 msgid "" @@ -154,18 +208,25 @@ msgid "" "statement by defining :meth:`__aenter__` and :meth:`__aexit__` methods. " "Introduced by :pep:`492`." msgstr "" +"Un objeto que controla el entorno visible en un sentencia :keyword:`async " +"with` al definir los métodos :meth:`__aenter__` :meth:`__aexit__`. " +"Introducido por :pep:`492`." #: ../Doc/glossary.rst:91 msgid "asynchronous generator" -msgstr "" +msgstr "generador asincrónico" #: ../Doc/glossary.rst:93 msgid "" -"A function which returns an :term:`asynchronous generator iterator`. It " -"looks like a coroutine function defined with :keyword:`async def` except " -"that it contains :keyword:`yield` expressions for producing a series of " -"values usable in an :keyword:`async for` loop." +"A function which returns an :term:`asynchronous generator iterator`. It looks " +"like a coroutine function defined with :keyword:`async def` except that it " +"contains :keyword:`yield` expressions for producing a series of values usable " +"in an :keyword:`async for` loop." msgstr "" +"Una función que retorna un :term:`asynchronous generator iterator`. Es similar " +"a una función corrutina definida con :keyword:`async def` excepto que contiene " +"expresiones :keyword:`yield` para producir series de variables usadas en un " +"ciclo :keyword:`async for`." #: ../Doc/glossary.rst:98 msgid "" @@ -173,28 +234,37 @@ msgid "" "*asynchronous generator iterator* in some contexts. In cases where the " "intended meaning isn't clear, using the full terms avoids ambiguity." msgstr "" +"Usualmente se refiere a una función generadora asincrónica, pero puede " +"referirse a un *iterador generador asincrónico* en ciertos contextos. En " +"aquellos casos en los que el significado no está claro, usar los términos " +"completos evita la ambigüedad." #: ../Doc/glossary.rst:102 msgid "" -"An asynchronous generator function may contain :keyword:`await` expressions " -"as well as :keyword:`async for`, and :keyword:`async with` statements." +"An asynchronous generator function may contain :keyword:`await` expressions as " +"well as :keyword:`async for`, and :keyword:`async with` statements." msgstr "" +"Una función generadora asincrónica puede contener expresiones :keyword:`await` " +"así como sentencias :keyword:`async for`, y :keyword:`async with`." #: ../Doc/glossary.rst:105 msgid "asynchronous generator iterator" -msgstr "" +msgstr "iterador generador asincrónico" #: ../Doc/glossary.rst:107 msgid "An object created by a :term:`asynchronous generator` function." -msgstr "" +msgstr "Un objeto creado por una función :term:`asynchronous generator`." #: ../Doc/glossary.rst:109 msgid "" "This is an :term:`asynchronous iterator` which when called using the :meth:" -"`__anext__` method returns an awaitable object which will execute the body " -"of the asynchronous generator function until the next :keyword:`yield` " -"expression." +"`__anext__` method returns an awaitable object which will execute the body of " +"the asynchronous generator function until the next :keyword:`yield` expression." msgstr "" +"Este es un :term:`asynchronous iterator` el cual cuando es llamado usa el " +"método :meth:`__anext__` retornando un objeto aguardable el cual ejecutará el " +"cuerpo de la función generadora asincrónica hasta la siguiente expresión :" +"keyword:`yield`." #: ../Doc/glossary.rst:114 msgid "" @@ -204,21 +274,29 @@ msgid "" "with another awaitable returned by :meth:`__anext__`, it picks up where it " "left off. See :pep:`492` and :pep:`525`." msgstr "" +"Cada :keyword:`yield` suspende temporalmente el procesamiento, recordando el " +"estado local de ejecución (incluyendo a las variables locales y las sentencias " +"`try` pendientes). Cuando el *iterador del generador asincrónico* vuelve " +"efectivamente con otro aguardable retornado por el método :meth:`__anext__`, " +"retoma donde lo dejó. Vea :pep:`492` y :pep:`525`." #: ../Doc/glossary.rst:119 msgid "asynchronous iterable" -msgstr "" +msgstr "iterable asincrónico" #: ../Doc/glossary.rst:121 msgid "" -"An object, that can be used in an :keyword:`async for` statement. Must " -"return an :term:`asynchronous iterator` from its :meth:`__aiter__` method. " +"An object, that can be used in an :keyword:`async for` statement. Must return " +"an :term:`asynchronous iterator` from its :meth:`__aiter__` method. " "Introduced by :pep:`492`." msgstr "" +"Un objeto, que puede ser usado en una sentencia :keyword:`async for`. Debe " +"retornar un :term:`asynchronous iterator` de su método :meth:`__aiter__`. " +"Introducido por :pep:`492`." #: ../Doc/glossary.rst:124 msgid "asynchronous iterator" -msgstr "" +msgstr "iterador asincrónico" #: ../Doc/glossary.rst:126 msgid "" @@ -228,10 +306,15 @@ msgid "" "meth:`__anext__` method until it raises a :exc:`StopAsyncIteration` " "exception. Introduced by :pep:`492`." msgstr "" +"Un objeto que implementa los métodos meth:`__aiter__` y :meth:`__anext__`. " +"``__anext__`` debe retornar un objeto :term:`awaitable`. :keyword:`async for` " +"resuelve los esperables retornados por un método de iterador asincrónico :meth:" +"`__anext__` hasta que lanza una excepción :exc:`StopAsyncIteration`. " +"Introducido por :pep:`492`." #: ../Doc/glossary.rst:131 msgid "attribute" -msgstr "" +msgstr "atributo" #: ../Doc/glossary.rst:133 msgid "" @@ -239,132 +322,182 @@ msgid "" "expressions. For example, if an object *o* has an attribute *a* it would be " "referenced as *o.a*." msgstr "" +"Un valor asociado a un objeto que es referencias por el nombre usado " +"expresiones de punto. Por ejemplo, si un objeto *o* tiene un atributo *a* " +"sería referenciado como *o.a*." #: ../Doc/glossary.rst:136 msgid "awaitable" -msgstr "" +msgstr "aguardable" #: ../Doc/glossary.rst:138 msgid "" -"An object that can be used in an :keyword:`await` expression. Can be a :" -"term:`coroutine` or an object with an :meth:`__await__` method. See also :" -"pep:`492`." +"An object that can be used in an :keyword:`await` expression. Can be a :term:" +"`coroutine` or an object with an :meth:`__await__` method. See also :pep:`492`." msgstr "" +"Es un objeto que puede ser usado en una expresión :keyword:`await`. Puede ser " +"una :term:`coroutine` o un objeto con un método :meth:`__await__`. Vea también " +"pep:`492`." #: ../Doc/glossary.rst:141 msgid "BDFL" -msgstr "" +msgstr "BDFL" #: ../Doc/glossary.rst:143 msgid "" "Benevolent Dictator For Life, a.k.a. `Guido van Rossum `_, Python's creator." msgstr "" +"Sigla de Benevolent Dictator For Life, Benevolente dictador vitalicio, es " +"decir `Guido van Rossum `_, el creador de " +"Python." #: ../Doc/glossary.rst:145 msgid "binary file" -msgstr "" +msgstr "archivo binario" #: ../Doc/glossary.rst:147 msgid "" -"A :term:`file object` able to read and write :term:`bytes-like objects " -"`. Examples of binary files are files opened in binary " -"mode (``'rb'``, ``'wb'`` or ``'rb+'``), :data:`sys.stdin.buffer`, :data:`sys." -"stdout.buffer`, and instances of :class:`io.BytesIO` and :class:`gzip." -"GzipFile`." +"A :term:`file object` able to read and write :term:`bytes-like objects `. Examples of binary files are files opened in binary mode " +"(``'rb'``, ``'wb'`` or ``'rb+'``), :data:`sys.stdin.buffer`, :data:`sys.stdout." +"buffer`, and instances of :class:`io.BytesIO` and :class:`gzip.GzipFile`." msgstr "" +"Un :term:`file object` capaz de leer y escribir :term:`objetos tipo binarios " +"`. Ejemplos de archivos binarios son los abiertos en modo " +"binario (``'rb'``, ``'wb'`` o ``'rb+'``), :data:`sys.stdin.buffer`, :data:`sys." +"stdout.buffer`, e instancias de :class:`io.BytesIO` y de :class:`gzip." +"GzipFile`." #: ../Doc/glossary.rst:154 msgid "" "See also :term:`text file` for a file object able to read and write :class:" "`str` objects." msgstr "" +"Vea también :term:`text file` para un objeto archivo capaz de leer y escribir " +"objetos :class:`str`." #: ../Doc/glossary.rst:156 msgid "bytes-like object" -msgstr "" +msgstr "objetos tipo binarios" #: ../Doc/glossary.rst:158 msgid "" "An object that supports the :ref:`bufferobjects` and can export a C-:term:" "`contiguous` buffer. This includes all :class:`bytes`, :class:`bytearray`, " "and :class:`array.array` objects, as well as many common :class:`memoryview` " -"objects. Bytes-like objects can be used for various operations that work " -"with binary data; these include compression, saving to a binary file, and " -"sending over a socket." +"objects. Bytes-like objects can be used for various operations that work with " +"binary data; these include compression, saving to a binary file, and sending " +"over a socket." msgstr "" +"Un objeto que soporta :ref:`bufferobjects` y puede exportar un buffer C-:term:" +"`contiguous`. Esto incluye todas los objetos :class:`bytes`, :class:" +"`bytearray`, y :class:`array.array`, así como muchos objetos comunes :class:" +"`memoryview`. Los objetos tipo binarios pueden ser usados para varias " +"operaciones que usan datos binarios; éstas incluyen compresión, salvar a " +"archivos binarios, y enviarlos a través de un socket." #: ../Doc/glossary.rst:165 msgid "" "Some operations need the binary data to be mutable. The documentation often " -"refers to these as \"read-write bytes-like objects\". Example mutable " -"buffer objects include :class:`bytearray` and a :class:`memoryview` of a :" -"class:`bytearray`. Other operations require the binary data to be stored in " +"refers to these as \"read-write bytes-like objects\". Example mutable buffer " +"objects include :class:`bytearray` and a :class:`memoryview` of a :class:" +"`bytearray`. Other operations require the binary data to be stored in " "immutable objects (\"read-only bytes-like objects\"); examples of these " "include :class:`bytes` and a :class:`memoryview` of a :class:`bytes` object." msgstr "" +"Algunas operaciones necesitan que los datos binarios sean mutables. La " +"documentación frecuentemente se refiere a éstos como \"objetos tipo binario de " +"lectura y escritura\". Ejemplos de objetos de buffer mutables incluyen a :" +"class:`bytearray` y :class:`memoryview` de la :class:`bytearray`. Otras " +"operaciones que requieren datos binarios almacenados en objetos inmutables " +"(\"objetos tipo binario de sólo lectura\"); ejemplos de éstos incluyen :class:" +"`bytes` y :class:`memoryview` del objeto :class:`bytes`." #: ../Doc/glossary.rst:173 msgid "bytecode" -msgstr "" +msgstr "bytecode" #: ../Doc/glossary.rst:175 msgid "" -"Python source code is compiled into bytecode, the internal representation of " -"a Python program in the CPython interpreter. The bytecode is also cached in " -"``.pyc`` files so that executing the same file is faster the second time " +"Python source code is compiled into bytecode, the internal representation of a " +"Python program in the CPython interpreter. The bytecode is also cached in ``." +"pyc`` files so that executing the same file is faster the second time " "(recompilation from source to bytecode can be avoided). This \"intermediate " "language\" is said to run on a :term:`virtual machine` that executes the " "machine code corresponding to each bytecode. Do note that bytecodes are not " "expected to work between different Python virtual machines, nor to be stable " "between Python releases." msgstr "" +"El código fuente Python es compilado en bytecode, la representación interna de " +"un programa python en el intérprete CPython. El bytecode también es guardado " +"en caché en los archivos `.pyc` de tal forma que ejecutar el mismo archivo es " +"más fácil la segunda vez (la recompilación desde el código fuente a bytecode " +"puede ser evitada). Este \"lenguaje intermedio\" deberá corren en una :term:" +"`virtual machine` que ejecute el código de máquina correspondiente a cada " +"bytecode. Note que los bytecodes no tienen como requisito trabajar en las " +"diversas máquina virtuales de Python, ni de ser estable entre versiones Python." #: ../Doc/glossary.rst:185 msgid "" "A list of bytecode instructions can be found in the documentation for :ref:" "`the dis module `." msgstr "" +"Una lista de las instrucciones en bytecode está disponible en la documentación " +"de :ref:`el módulo dis `." #: ../Doc/glossary.rst:187 msgid "class" -msgstr "" +msgstr "clase" #: ../Doc/glossary.rst:189 msgid "" "A template for creating user-defined objects. Class definitions normally " "contain method definitions which operate on instances of the class." msgstr "" +"Una plantilla para crear objetos definidos por el usuario. Las definiciones de " +"clase normalmente contienen definiciones de métodos que operan una instancia " +"de la clase." #: ../Doc/glossary.rst:192 msgid "class variable" -msgstr "" +msgstr "variable de clase" #: ../Doc/glossary.rst:194 msgid "" -"A variable defined in a class and intended to be modified only at class " -"level (i.e., not in an instance of the class)." +"A variable defined in a class and intended to be modified only at class level " +"(i.e., not in an instance of the class)." msgstr "" +"Una variable definida en una clase y prevista para ser modificada sólo a nivel " +"de clase (es decir, no en una instancia de la clase)." #: ../Doc/glossary.rst:196 msgid "coercion" -msgstr "" +msgstr "coerción" #: ../Doc/glossary.rst:198 msgid "" "The implicit conversion of an instance of one type to another during an " "operation which involves two arguments of the same type. For example, " -"``int(3.15)`` converts the floating point number to the integer ``3``, but " -"in ``3+4.5``, each argument is of a different type (one int, one float), and " -"both must be converted to the same type before they can be added or it will " -"raise a :exc:`TypeError`. Without coercion, all arguments of even " -"compatible types would have to be normalized to the same value by the " -"programmer, e.g., ``float(3)+4.5`` rather than just ``3+4.5``." -msgstr "" +"``int(3.15)`` converts the floating point number to the integer ``3``, but in " +"``3+4.5``, each argument is of a different type (one int, one float), and both " +"must be converted to the same type before they can be added or it will raise " +"a :exc:`TypeError`. Without coercion, all arguments of even compatible types " +"would have to be normalized to the same value by the programmer, e.g., " +"``float(3)+4.5`` rather than just ``3+4.5``." +msgstr "" +"La conversión implícita de una instancia de un tipo en otra durante una " +"operación que involucra dos argumentos del mismo tipo. Por ejemplo, " +"``int(3.15)`` convierte el número de punto flotante al entero ``3``, pero en " +"``3 + 4.5``, cada argumento es de un tipo diferente (uno entero, otro " +"flotante), y ambos deben ser convertidos al mismo tipo antes de que puedan ser " +"sumados o emitiría un :exc:`TypeError`. Sin coerción, todos los argumentos, " +"incluso de tipos compatibles, deberían ser normalizados al mismo tipo por el " +"programador, por ejemplo ``float(3)+4.5`` en lugar de ``3+4.5``." #: ../Doc/glossary.rst:206 msgid "complex number" -msgstr "" +msgstr "número complejo" #: ../Doc/glossary.rst:208 msgid "" @@ -372,191 +505,269 @@ msgid "" "expressed as a sum of a real part and an imaginary part. Imaginary numbers " "are real multiples of the imaginary unit (the square root of ``-1``), often " "written ``i`` in mathematics or ``j`` in engineering. Python has built-in " -"support for complex numbers, which are written with this latter notation; " -"the imaginary part is written with a ``j`` suffix, e.g., ``3+1j``. To get " -"access to complex equivalents of the :mod:`math` module, use :mod:`cmath`. " -"Use of complex numbers is a fairly advanced mathematical feature. If you're " -"not aware of a need for them, it's almost certain you can safely ignore them." -msgstr "" +"support for complex numbers, which are written with this latter notation; the " +"imaginary part is written with a ``j`` suffix, e.g., ``3+1j``. To get access " +"to complex equivalents of the :mod:`math` module, use :mod:`cmath`. Use of " +"complex numbers is a fairly advanced mathematical feature. If you're not " +"aware of a need for them, it's almost certain you can safely ignore them." +msgstr "" +"Una extensión del sistema familiar de número reales en el cual los números son " +"expresados como la suma de una parte real y una parte imaginaria. Los números " +"imaginarios son múltiplos de la unidad imaginaria (la raíz cuadrada de " +"``-1``), usualmente escrita como ``i`` en matemáticas o ``j`` en ingeniería. " +"Python tiene soporte incorporado para números complejos, los cuales son " +"escritos con la notación mencionada al final.; la parte imaginaria es escrita " +"con un sufijo ``j``, por ejemplo, ``3+1j``. Para tener acceso a los " +"equivalentes complejos del módulo :mod:`math` module, use :mod:`cmath. El uso " +"de números complejos es matemática bastante avanzada. Si no le parecen " +"necesarios, puede ignorarlos sin inconvenientes." #: ../Doc/glossary.rst:218 msgid "context manager" -msgstr "" +msgstr "administrador de contextos" #: ../Doc/glossary.rst:220 msgid "" "An object which controls the environment seen in a :keyword:`with` statement " "by defining :meth:`__enter__` and :meth:`__exit__` methods. See :pep:`343`." msgstr "" +"Un objeto que controla el entorno en la sentencia :keyword:`with` definiendo :" +"meth:`__enter__` y :meth:`__exit__` methods. Vea :pep:`343`." #: ../Doc/glossary.rst:223 msgid "contiguous" -msgstr "" +msgstr "contiguo" #: ../Doc/glossary.rst:227 msgid "" "A buffer is considered contiguous exactly if it is either *C-contiguous* or " -"*Fortran contiguous*. Zero-dimensional buffers are C and Fortran " -"contiguous. In one-dimensional arrays, the items must be laid out in memory " -"next to each other, in order of increasing indexes starting from zero. In " -"multidimensional C-contiguous arrays, the last index varies the fastest when " -"visiting items in order of memory address. However, in Fortran contiguous " -"arrays, the first index varies the fastest." -msgstr "" +"*Fortran contiguous*. Zero-dimensional buffers are C and Fortran contiguous. " +"In one-dimensional arrays, the items must be laid out in memory next to each " +"other, in order of increasing indexes starting from zero. In multidimensional " +"C-contiguous arrays, the last index varies the fastest when visiting items in " +"order of memory address. However, in Fortran contiguous arrays, the first " +"index varies the fastest." +msgstr "" +"Un buffer es considerado contiguo con precisión si es *C-contíguo* o *Fortran " +"contiguo*. Los buffers cero dimensionales con C y Fortran contiguos. En los " +"arreglos unidimensionales, los ítems deben ser dispuestos en memoria uno " +"siguiente al otro, ordenados por índices que comienzan en cero. En arreglos " +"unidimensionales C-contíguos, el último índice varía más velozmente en el " +"orden de las direcciones de memoria. Sin embargo, en arreglos Fortran " +"contiguos, el primer índice vería más rápidamente." #: ../Doc/glossary.rst:235 msgid "coroutine" -msgstr "" +msgstr "corrutina" #: ../Doc/glossary.rst:237 msgid "" -"Coroutines is a more generalized form of subroutines. Subroutines are " -"entered at one point and exited at another point. Coroutines can be " -"entered, exited, and resumed at many different points. They can be " -"implemented with the :keyword:`async def` statement. See also :pep:`492`." +"Coroutines is a more generalized form of subroutines. Subroutines are entered " +"at one point and exited at another point. Coroutines can be entered, exited, " +"and resumed at many different points. They can be implemented with the :" +"keyword:`async def` statement. See also :pep:`492`." msgstr "" +"Las corrutinas son una forma más generalizadas de las subrutinas. A las " +"subrutinas se ingresa por un punto y se sale por otro punto. Las corrutinas " +"pueden se iniciadas, finalizadas y reanudadas en muchos puntos diferentes. " +"Pueden ser implementadas con la sentencia :keyword:`async def`. Vea además :" +"pep:`492`." #: ../Doc/glossary.rst:242 msgid "coroutine function" -msgstr "" +msgstr "función corrutina" #: ../Doc/glossary.rst:244 msgid "" -"A function which returns a :term:`coroutine` object. A coroutine function " -"may be defined with the :keyword:`async def` statement, and may contain :" -"keyword:`await`, :keyword:`async for`, and :keyword:`async with` keywords. " -"These were introduced by :pep:`492`." +"A function which returns a :term:`coroutine` object. A coroutine function may " +"be defined with the :keyword:`async def` statement, and may contain :keyword:" +"`await`, :keyword:`async for`, and :keyword:`async with` keywords. These were " +"introduced by :pep:`492`." msgstr "" +"Un función que retorna un objeto :term:`coroutine` . Una función corrutina " +"puede ser definida con la sentencia :keyword:`async def`, y puede contener las " +"palabras claves :keyword:`await`, :keyword:`async for`, y :keyword:`async " +"with`. Las mismas son introducidas en :pep:`492`." #: ../Doc/glossary.rst:249 msgid "CPython" -msgstr "" +msgstr "CPython" #: ../Doc/glossary.rst:251 msgid "" "The canonical implementation of the Python programming language, as " "distributed on `python.org `_. The term \"CPython\" " -"is used when necessary to distinguish this implementation from others such " -"as Jython or IronPython." +"is used when necessary to distinguish this implementation from others such as " +"Jython or IronPython." msgstr "" +"La implementación canónica del lenguaje de programación Python, como se " +"distribuye en `python.org `_. El término \"CPython\" " +"es usado cuando es necesario distinguir esta implementación de otras como " +"Jython o IronPython." #: ../Doc/glossary.rst:255 msgid "decorator" -msgstr "" +msgstr "decorador" #: ../Doc/glossary.rst:257 msgid "" "A function returning another function, usually applied as a function " -"transformation using the ``@wrapper`` syntax. Common examples for " -"decorators are :func:`classmethod` and :func:`staticmethod`." +"transformation using the ``@wrapper`` syntax. Common examples for decorators " +"are :func:`classmethod` and :func:`staticmethod`." msgstr "" +"Una función que retorna otra función, usualmente aplicada como una función de " +"transformación empleando la sintaxis ``@envoltorio``. Ejemplos comunes de " +"decoradores son :func:`classmethod` y func:`staticmethod`." #: ../Doc/glossary.rst:261 msgid "" "The decorator syntax is merely syntactic sugar, the following two function " "definitions are semantically equivalent::" msgstr "" +"La sintaxis del decorador es meramente azúcar sintáctico, las definiciones de " +"las siguientes dos funciones son semánticamente equivalentes::" #: ../Doc/glossary.rst:272 msgid "" -"The same concept exists for classes, but is less commonly used there. See " -"the documentation for :ref:`function definitions ` and :ref:`class " +"The same concept exists for classes, but is less commonly used there. See the " +"documentation for :ref:`function definitions ` and :ref:`class " "definitions ` for more about decorators." msgstr "" +"El mismo concepto existe para clases, pero son menos usadas. Vea la " +"documentación de :ref:`function definitions ` y :ref:`class " +"definitions ` para mayor detalle sobre decoradores." #: ../Doc/glossary.rst:275 msgid "descriptor" -msgstr "" +msgstr "descriptor" #: ../Doc/glossary.rst:277 msgid "" "Any object which defines the methods :meth:`__get__`, :meth:`__set__`, or :" "meth:`__delete__`. When a class attribute is a descriptor, its special " -"binding behavior is triggered upon attribute lookup. Normally, using *a.b* " -"to get, set or delete an attribute looks up the object named *b* in the " -"class dictionary for *a*, but if *b* is a descriptor, the respective " -"descriptor method gets called. Understanding descriptors is a key to a deep " -"understanding of Python because they are the basis for many features " -"including functions, methods, properties, class methods, static methods, and " -"reference to super classes." -msgstr "" +"binding behavior is triggered upon attribute lookup. Normally, using *a.b* to " +"get, set or delete an attribute looks up the object named *b* in the class " +"dictionary for *a*, but if *b* is a descriptor, the respective descriptor " +"method gets called. Understanding descriptors is a key to a deep " +"understanding of Python because they are the basis for many features including " +"functions, methods, properties, class methods, static methods, and reference " +"to super classes." +msgstr "" +"Cualquier objeto que define los métodos :meth:`__get__`, :meth:`__set__`, o :" +"meth:`__delete__`. Cuando un atributo de clase es un descriptor, su conducta " +"enlazada especial es disparada durante la búsqueda del atributo. Normalmente, " +"usando *a.b* para consultar, establecer o borrar un atributo busca el objeto " +"llamado *b* en el diccionario de clase de *a*, pero si *b* es un descriptor, " +"el respectivo método descriptor es llamado. Entender descriptores es clave " +"para lograr una comprensión profunda de Python porque son la base de muchas de " +"las capacidades incluyendo funciones, métodos, propiedades, métodos de clase, " +"métodos estáticos, y referencia a súper clases." #: ../Doc/glossary.rst:287 -msgid "" -"For more information about descriptors' methods, see :ref:`descriptors`." -msgstr "" +msgid "For more information about descriptors' methods, see :ref:`descriptors`." +msgstr "Para más información sobre métodos descriptores, vea :ref:`descriptors`." #: ../Doc/glossary.rst:288 msgid "dictionary" -msgstr "" +msgstr "diccionario" #: ../Doc/glossary.rst:290 msgid "" -"An associative array, where arbitrary keys are mapped to values. The keys " -"can be any object with :meth:`__hash__` and :meth:`__eq__` methods. Called a " -"hash in Perl." +"An associative array, where arbitrary keys are mapped to values. The keys can " +"be any object with :meth:`__hash__` and :meth:`__eq__` methods. Called a hash " +"in Perl." msgstr "" +"Un arreglo asociativo, con claves arbitrarias que son asociadas a valores. Las " +"claves pueden ser cualquier objeto con los métodos :meth:`__hash__` y :meth:" +"`__eq__` . Son llamadas hash en Perl." #: ../Doc/glossary.rst:293 msgid "dictionary view" -msgstr "" +msgstr "vista de diccionario" #: ../Doc/glossary.rst:295 msgid "" "The objects returned from :meth:`dict.keys`, :meth:`dict.values`, and :meth:" "`dict.items` are called dictionary views. They provide a dynamic view on the " "dictionary’s entries, which means that when the dictionary changes, the view " -"reflects these changes. To force the dictionary view to become a full list " -"use ``list(dictview)``. See :ref:`dict-views`." +"reflects these changes. To force the dictionary view to become a full list use " +"``list(dictview)``. See :ref:`dict-views`." msgstr "" +"Los objetos retornados por los métodos :meth:`dict.keys`, :meth:`dict." +"values`, y :meth:`dict.items` son llamados vistas de diccionarios. Proveen una " +"vista dinámica de las entradas de un diccionario, lo que significa que cuando " +"el diccionario cambia, la vista refleja éstos cambios. Para forzar a la vista " +"de diccionario a convertirse en una lista completa, use ``list(dictview)``. " +"Vea :ref:`dict-views`." #: ../Doc/glossary.rst:301 msgid "docstring" -msgstr "" +msgstr "docstring" #: ../Doc/glossary.rst:303 msgid "" -"A string literal which appears as the first expression in a class, function " -"or module. While ignored when the suite is executed, it is recognized by " -"the compiler and put into the :attr:`__doc__` attribute of the enclosing " -"class, function or module. Since it is available via introspection, it is " -"the canonical place for documentation of the object." +"A string literal which appears as the first expression in a class, function or " +"module. While ignored when the suite is executed, it is recognized by the " +"compiler and put into the :attr:`__doc__` attribute of the enclosing class, " +"function or module. Since it is available via introspection, it is the " +"canonical place for documentation of the object." msgstr "" +"Una cadena de caracteres literal que aparece como la primera expresión en una " +"clase, función o módulo. Aunque es ignorada cuando se ejecuta, es reconocida " +"por el compilador y puesta en el atributo :attr:`__doc__` de la clase, función " +"o módulo comprendida. Como está disponible mediante introspección, es el " +"lugar canónico para ubicar la documentación del objeto." #: ../Doc/glossary.rst:309 msgid "duck-typing" -msgstr "" +msgstr "tipado de pato" #: ../Doc/glossary.rst:311 msgid "" -"A programming style which does not look at an object's type to determine if " -"it has the right interface; instead, the method or attribute is simply " -"called or used (\"If it looks like a duck and quacks like a duck, it must be " -"a duck.\") By emphasizing interfaces rather than specific types, well-" -"designed code improves its flexibility by allowing polymorphic " -"substitution. Duck-typing avoids tests using :func:`type` or :func:" -"`isinstance`. (Note, however, that duck-typing can be complemented with :" -"term:`abstract base classes `.) Instead, it typically " -"employs :func:`hasattr` tests or :term:`EAFP` programming." -msgstr "" +"A programming style which does not look at an object's type to determine if it " +"has the right interface; instead, the method or attribute is simply called or " +"used (\"If it looks like a duck and quacks like a duck, it must be a duck.\") " +"By emphasizing interfaces rather than specific types, well-designed code " +"improves its flexibility by allowing polymorphic substitution. Duck-typing " +"avoids tests using :func:`type` or :func:`isinstance`. (Note, however, that " +"duck-typing can be complemented with :term:`abstract base classes `.) Instead, it typically employs :func:`hasattr` tests or :term:" +"`EAFP` programming." +msgstr "" +"Un estilo de programación que no revisa el tipo del objeto para determinar si " +"tiene la interfaz correcta; en vez de ello, el método o atributo es " +"simplemente llamado o usado (\"Si se ve como un pato y grazna como un pato, " +"debe ser un pato\"). Enfatizando las interfaces en vez de hacerlo con los " +"tipos específicos, un código bien diseñado pues tener mayor flexibilidad " +"permitiendo la sustitución polimórfica. El tipado de pato *duck-typing* evita " +"usar pruebas llamando a :func:`type` o :func:`isinstance`. (Nota: si embargo, " +"el tipado de pato puede ser complementado con :term:`abstract base classes " +"`. En su lugar, generalmente emplea :func:`hasattr` tests " +"o :term:`EAFP`." #: ../Doc/glossary.rst:320 msgid "EAFP" -msgstr "" +msgstr "EAFP" #: ../Doc/glossary.rst:322 msgid "" "Easier to ask for forgiveness than permission. This common Python coding " -"style assumes the existence of valid keys or attributes and catches " -"exceptions if the assumption proves false. This clean and fast style is " -"characterized by the presence of many :keyword:`try` and :keyword:`except` " -"statements. The technique contrasts with the :term:`LBYL` style common to " -"many other languages such as C." -msgstr "" +"style assumes the existence of valid keys or attributes and catches exceptions " +"if the assumption proves false. This clean and fast style is characterized by " +"the presence of many :keyword:`try` and :keyword:`except` statements. The " +"technique contrasts with the :term:`LBYL` style common to many other languages " +"such as C." +msgstr "" +"Del inglés \"Easier to ask for forgiveness than permission\", es más fácil " +"pedir perdón que pedir permiso. Este estilo de codificación común en Python " +"asume la existencia de claves o atributos válidos y atrapa las excepciones si " +"esta suposición resulta falsa. Este estilo rápido y limpio está caracterizado " +"por muchas sentencias :keyword:`try` y :keyword:`except`. Esta técnica " +"contrasta con estilo :term:`LBYL` usual en otros lenguajes como C." #: ../Doc/glossary.rst:328 msgid "expression" -msgstr "" +msgstr "expresión" #: ../Doc/glossary.rst:330 msgid "" @@ -568,20 +779,29 @@ msgid "" "expressions, such as :keyword:`while`. Assignments are also statements, not " "expressions." msgstr "" +"Una construcción sintáctica que puede ser evaluada, hasta dar un valor. En " +"otras palabras, una expresión es una acumulación de elementos de expresión " +"tales como literales, nombres, accesos a atributos, operadores o llamadas a " +"funciones, todos ellos retornando valor. A diferencia de otros lenguajes, no " +"toda la sintaxis del lenguaje son expresiones. También hay :term:`statement`" +"\\s que no pueden ser usadas como expresiones, como la :keyword:`while`. Las " +"asignaciones también son sentencias, no expresiones." #: ../Doc/glossary.rst:337 msgid "extension module" -msgstr "" +msgstr "módulo de extensión" #: ../Doc/glossary.rst:339 msgid "" "A module written in C or C++, using Python's C API to interact with the core " "and with user code." msgstr "" +"Un módulo escrito en C o C++, usando la API para C de Python para interactuar " +"con el núcleo y el código del usuario." #: ../Doc/glossary.rst:341 msgid "f-string" -msgstr "" +msgstr "f-string" #: ../Doc/glossary.rst:343 msgid "" @@ -589,75 +809,100 @@ msgid "" "strings\" which is short for :ref:`formatted string literals `. " "See also :pep:`498`." msgstr "" +"Son llamadas \"f-strings\" las cadenas literales que usan el prefijo ``'f'`` o " +"``'F'``, que es una abreviatura para :ref:`cadenas literales formateadas `. Vea también :pep:`498`." #: ../Doc/glossary.rst:346 msgid "file object" -msgstr "" +msgstr "objeto archivo" #: ../Doc/glossary.rst:348 msgid "" "An object exposing a file-oriented API (with methods such as :meth:`read()` " "or :meth:`write()`) to an underlying resource. Depending on the way it was " -"created, a file object can mediate access to a real on-disk file or to " -"another type of storage or communication device (for example standard input/" -"output, in-memory buffers, sockets, pipes, etc.). File objects are also " -"called :dfn:`file-like objects` or :dfn:`streams`." -msgstr "" +"created, a file object can mediate access to a real on-disk file or to another " +"type of storage or communication device (for example standard input/output, in-" +"memory buffers, sockets, pipes, etc.). File objects are also called :dfn:" +"`file-like objects` or :dfn:`streams`." +msgstr "" +"Un objeto que expone una API orientada a archivos (con métodos como :meth:" +"`read()` o :meth:`write()`) al objeto subyacente. Dependiendo de la forma en " +"la que fue creado, un objeto archivo, puede mediar el acceso a un archivo real " +"en el disco u otro tipo de dispositivo de almacenamiento o de comunicación " +"(por ejemplo, entrada/salida estándar, buffer de memoria, sockets, pipes, " +"etc.). Los objetos archivo son también denominados :dfn:`objetos tipo " +"archivo` o :dfn:`flujos`." #: ../Doc/glossary.rst:356 msgid "" "There are actually three categories of file objects: raw :term:`binary files " "`, buffered :term:`binary files ` and :term:`text " -"files `. Their interfaces are defined in the :mod:`io` module. " -"The canonical way to create a file object is by using the :func:`open` " -"function." +"files `. Their interfaces are defined in the :mod:`io` module. The " +"canonical way to create a file object is by using the :func:`open` function." msgstr "" +"Existen tres categorías de objetos archivo: crudos *raw* :term:`archivos " +"binarios `, con buffer :term:`archivos binarios ` y :" +"term:`archivos de texto `. Sus interfaces son definidas en el " +"módulo :mod:`io`. La forma canónica de crear objetos archivo es usando la " +"función :func:`open`." #: ../Doc/glossary.rst:361 msgid "file-like object" -msgstr "" +msgstr "objetos tipo archivo" #: ../Doc/glossary.rst:363 msgid "A synonym for :term:`file object`." -msgstr "" +msgstr "Un sinónimo de :term:`file object`." #: ../Doc/glossary.rst:364 msgid "finder" -msgstr "" +msgstr "buscador" #: ../Doc/glossary.rst:366 msgid "" "An object that tries to find the :term:`loader` for a module that is being " "imported." msgstr "" +"Un objeto que trata de encontrar el :term:`loader` para el módulo que está " +"siendo importado." #: ../Doc/glossary.rst:369 msgid "" "Since Python 3.3, there are two types of finder: :term:`meta path finders " -"` for use with :data:`sys.meta_path`, and :term:`path " -"entry finders ` for use with :data:`sys.path_hooks`." +"` for use with :data:`sys.meta_path`, and :term:`path entry " +"finders ` for use with :data:`sys.path_hooks`." msgstr "" +"Desde la versión 3.3 de Python, existen dos tipos de buscadores: :term:`meta " +"buscadores de ruta ` para usar con :data:`sys.meta_path`, y :" +"term:`buscadores de entradas de rutas ` para usar con :" +"data:`sys.path_hooks`." #: ../Doc/glossary.rst:373 msgid "See :pep:`302`, :pep:`420` and :pep:`451` for much more detail." -msgstr "" +msgstr "Vea :pep:`302`, :pep:`420` y :pep:`451` para mayores detalles." #: ../Doc/glossary.rst:374 msgid "floor division" -msgstr "" +msgstr "división entera" #: ../Doc/glossary.rst:376 msgid "" -"Mathematical division that rounds down to nearest integer. The floor " -"division operator is ``//``. For example, the expression ``11 // 4`` " -"evaluates to ``2`` in contrast to the ``2.75`` returned by float true " -"division. Note that ``(-11) // 4`` is ``-3`` because that is ``-2.75`` " -"rounded *downward*. See :pep:`238`." +"Mathematical division that rounds down to nearest integer. The floor division " +"operator is ``//``. For example, the expression ``11 // 4`` evaluates to " +"``2`` in contrast to the ``2.75`` returned by float true division. Note that " +"``(-11) // 4`` is ``-3`` because that is ``-2.75`` rounded *downward*. See :" +"pep:`238`." msgstr "" +"Una división matemática que se redondea hacia el entero menor más cercano. El " +"operador de la división entera es ``//``. Por ejemplo, la expresión ``11 // " +"4`` evalúa ``2`` a diferencia del ``2.75`` retornado por la verdadera división " +"de números flotantes. Note que ``(-11) // 4`` es ``-3`` porque es ``-2.75`` " +"redondeado *para abajo*. Ver :pep:`238`." #: ../Doc/glossary.rst:381 msgid "function" -msgstr "" +msgstr "función" #: ../Doc/glossary.rst:383 msgid "" @@ -666,275 +911,366 @@ msgid "" "execution of the body. See also :term:`parameter`, :term:`method`, and the :" "ref:`function` section." msgstr "" +"Una serie de sentencias que retornan un valor al que las llama. También se le " +"puede pasar cero o más :term:`argumentos ` los cuales pueden ser " +"usados en la ejecución de la misma. Vea también :term:`parameter`, :term:" +"`method`, y la sección :ref:`function`." #: ../Doc/glossary.rst:387 msgid "function annotation" -msgstr "" +msgstr "anotación de función" #: ../Doc/glossary.rst:389 msgid "An :term:`annotation` of a function parameter or return value." msgstr "" +"Una :term:`annotation` del parámetro de una función o un valor de retorno." #: ../Doc/glossary.rst:391 msgid "" -"Function annotations are usually used for :term:`type hints `: " -"for example, this function is expected to take two :class:`int` arguments " -"and is also expected to have an :class:`int` return value::" +"Function annotations are usually used for :term:`type hints `: for " +"example, this function is expected to take two :class:`int` arguments and is " +"also expected to have an :class:`int` return value::" msgstr "" +"Las anotaciones de funciones son usadas frecuentemente para :term:`type " +"hint`s , por ejemplo, se espera que una función tome dos argumentos de clase :" +"class:`int` y también se espera que devuelva dos valores :class:`int`::" #: ../Doc/glossary.rst:399 msgid "Function annotation syntax is explained in section :ref:`function`." msgstr "" +"La sintaxis de las anotaciones de funciones son explicadas en la sección :ref:" +"`function`." #: ../Doc/glossary.rst:401 msgid "" "See :term:`variable annotation` and :pep:`484`, which describe this " "functionality." msgstr "" +"Vea :term:`variable annotation` y :pep:`484`, que describen esta funcionalidad." #: ../Doc/glossary.rst:403 msgid "__future__" -msgstr "" +msgstr "__future__" #: ../Doc/glossary.rst:405 msgid "" "A pseudo-module which programmers can use to enable new language features " "which are not compatible with the current interpreter." msgstr "" +"Un pseudo-módulo que los programadores pueden usar para habilitar nuevas " +"capacidades del lenguaje que no son compatibles con el intérprete actual." #: ../Doc/glossary.rst:408 msgid "" "By importing the :mod:`__future__` module and evaluating its variables, you " -"can see when a new feature was first added to the language and when it " -"becomes the default::" +"can see when a new feature was first added to the language and when it becomes " +"the default::" msgstr "" +"Al importar el módulo :mod:`__future__` y evaluar sus variables, puede verse " +"cuándo las nuevas capacidades fueron agregadas por primera vez al lenguaje y " +"cuando se quedaron establecidas por defecto::" #: ../Doc/glossary.rst:415 msgid "garbage collection" -msgstr "" +msgstr "recolección de basura" #: ../Doc/glossary.rst:417 msgid "" "The process of freeing memory when it is not used anymore. Python performs " -"garbage collection via reference counting and a cyclic garbage collector " -"that is able to detect and break reference cycles. The garbage collector " -"can be controlled using the :mod:`gc` module." +"garbage collection via reference counting and a cyclic garbage collector that " +"is able to detect and break reference cycles. The garbage collector can be " +"controlled using the :mod:`gc` module." msgstr "" +"El proceso de liberar la memoria de lo que ya no está en uso. Python realiza " +"recolección de basura (*garbage collection*) llevando la cuenta de las " +"referencias, y el recogedor de basura cíclico es capaz de detectar y romper " +"las referencias cíclicas. El recogedor de basura puede ser controlado " +"mediante el módulo :mod:`gc` ." #: ../Doc/glossary.rst:423 msgid "generator" -msgstr "" +msgstr "generador" #: ../Doc/glossary.rst:425 msgid "" -"A function which returns a :term:`generator iterator`. It looks like a " -"normal function except that it contains :keyword:`yield` expressions for " -"producing a series of values usable in a for-loop or that can be retrieved " -"one at a time with the :func:`next` function." +"A function which returns a :term:`generator iterator`. It looks like a normal " +"function except that it contains :keyword:`yield` expressions for producing a " +"series of values usable in a for-loop or that can be retrieved one at a time " +"with the :func:`next` function." msgstr "" +"Una función que retorna un :term:`generator iterator`. Luce como una función " +"normal excepto que contiene la expresión :keyword:`yield` para producir series " +"de valores utilizables en un bucle for o que pueden ser obtenidas una por una " +"con la función :func:`next`." #: ../Doc/glossary.rst:430 msgid "" "Usually refers to a generator function, but may refer to a *generator " -"iterator* in some contexts. In cases where the intended meaning isn't " -"clear, using the full terms avoids ambiguity." +"iterator* in some contexts. In cases where the intended meaning isn't clear, " +"using the full terms avoids ambiguity." msgstr "" +"Usualmente se refiere a una función generadora, pero puede referirse a un " +"*iterador generador* en ciertos contextos. En aquellos casos en los que el " +"significado no está claro, usar los términos completos evita la ambigüedad." #: ../Doc/glossary.rst:433 msgid "generator iterator" -msgstr "" +msgstr "iterador generador" #: ../Doc/glossary.rst:435 msgid "An object created by a :term:`generator` function." -msgstr "" +msgstr "Un objeto creado por una función :term:`generator`." #: ../Doc/glossary.rst:437 msgid "" "Each :keyword:`yield` temporarily suspends processing, remembering the " "location execution state (including local variables and pending try-" -"statements). When the *generator iterator* resumes, it picks up where it " -"left off (in contrast to functions which start fresh on every invocation)." +"statements). When the *generator iterator* resumes, it picks up where it left " +"off (in contrast to functions which start fresh on every invocation)." msgstr "" +"Cada :keyword:`yield` suspende temporalmente el procesamiento, recordando el " +"estado de ejecución local (incluyendo las variables locales y las sentencias " +"try pendientes). Cuando el \"iterador generado\" vuelve, retoma donde ha " +"dejado, a diferencia de lo que ocurre con las funciones que comienzan " +"nuevamente con cada invocación." #: ../Doc/glossary.rst:444 msgid "generator expression" -msgstr "" +msgstr "expresión generadora" #: ../Doc/glossary.rst:446 msgid "" "An expression that returns an iterator. It looks like a normal expression " "followed by a :keyword:`!for` clause defining a loop variable, range, and an " -"optional :keyword:`!if` clause. The combined expression generates values " -"for an enclosing function::" +"optional :keyword:`!if` clause. The combined expression generates values for " +"an enclosing function::" msgstr "" +"Una expresión que retorna un iterador. Luce como una expresión normal seguida " +"por la cláusula :keyword:`!for` definiendo así una variable de bucle, un rango " +"y una cláusula opcional :keyword:`!if`. La expresión combinada genera valores " +"para la función contenedora::" #: ../Doc/glossary.rst:453 msgid "generic function" -msgstr "" +msgstr "función genérica" #: ../Doc/glossary.rst:455 msgid "" -"A function composed of multiple functions implementing the same operation " -"for different types. Which implementation should be used during a call is " +"A function composed of multiple functions implementing the same operation for " +"different types. Which implementation should be used during a call is " "determined by the dispatch algorithm." msgstr "" +"Una función compuesta de muchas funciones que implementan la misma operación " +"para diferentes tipos. Qué implementación deberá ser usada durante la llamada " +"a la misma es determinado por el algoritmo de despacho." #: ../Doc/glossary.rst:459 msgid "" "See also the :term:`single dispatch` glossary entry, the :func:`functools." "singledispatch` decorator, and :pep:`443`." msgstr "" +"Vea también la entrada de glosario :term:`single dispatch`, el decorador :func:" +"`functools.singledispatch`, y :pep:`443`." #: ../Doc/glossary.rst:462 msgid "GIL" -msgstr "" +msgstr "GIL" #: ../Doc/glossary.rst:464 msgid "See :term:`global interpreter lock`." -msgstr "" +msgstr "Vea :term:`global interpreter lock`." #: ../Doc/glossary.rst:465 msgid "global interpreter lock" -msgstr "" +msgstr "bloqueo global del intérprete" #: ../Doc/glossary.rst:467 msgid "" -"The mechanism used by the :term:`CPython` interpreter to assure that only " -"one thread executes Python :term:`bytecode` at a time. This simplifies the " -"CPython implementation by making the object model (including critical built-" -"in types such as :class:`dict`) implicitly safe against concurrent access. " -"Locking the entire interpreter makes it easier for the interpreter to be " -"multi-threaded, at the expense of much of the parallelism afforded by multi-" -"processor machines." -msgstr "" +"The mechanism used by the :term:`CPython` interpreter to assure that only one " +"thread executes Python :term:`bytecode` at a time. This simplifies the CPython " +"implementation by making the object model (including critical built-in types " +"such as :class:`dict`) implicitly safe against concurrent access. Locking the " +"entire interpreter makes it easier for the interpreter to be multi-threaded, " +"at the expense of much of the parallelism afforded by multi-processor machines." +msgstr "" +"Mecanismo empleado por el intérprete :term:`CPython` para asegurar que sólo un " +"hilo ejecute el :term:`bytecode` Python por vez. Esto simplifica la " +"implementación de CPython haciendo que el modelo de objetos (incluyendo " +"algunos críticos como :class:`dict`) están implícitamente a salvo de acceso " +"concurrente. Bloqueando el intérprete completo se simplifica hacerlo multi-" +"hilos, a costa de mucho del paralelismo ofrecido por las máquinas con " +"múltiples procesadores." #: ../Doc/glossary.rst:476 msgid "" -"However, some extension modules, either standard or third-party, are " -"designed so as to release the GIL when doing computationally-intensive tasks " -"such as compression or hashing. Also, the GIL is always released when doing " -"I/O." +"However, some extension modules, either standard or third-party, are designed " +"so as to release the GIL when doing computationally-intensive tasks such as " +"compression or hashing. Also, the GIL is always released when doing I/O." msgstr "" +"Sin embargo, algunos módulos de extensión, tanto estándar como de terceros, " +"están diseñados para liberar el GIL cuando se realizan tareas " +"computacionalmente intensivas como la compresión o el hashing. Además, el GIL " +"siempre es liberado cuando se hace entrada/salida." #: ../Doc/glossary.rst:481 msgid "" -"Past efforts to create a \"free-threaded\" interpreter (one which locks " -"shared data at a much finer granularity) have not been successful because " -"performance suffered in the common single-processor case. It is believed " -"that overcoming this performance issue would make the implementation much " -"more complicated and therefore costlier to maintain." +"Past efforts to create a \"free-threaded\" interpreter (one which locks shared " +"data at a much finer granularity) have not been successful because performance " +"suffered in the common single-processor case. It is believed that overcoming " +"this performance issue would make the implementation much more complicated and " +"therefore costlier to maintain." msgstr "" +"Esfuerzos previos hechos para crear un intérprete \"sin hilos\" (uno que " +"bloquee los datos compartidos con una granularidad mucho más fina) no han sido " +"exitosos debido a que el rendimiento sufrió para el caso más común de un solo " +"procesador. Se cree que superar este problema de rendimiento haría la " +"implementación mucho más compleja y por tanto, más costosa de mantener." #: ../Doc/glossary.rst:487 msgid "hash-based pyc" -msgstr "" +msgstr "hash-based pyc" #: ../Doc/glossary.rst:489 msgid "" -"A bytecode cache file that uses the hash rather than the last-modified time " -"of the corresponding source file to determine its validity. See :ref:`pyc-" +"A bytecode cache file that uses the hash rather than the last-modified time of " +"the corresponding source file to determine its validity. See :ref:`pyc-" "invalidation`." msgstr "" +"Un archivo cache de bytecode que usa el hash en vez de usar el tiempo de la " +"última modificación del archivo fuente correspondiente para determinar su " +"validez. Vea :ref:`pyc-invalidation`." #: ../Doc/glossary.rst:492 msgid "hashable" -msgstr "" +msgstr "hashable" #: ../Doc/glossary.rst:494 msgid "" -"An object is *hashable* if it has a hash value which never changes during " -"its lifetime (it needs a :meth:`__hash__` method), and can be compared to " -"other objects (it needs an :meth:`__eq__` method). Hashable objects which " -"compare equal must have the same hash value." +"An object is *hashable* if it has a hash value which never changes during its " +"lifetime (it needs a :meth:`__hash__` method), and can be compared to other " +"objects (it needs an :meth:`__eq__` method). Hashable objects which compare " +"equal must have the same hash value." msgstr "" +"Un objeto es *hashable* si tiene un valor de hash que nunca cambiará durante " +"su tiempo de vida (necesita un método :meth:`__hash__` ), y puede ser " +"comparado con otro objeto (necesita el método :meth:`__eq__` ). Los objetos " +"hashables que se comparan iguales deben tener el mismo número hash." #: ../Doc/glossary.rst:499 msgid "" "Hashability makes an object usable as a dictionary key and a set member, " "because these data structures use the hash value internally." msgstr "" +"La hashabilidad hace a un objeto empleable como clave de un diccionario y " +"miembro de un set, porque éstas estructuras de datos usan los valores de hash " +"internamente." #: ../Doc/glossary.rst:502 msgid "" "All of Python's immutable built-in objects are hashable; mutable containers " -"(such as lists or dictionaries) are not. Objects which are instances of " -"user-defined classes are hashable by default. They all compare unequal " -"(except with themselves), and their hash value is derived from their :func:" -"`id`." +"(such as lists or dictionaries) are not. Objects which are instances of user-" +"defined classes are hashable by default. They all compare unequal (except " +"with themselves), and their hash value is derived from their :func:`id`." msgstr "" +"Todos los objetos inmutables incorporados en Python son hashables; los " +"contenedores mutables (como las listas o los diccionarios) no lo son. Los " +"objetos que son instancias de clases definidas por el usuario son hashables " +"por defecto. Todos se comparan como desiguales (excepto consigo mismos), y su " +"valor de hash está derivado de su función :func:`id`." #: ../Doc/glossary.rst:507 msgid "IDLE" -msgstr "" +msgstr "IDLE" #: ../Doc/glossary.rst:509 msgid "" -"An Integrated Development Environment for Python. IDLE is a basic editor " -"and interpreter environment which ships with the standard distribution of " -"Python." +"An Integrated Development Environment for Python. IDLE is a basic editor and " +"interpreter environment which ships with the standard distribution of Python." msgstr "" +"El entorno integrado de desarrollo de Python, o \"Integrated Development " +"Environment for Python\". IDLE es un editor básico y un entorno de intérprete " +"que se incluye con la distribución estándar de Python." #: ../Doc/glossary.rst:512 msgid "immutable" -msgstr "" +msgstr "inmutable" #: ../Doc/glossary.rst:514 msgid "" -"An object with a fixed value. Immutable objects include numbers, strings " -"and tuples. Such an object cannot be altered. A new object has to be " -"created if a different value has to be stored. They play an important role " -"in places where a constant hash value is needed, for example as a key in a " -"dictionary." +"An object with a fixed value. Immutable objects include numbers, strings and " +"tuples. Such an object cannot be altered. A new object has to be created if " +"a different value has to be stored. They play an important role in places " +"where a constant hash value is needed, for example as a key in a dictionary." msgstr "" +"Un objeto con un valor fijo. Los objetos inmutables son números, cadenas y " +"tuplas. Éstos objetos no pueden ser alterados. Un nuevo objeto debe ser " +"creado si un valor diferente ha de ser guardado. Juegan un rol importante en " +"lugares donde es necesario un valor de hash constante, por ejemplo como claves " +"de un diccionario." #: ../Doc/glossary.rst:519 msgid "import path" -msgstr "" +msgstr "ruta de importación" #: ../Doc/glossary.rst:521 msgid "" "A list of locations (or :term:`path entries `) that are searched " "by the :term:`path based finder` for modules to import. During import, this " -"list of locations usually comes from :data:`sys.path`, but for subpackages " -"it may also come from the parent package's ``__path__`` attribute." +"list of locations usually comes from :data:`sys.path`, but for subpackages it " +"may also come from the parent package's ``__path__`` attribute." msgstr "" +"Una lista de las ubicaciones (o :term:`entradas de ruta `) que son " +"revisadas por :term:`path based finder` al importar módulos. Durante la " +"importación, ésta lista de localizaciones usualmente viene de :data:`sys." +"path`, pero para los subpaquetes también puede incluir al atributo " +"``__path__`` del paquete padre." #: ../Doc/glossary.rst:526 msgid "importing" -msgstr "" +msgstr "importar" #: ../Doc/glossary.rst:528 msgid "" "The process by which Python code in one module is made available to Python " "code in another module." msgstr "" +"El proceso mediante el cual el código Python dentro de un módulo se hace " +"alcanzable desde otro código Python en otro módulo." #: ../Doc/glossary.rst:530 msgid "importer" -msgstr "" +msgstr "importador" #: ../Doc/glossary.rst:532 msgid "" -"An object that both finds and loads a module; both a :term:`finder` and :" -"term:`loader` object." +"An object that both finds and loads a module; both a :term:`finder` and :term:" +"`loader` object." msgstr "" +"Un objeto que buscan y lee un módulo; un objeto que es tanto :term:`finder` " +"como :term:`loader`." #: ../Doc/glossary.rst:534 msgid "interactive" -msgstr "" +msgstr "interactivo" #: ../Doc/glossary.rst:536 msgid "" -"Python has an interactive interpreter which means you can enter statements " -"and expressions at the interpreter prompt, immediately execute them and see " -"their results. Just launch ``python`` with no arguments (possibly by " -"selecting it from your computer's main menu). It is a very powerful way to " -"test out new ideas or inspect modules and packages (remember ``help(x)``)." +"Python has an interactive interpreter which means you can enter statements and " +"expressions at the interpreter prompt, immediately execute them and see their " +"results. Just launch ``python`` with no arguments (possibly by selecting it " +"from your computer's main menu). It is a very powerful way to test out new " +"ideas or inspect modules and packages (remember ``help(x)``)." msgstr "" +"Python tiene un intérprete interactivo, lo que significa que puede ingresar " +"sentencias y expresiones en el prompt del intérprete, ejecutarlos de inmediato " +"y ver sus resultados. Sólo ejecute ``python`` sin argumentos (podría " +"seleccionarlo desde el menú principal de su computadora). Es una forma muy " +"potente de probar nuevas ideas o inspeccionar módulos y paquetes (recuerde " +"``help(x)``)." #: ../Doc/glossary.rst:542 msgid "interpreted" -msgstr "" +msgstr "interpretado" #: ../Doc/glossary.rst:544 msgid "" @@ -945,10 +1281,17 @@ msgid "" "shorter development/debug cycle than compiled ones, though their programs " "generally also run more slowly. See also :term:`interactive`." msgstr "" +"Python es un lenguaje interpretado, a diferencia de uno compilado, a pesar de " +"que la distinción puede ser difusa debido al compilador a bytecode. Esto " +"significa que los archivos fuente pueden ser corridos directamente, sin crear " +"explícitamente un ejecutable que es corrido luego. Los lenguajes interpretados " +"típicamente tienen ciclos de desarrollo y depuración más cortos que los " +"compilados, sin embargo sus programas suelen correr más lentamente. Vea " +"también :term:`interactive`." #: ../Doc/glossary.rst:551 msgid "interpreter shutdown" -msgstr "" +msgstr "apagado del intérprete" #: ../Doc/glossary.rst:553 msgid "" @@ -957,20 +1300,31 @@ msgid "" "critical internal structures. It also makes several calls to the :term:" "`garbage collector `. This can trigger the execution of " "code in user-defined destructors or weakref callbacks. Code executed during " -"the shutdown phase can encounter various exceptions as the resources it " -"relies on may not function anymore (common examples are library modules or " -"the warnings machinery)." -msgstr "" +"the shutdown phase can encounter various exceptions as the resources it relies " +"on may not function anymore (common examples are library modules or the " +"warnings machinery)." +msgstr "" +"Cuando se le solicita apagarse, el intérprete Python ingresa a un fase " +"especial en la cual gradualmente libera todos los recursos reservados, como " +"módulos y varias estructuras internas críticas. También hace varias llamadas " +"al :term:`recolector de basura `. Esto puede disparar la " +"ejecución de código de destructores definidos por el usuario o \"weakref " +"callbacks\". El código ejecutado durante la fase de apagado puede encontrar " +"varias excepciones debido a que los recursos que necesita pueden no funcionar " +"más (ejemplos comunes son los módulos de bibliotecas o los artefactos de " +"advertencias \"warnings machinery\")" #: ../Doc/glossary.rst:562 msgid "" "The main reason for interpreter shutdown is that the ``__main__`` module or " "the script being run has finished executing." msgstr "" +"La principal razón para el apagado del intérpreter es que el módulo " +"``__main__`` o el script que estaba corriendo termine su ejecución." #: ../Doc/glossary.rst:564 msgid "iterable" -msgstr "" +msgstr "iterable" #: ../Doc/glossary.rst:566 msgid "" @@ -981,49 +1335,79 @@ msgid "" "meth:`__iter__` method or with a :meth:`__getitem__` method that implements :" "term:`Sequence` semantics." msgstr "" +"Un objeto capaz de retornar sus miembros uno por vez. Ejemplos de iterables " +"son todos los tipos de secuencias (como :class:`list`, :class:`str`, y :class:" +"`tuple`) y algunos de tipos no secuenciales, como :class:`dict`, :term:`objeto " +"archivo `, y objetos de cualquier clase que defina con los " +"métodos :meth:`__iter__` o con un método :meth:`__getitem__` que implementen " +"la semántica de :term:`Sequence`." #: ../Doc/glossary.rst:573 msgid "" -"Iterables can be used in a :keyword:`for` loop and in many other places " -"where a sequence is needed (:func:`zip`, :func:`map`, ...). When an " -"iterable object is passed as an argument to the built-in function :func:" -"`iter`, it returns an iterator for the object. This iterator is good for " -"one pass over the set of values. When using iterables, it is usually not " -"necessary to call :func:`iter` or deal with iterator objects yourself. The " -"``for`` statement does that automatically for you, creating a temporary " -"unnamed variable to hold the iterator for the duration of the loop. See " -"also :term:`iterator`, :term:`sequence`, and :term:`generator`." -msgstr "" +"Iterables can be used in a :keyword:`for` loop and in many other places where " +"a sequence is needed (:func:`zip`, :func:`map`, ...). When an iterable object " +"is passed as an argument to the built-in function :func:`iter`, it returns an " +"iterator for the object. This iterator is good for one pass over the set of " +"values. When using iterables, it is usually not necessary to call :func:" +"`iter` or deal with iterator objects yourself. The ``for`` statement does " +"that automatically for you, creating a temporary unnamed variable to hold the " +"iterator for the duration of the loop. See also :term:`iterator`, :term:" +"`sequence`, and :term:`generator`." +msgstr "" +"Los iterables pueden ser usados en el bucle :keyword:`for` y en muchos otros " +"sitios donde una secuencia es necesaria (:func:`zip`, :func:`map`, ...). " +"Cuando un objeto iterable es pasado como argumento a la función incorporada :" +"func:`iter`, retorna un iterador para el objeto. Este iterador pasa así el " +"conjunto de valores. Cuando se usan iterables, normalmente no es necesario " +"llamar a la función :func:`iter` o tratar con los objetos iteradores usted " +"mismo. La sentencia ``for`` lo hace automáticamente por usted, creando un " +"variable temporal sin nombre para mantener el iterador mientras dura el " +"bucle. Vea también :term:`iterator`, :term:`sequence`, y :term:`generator`." #: ../Doc/glossary.rst:583 msgid "iterator" -msgstr "" +msgstr "iterador" #: ../Doc/glossary.rst:585 msgid "" "An object representing a stream of data. Repeated calls to the iterator's :" -"meth:`~iterator.__next__` method (or passing it to the built-in function :" -"func:`next`) return successive items in the stream. When no more data are " -"available a :exc:`StopIteration` exception is raised instead. At this " -"point, the iterator object is exhausted and any further calls to its :meth:" -"`__next__` method just raise :exc:`StopIteration` again. Iterators are " -"required to have an :meth:`__iter__` method that returns the iterator object " -"itself so every iterator is also iterable and may be used in most places " -"where other iterables are accepted. One notable exception is code which " -"attempts multiple iteration passes. A container object (such as a :class:" -"`list`) produces a fresh new iterator each time you pass it to the :func:" -"`iter` function or use it in a :keyword:`for` loop. Attempting this with an " -"iterator will just return the same exhausted iterator object used in the " -"previous iteration pass, making it appear like an empty container." -msgstr "" +"meth:`~iterator.__next__` method (or passing it to the built-in function :func:" +"`next`) return successive items in the stream. When no more data are " +"available a :exc:`StopIteration` exception is raised instead. At this point, " +"the iterator object is exhausted and any further calls to its :meth:`__next__` " +"method just raise :exc:`StopIteration` again. Iterators are required to have " +"an :meth:`__iter__` method that returns the iterator object itself so every " +"iterator is also iterable and may be used in most places where other iterables " +"are accepted. One notable exception is code which attempts multiple iteration " +"passes. A container object (such as a :class:`list`) produces a fresh new " +"iterator each time you pass it to the :func:`iter` function or use it in a :" +"keyword:`for` loop. Attempting this with an iterator will just return the " +"same exhausted iterator object used in the previous iteration pass, making it " +"appear like an empty container." +msgstr "" +"Un objeto que representa un flujo de datos. Llamadas repetidas al método :" +"meth:`~iterator.__next__` del iterador (o al pasar la función incorporada :" +"func:`next`) retorna ítems sucesivos del flujo. Cuando no hay más datos " +"disponibles, una excepción :exc:`StopIteration` es disparada. En este " +"momento, el objeto iterador está exhausto y cualquier llamada posterior al " +"método :meth:`__next__` sólo dispara otra vez :exc:`StopIteration`. Los " +"iteradores necesitan tener un método:meth:`__iter__` que retorna el objeto " +"iterador mismo así cada iterador es también un iterable y puede ser usado en " +"casi todos los lugares donde los iterables son aceptados. Una excepción " +"importante es el código que intenta múltiples pases de iteración. Un objeto " +"contenedor (como la :class:`list`) produce un nuevo iterador cada vez que las " +"pasa a una función :func:`iter` o la usa en un blucle :keyword:`for`. " +"Intentar ésto con un iterador simplemente retornaría el mismo objeto iterador " +"exhausto usado en previas iteraciones, haciéndolo aparecer como un contenedor " +"vacío." #: ../Doc/glossary.rst:600 msgid "More information can be found in :ref:`typeiter`." -msgstr "" +msgstr "Puede encontrar más información en :ref:`typeiter`." #: ../Doc/glossary.rst:601 msgid "key function" -msgstr "" +msgstr "función clave" #: ../Doc/glossary.rst:603 msgid "" @@ -1031,6 +1415,10 @@ msgid "" "for sorting or ordering. For example, :func:`locale.strxfrm` is used to " "produce a sort key that is aware of locale specific sort conventions." msgstr "" +"Una función clave o una función de colación es un invocable que retorna un " +"valor usado para el ordenamiento o clasificación. Por ejemplo, :func:`locale." +"strxfrm` es usada para producir claves de ordenamiento que se adaptan a las " +"convenciones específicas de ordenamiento de un locale." #: ../Doc/glossary.rst:608 msgid "" @@ -1039,30 +1427,42 @@ msgid "" "meth:`list.sort`, :func:`heapq.merge`, :func:`heapq.nsmallest`, :func:`heapq." "nlargest`, and :func:`itertools.groupby`." msgstr "" +"Cierta cantidad de herramientas de Python aceptan funciones clave para " +"controlar como los elementos son ordenados o agrupados. Incluyendo a :func:" +"`min`, :func:`max`, :func:`sorted`, :meth:`list.sort`, :func:`heapq.merge`, :" +"func:`heapq.nsmallest`, :func:`heapq.nlargest`, y :func:`itertools.groupby`." #: ../Doc/glossary.rst:614 msgid "" -"There are several ways to create a key function. For example. the :meth:" -"`str.lower` method can serve as a key function for case insensitive sorts. " -"Alternatively, a key function can be built from a :keyword:`lambda` " -"expression such as ``lambda r: (r[0], r[2])``. Also, the :mod:`operator` " -"module provides three key function constructors: :func:`~operator." -"attrgetter`, :func:`~operator.itemgetter`, and :func:`~operator." -"methodcaller`. See the :ref:`Sorting HOW TO ` for examples of " -"how to create and use key functions." -msgstr "" +"There are several ways to create a key function. For example. the :meth:`str." +"lower` method can serve as a key function for case insensitive sorts. " +"Alternatively, a key function can be built from a :keyword:`lambda` expression " +"such as ``lambda r: (r[0], r[2])``. Also, the :mod:`operator` module provides " +"three key function constructors: :func:`~operator.attrgetter`, :func:" +"`~operator.itemgetter`, and :func:`~operator.methodcaller`. See the :ref:" +"`Sorting HOW TO ` for examples of how to create and use key " +"functions." +msgstr "" +"Hay varias formas de crear una función clave. Por ejemplo, el método :meth:" +"`str.lower` puede servir como función clave para ordenamientos que no " +"distingan mayúsculas de minúsculas. Como alternativa, una función clave puede " +"ser realizada con una expresión :keyword:`lambda` como ``lambda r: (r[0], " +"r[2])``. También, el módulo :mod:`operator` provee tres constructores de " +"funciones clave: :func:`~operator.attrgetter`, :func:`~operator.itemgetter`, " +"y :func:`~operator.methodcaller`. Vea en :ref:`Sorting HOW TO ` " +"ejemplos de cómo crear y usar funciones clave." #: ../Doc/glossary.rst:622 msgid "keyword argument" -msgstr "" +msgstr "argumento nombrado" #: ../Doc/glossary.rst:624 ../Doc/glossary.rst:888 msgid "See :term:`argument`." -msgstr "" +msgstr "Vea :term:`argument`." #: ../Doc/glossary.rst:625 msgid "lambda" -msgstr "" +msgstr "lambda" #: ../Doc/glossary.rst:627 msgid "" @@ -1070,31 +1470,43 @@ msgid "" "is evaluated when the function is called. The syntax to create a lambda " "function is ``lambda [parameters]: expression``" msgstr "" +"Una función anónima de una línea consistente en un sola :term:`expression` que " +"es evaluada cuando la función es llamada. La sintaxis para crear una función " +"lambda es ``lambda [parameters]: expression``" #: ../Doc/glossary.rst:630 msgid "LBYL" -msgstr "" +msgstr "LBYL" #: ../Doc/glossary.rst:632 msgid "" "Look before you leap. This coding style explicitly tests for pre-conditions " "before making calls or lookups. This style contrasts with the :term:`EAFP` " -"approach and is characterized by the presence of many :keyword:`if` " -"statements." +"approach and is characterized by the presence of many :keyword:`if` statements." msgstr "" +"Del inglés \"Look before you leap\", \"mira antes de saltar\". Es un estilo " +"de codificación que prueba explícitamente las condiciones previas antes de " +"hacer llamadas o búsquedas. Este estilo contrasta con la manera :term:`EAFP` " +"y está caracterizado por la presencia de muchas sentencias :keyword:`if`." #: ../Doc/glossary.rst:637 msgid "" -"In a multi-threaded environment, the LBYL approach can risk introducing a " -"race condition between \"the looking\" and \"the leaping\". For example, " -"the code, ``if key in mapping: return mapping[key]`` can fail if another " -"thread removes *key* from *mapping* after the test, but before the lookup. " -"This issue can be solved with locks or by using the EAFP approach." +"In a multi-threaded environment, the LBYL approach can risk introducing a race " +"condition between \"the looking\" and \"the leaping\". For example, the code, " +"``if key in mapping: return mapping[key]`` can fail if another thread removes " +"*key* from *mapping* after the test, but before the lookup. This issue can be " +"solved with locks or by using the EAFP approach." msgstr "" +"En entornos multi-hilos, el método LBYL tiene el riesgo de introducir " +"condiciones de carrera entre los hilos que están \"mirando\" y los que están " +"\"saltando\". Por ejemplo, el código, `if key in mapping: return " +"mapping[key]`` puede fallar si otro hilo remueve *key* de *mapping* después " +"del test, pero antes de retornar el valor. Este problema puede ser resuelto " +"usando bloqueos o empleando el método EAFP." #: ../Doc/glossary.rst:642 msgid "list" -msgstr "" +msgstr "lista" #: ../Doc/glossary.rst:644 msgid "" @@ -1102,23 +1514,31 @@ msgid "" "array in other languages than to a linked list since access to elements is " "O(1)." msgstr "" +"Es una :term:`sequence` Python incorporada. A pesar de su nombre es más " +"similar a un arreglo en otros lenguajes que a una lista enlazada porque el " +"acceso a los elementos es O(1)." #: ../Doc/glossary.rst:647 msgid "list comprehension" -msgstr "" +msgstr "comprensión de listas" #: ../Doc/glossary.rst:649 msgid "" -"A compact way to process all or part of the elements in a sequence and " -"return a list with the results. ``result = ['{:#04x}'.format(x) for x in " -"range(256) if x % 2 == 0]`` generates a list of strings containing even hex " -"numbers (0x..) in the range from 0 to 255. The :keyword:`if` clause is " -"optional. If omitted, all elements in ``range(256)`` are processed." +"A compact way to process all or part of the elements in a sequence and return " +"a list with the results. ``result = ['{:#04x}'.format(x) for x in range(256) " +"if x % 2 == 0]`` generates a list of strings containing even hex numbers " +"(0x..) in the range from 0 to 255. The :keyword:`if` clause is optional. If " +"omitted, all elements in ``range(256)`` are processed." msgstr "" +"Una forma compacta de procesar todos o parte de los elementos en una secuencia " +"y retornar una lista como resultado. ``result = ['{:#04x}'.format(x) for x in " +"range(256) if x % 2 == 0]`` genera una lista de cadenas conteniendo números " +"hexadecimales (0x..) entre 0 y 255. La cláusula :keyword:`if` es opcional. Si " +"es omitida, todos los elementos en ``range(256)`` son procesados." #: ../Doc/glossary.rst:655 msgid "loader" -msgstr "" +msgstr "cargador" #: ../Doc/glossary.rst:657 msgid "" @@ -1127,32 +1547,42 @@ msgid "" "`302` for details and :class:`importlib.abc.Loader` for an :term:`abstract " "base class`." msgstr "" +"Un objeto que carga un módulo. Debe definir el método llamado :meth:" +"`load_module`. Un cargador es normalmente retornados por un :term:`finder`. " +"Vea :pep:`302` para detalles y :class:`importlib.abc.Loader` para una :term:" +"`abstract base class`." #: ../Doc/glossary.rst:661 msgid "magic method" -msgstr "" +msgstr "método mágico" #: ../Doc/glossary.rst:665 msgid "An informal synonym for :term:`special method`." -msgstr "" +msgstr "Una manera informal de llamar a un :term:`special method`." #: ../Doc/glossary.rst:666 msgid "mapping" -msgstr "" +msgstr "mapeado" #: ../Doc/glossary.rst:668 msgid "" "A container object that supports arbitrary key lookups and implements the " "methods specified in the :class:`~collections.abc.Mapping` or :class:" "`~collections.abc.MutableMapping` :ref:`abstract base classes `. Examples include :class:`dict`, :class:" -"`collections.defaultdict`, :class:`collections.OrderedDict` and :class:" +"abstract-base-classes>`. Examples include :class:`dict`, :class:`collections." +"defaultdict`, :class:`collections.OrderedDict` and :class:`collections." +"Counter`." +msgstr "" +"Un objeto contenedor que permite recupero de claves arbitrarias y que " +"implementa los métodos especificados en la :class:`~collections.abc.Mapping` " +"o :class:`~collections.abc.MutableMapping` :ref:`abstract base classes " +"`. Por ejemplo, :class:`dict`, :class:" +"`collections.defaultdict`, :class:`collections.OrderedDict` y :class:" "`collections.Counter`." -msgstr "" #: ../Doc/glossary.rst:674 msgid "meta path finder" -msgstr "" +msgstr "meta buscadores de ruta" #: ../Doc/glossary.rst:676 msgid "" @@ -1160,16 +1590,21 @@ msgid "" "finders are related to, but different from :term:`path entry finders `." msgstr "" +"Un :term:`finder` retornado por una búsqueda de :data:`sys.meta_path`. Los " +"meta buscadores de ruta están relacionados a :term:`buscadores de entradas de " +"rutas `, pero son algo diferente." #: ../Doc/glossary.rst:680 msgid "" "See :class:`importlib.abc.MetaPathFinder` for the methods that meta path " "finders implement." msgstr "" +"Vea en :class:`importlib.abc.MetaPathFinder` los métodos que los meta " +"buscadores de ruta implementan." #: ../Doc/glossary.rst:682 msgid "metaclass" -msgstr "" +msgstr "metaclase" #: ../Doc/glossary.rst:684 msgid "" @@ -1177,126 +1612,171 @@ msgid "" "dictionary, and a list of base classes. The metaclass is responsible for " "taking those three arguments and creating the class. Most object oriented " "programming languages provide a default implementation. What makes Python " -"special is that it is possible to create custom metaclasses. Most users " -"never need this tool, but when the need arises, metaclasses can provide " -"powerful, elegant solutions. They have been used for logging attribute " -"access, adding thread-safety, tracking object creation, implementing " -"singletons, and many other tasks." -msgstr "" +"special is that it is possible to create custom metaclasses. Most users never " +"need this tool, but when the need arises, metaclasses can provide powerful, " +"elegant solutions. They have been used for logging attribute access, adding " +"thread-safety, tracking object creation, implementing singletons, and many " +"other tasks." +msgstr "" +"La clase de una clase. Las definiciones de clases crean nombres de clase, un " +"diccionario de clase, y una lista de clases base. Las metaclases son " +"responsables de tomar estos tres argumentos y crear la clase. La mayoría de " +"los objetos de un lenguaje de programación orientado a objetos provienen de " +"una implementación por defecto. Lo que hace a Python especial que es posible " +"crear metaclases a medida. La mayoría de los usuario nunca necesitarán esta " +"herramienta, pero cuando la necesidad surge, las metaclases pueden brindar " +"soluciones poderosas y elegantes. Han sido usadas para loggear acceso de " +"atributos, agregar seguridad a hilos, rastrear la creación de objetos, " +"implementar singletons, y muchas otras tareas." #: ../Doc/glossary.rst:694 msgid "More information can be found in :ref:`metaclasses`." -msgstr "" +msgstr "Más información hallará en :ref:`metaclasses`." #: ../Doc/glossary.rst:695 msgid "method" -msgstr "" +msgstr "método" #: ../Doc/glossary.rst:697 msgid "" -"A function which is defined inside a class body. If called as an attribute " -"of an instance of that class, the method will get the instance object as its " +"A function which is defined inside a class body. If called as an attribute of " +"an instance of that class, the method will get the instance object as its " "first :term:`argument` (which is usually called ``self``). See :term:" "`function` and :term:`nested scope`." msgstr "" +"Una función que es definida dentro del cuerpo de una clase. Si es llamada " +"como un atributo de una instancia de otra clase, el método tomará el objeto " +"instanciado como su primer :term:`argument` (el cual es usualmente denominado " +"`self`). Vea :term:`function` y :term:`nested scope`." #: ../Doc/glossary.rst:701 msgid "method resolution order" -msgstr "" +msgstr "orden de resolución de métodos" #: ../Doc/glossary.rst:703 msgid "" -"Method Resolution Order is the order in which base classes are searched for " -"a member during lookup. See `The Python 2.3 Method Resolution Order `_ for details of the algorithm " -"used by the Python interpreter since the 2.3 release." +"Method Resolution Order is the order in which base classes are searched for a " +"member during lookup. See `The Python 2.3 Method Resolution Order `_ for details of the algorithm used by " +"the Python interpreter since the 2.3 release." msgstr "" +"Orden de resolución de métodos es el orden en el cual una clase base es " +"buscada por un miembro durante la búsqueda. Mire en `The Python 2.3 Method " +"Resolution Order `_ los " +"detalles del algoritmo usado por el intérprete Python desde la versión 2.3." #: ../Doc/glossary.rst:707 msgid "module" -msgstr "" +msgstr "módulo" #: ../Doc/glossary.rst:709 msgid "" -"An object that serves as an organizational unit of Python code. Modules " -"have a namespace containing arbitrary Python objects. Modules are loaded " -"into Python by the process of :term:`importing`." +"An object that serves as an organizational unit of Python code. Modules have " +"a namespace containing arbitrary Python objects. Modules are loaded into " +"Python by the process of :term:`importing`." msgstr "" +"Un objeto que sirve como unidad de organización del código Python. Los " +"módulos tienen espacios de nombres conteniendo objetos Python arbitrarios. " +"Los módulos son cargados en Python por el proceso de :term:`importing`." #: ../Doc/glossary.rst:713 msgid "See also :term:`package`." -msgstr "" +msgstr "Vea también :term:`package`." #: ../Doc/glossary.rst:714 msgid "module spec" -msgstr "" +msgstr "especificador de módulo" #: ../Doc/glossary.rst:716 msgid "" "A namespace containing the import-related information used to load a module. " "An instance of :class:`importlib.machinery.ModuleSpec`." msgstr "" +"Un espacio de nombres que contiene la información relacionada a la importación " +"usada al leer un módulo. Una instancia de :class:`importlib.machinery." +"ModuleSpec`." #: ../Doc/glossary.rst:718 msgid "MRO" -msgstr "" +msgstr "MRO" #: ../Doc/glossary.rst:720 msgid "See :term:`method resolution order`." -msgstr "" +msgstr "Vea :term:`method resolution order`." #: ../Doc/glossary.rst:721 msgid "mutable" -msgstr "" +msgstr "mutable" #: ../Doc/glossary.rst:723 msgid "" "Mutable objects can change their value but keep their :func:`id`. See also :" "term:`immutable`." msgstr "" +"Los objetos mutables pueden cambiar su valor pero mantener su :func:`id`. Vea " +"también :term:`immutable`." #: ../Doc/glossary.rst:725 msgid "named tuple" -msgstr "" +msgstr "tupla nombrada" #: ../Doc/glossary.rst:727 msgid "" -"Any tuple-like class whose indexable elements are also accessible using " -"named attributes (for example, :func:`time.localtime` returns a tuple-like " -"object where the *year* is accessible either with an index such as ``t[0]`` " -"or with a named attribute like ``t.tm_year``)." +"Any tuple-like class whose indexable elements are also accessible using named " +"attributes (for example, :func:`time.localtime` returns a tuple-like object " +"where the *year* is accessible either with an index such as ``t[0]`` or with a " +"named attribute like ``t.tm_year``)." msgstr "" +"Cualquier clase similar a una tupla cuyos elementos indexables son también " +"accesibles usando atributos nombrados (por ejemplo, :func:`time.localtime` " +"retorna un objeto similar a tupla donde *year* es accesible tanto como " +"``t[0]`` o con un atributo nombrado como``t.tm_year``)." #: ../Doc/glossary.rst:732 msgid "" -"A named tuple can be a built-in type such as :class:`time.struct_time`, or " -"it can be created with a regular class definition. A full featured named " -"tuple can also be created with the factory function :func:`collections." -"namedtuple`. The latter approach automatically provides extra features such " -"as a self-documenting representation like ``Employee(name='jones', " -"title='programmer')``." +"A named tuple can be a built-in type such as :class:`time.struct_time`, or it " +"can be created with a regular class definition. A full featured named tuple " +"can also be created with the factory function :func:`collections.namedtuple`. " +"The latter approach automatically provides extra features such as a self-" +"documenting representation like ``Employee(name='jones', title='programmer')``." msgstr "" +"Una tupla nombrada puede ser un tipo incorporado como :class:`time." +"struct_time`, o puede ser creada con una definición regular de clase. Una " +"tupla nombrada con todas las características puede también ser creada con la " +"función factoría :func:`collections.namedtuple`. Esta última forma " +"automáticamente brinda capacidades extra como una representación " +"autodocumentada como ``Employee(name='jones', title='programmer')``." #: ../Doc/glossary.rst:738 msgid "namespace" -msgstr "" +msgstr "espacio de nombres" #: ../Doc/glossary.rst:740 msgid "" "The place where a variable is stored. Namespaces are implemented as " -"dictionaries. There are the local, global and built-in namespaces as well " -"as nested namespaces in objects (in methods). Namespaces support modularity " -"by preventing naming conflicts. For instance, the functions :func:`builtins." -"open <.open>` and :func:`os.open` are distinguished by their namespaces. " +"dictionaries. There are the local, global and built-in namespaces as well as " +"nested namespaces in objects (in methods). Namespaces support modularity by " +"preventing naming conflicts. For instance, the functions :func:`builtins.open " +"<.open>` and :func:`os.open` are distinguished by their namespaces. " "Namespaces also aid readability and maintainability by making it clear which " "module implements a function. For instance, writing :func:`random.seed` or :" -"func:`itertools.islice` makes it clear that those functions are implemented " -"by the :mod:`random` and :mod:`itertools` modules, respectively." -msgstr "" +"func:`itertools.islice` makes it clear that those functions are implemented by " +"the :mod:`random` and :mod:`itertools` modules, respectively." +msgstr "" +"El lugar donde la variable es almacenada. Los espacios de nombres son " +"implementados como diccionarios. Hay espacio de nombre local, global, e " +"incorporado así como espacios de nombres anidados en objetos (en métodos). " +"Los espacios de nombres soportan modularidad previniendo conflictos de " +"nombramiento. Por ejemplo, las funciones :func:`builtins.open <.open>` y :" +"func:`os.open` se distinguen por su espacio de nombres. Los espacios de " +"nombres también ayuda a la legibilidad y mantenibilidad dejando claro qué " +"módulo implementa una función. Por ejemplo, escribiendo :func:`random.seed` " +"o :func:`itertools.islice` queda claro que éstas funciones están implementadas " +"en los módulos :mod:`random` y :mod:`itertools`, respectivamente." #: ../Doc/glossary.rst:750 msgid "namespace package" -msgstr "" +msgstr "paquete de espacios de nombres" #: ../Doc/glossary.rst:752 msgid "" @@ -1305,50 +1785,69 @@ msgid "" "specifically are not like a :term:`regular package` because they have no " "``__init__.py`` file." msgstr "" +"Un :pep:`420` :term:`package` que sirve sólo para contener subpaquetes. Los " +"paquetes de espacios de nombres pueden no tener representación física, y " +"específicamente se diferencian de los :term:`regular package` porque no tienen " +"un archivo ``__init__.py``." #: ../Doc/glossary.rst:757 msgid "See also :term:`module`." -msgstr "" +msgstr "Vea también :term:`module`." #: ../Doc/glossary.rst:758 msgid "nested scope" -msgstr "" +msgstr "alcances anidados" #: ../Doc/glossary.rst:760 msgid "" -"The ability to refer to a variable in an enclosing definition. For " -"instance, a function defined inside another function can refer to variables " -"in the outer function. Note that nested scopes by default work only for " -"reference and not for assignment. Local variables both read and write in " -"the innermost scope. Likewise, global variables read and write to the " -"global namespace. The :keyword:`nonlocal` allows writing to outer scopes." -msgstr "" +"The ability to refer to a variable in an enclosing definition. For instance, " +"a function defined inside another function can refer to variables in the outer " +"function. Note that nested scopes by default work only for reference and not " +"for assignment. Local variables both read and write in the innermost scope. " +"Likewise, global variables read and write to the global namespace. The :" +"keyword:`nonlocal` allows writing to outer scopes." +msgstr "" +"La habilidad de referirse a una variable dentro de una definición encerrada. " +"Por ejemplo, una función definida dentro de otra función puede referir a " +"variables en la función externa. Note que los alcances anidados por defecto " +"sólo funcionan para referencia y no para asignación. Las variables locales " +"leen y escriben sólo en el alcance más interno. De manera semejante, las " +"variables globales pueden leer y escribir en el espacio de nombres global. " +"Con :keyword:`nonlocal` se puede escribir en alcances exteriores." #: ../Doc/glossary.rst:767 msgid "new-style class" -msgstr "" +msgstr "clase de nuevo estilo" #: ../Doc/glossary.rst:769 msgid "" -"Old name for the flavor of classes now used for all class objects. In " -"earlier Python versions, only new-style classes could use Python's newer, " -"versatile features like :attr:`~object.__slots__`, descriptors, properties, :" -"meth:`__getattribute__`, class methods, and static methods." +"Old name for the flavor of classes now used for all class objects. In earlier " +"Python versions, only new-style classes could use Python's newer, versatile " +"features like :attr:`~object.__slots__`, descriptors, properties, :meth:" +"`__getattribute__`, class methods, and static methods." msgstr "" +"Vieja denominación usada para el estilo de clases ahora empleado en todos los " +"objetos de clase. En versiones más tempranas de Python, sólo las nuevas " +"clases podían usar capacidades nuevas y versátiles de Python como :attr:" +"`~object.__slots__`, descriptores, propiedades, :meth:`__getattribute__`, " +"métodos de clase y métodos estáticos." #: ../Doc/glossary.rst:773 msgid "object" -msgstr "" +msgstr "objeto" #: ../Doc/glossary.rst:775 msgid "" "Any data with state (attributes or value) and defined behavior (methods). " "Also the ultimate base class of any :term:`new-style class`." msgstr "" +"Cualquier dato con estado (atributo o valor) y comportamiento definido " +"(métodos). También es la más básica clase base para cualquier :term:`new-" +"style class`." #: ../Doc/glossary.rst:778 msgid "package" -msgstr "" +msgstr "paquete" #: ../Doc/glossary.rst:780 msgid "" @@ -1356,29 +1855,39 @@ msgid "" "subpackages. Technically, a package is a Python module with an ``__path__`` " "attribute." msgstr "" +"Un :term:`module` Python que puede contener submódulos o recursivamente, " +"subpaquetes. Técnicamente, un paquete es un módulo Python con un atributo " +"``__path__``." #: ../Doc/glossary.rst:784 msgid "See also :term:`regular package` and :term:`namespace package`." -msgstr "" +msgstr "Vea también :term:`regular package` y :term:`namespace package`." #: ../Doc/glossary.rst:785 msgid "parameter" -msgstr "" +msgstr "parámetro" #: ../Doc/glossary.rst:787 msgid "" -"A named entity in a :term:`function` (or method) definition that specifies " -"an :term:`argument` (or in some cases, arguments) that the function can " -"accept. There are five kinds of parameter:" +"A named entity in a :term:`function` (or method) definition that specifies an :" +"term:`argument` (or in some cases, arguments) that the function can accept. " +"There are five kinds of parameter:" msgstr "" +"Una entidad nombrada en una definición de una :term:`function` (o método) que " +"especifica un :term:`argument` (o en algunos casos, varios argumentos) que la " +"función puede aceptar. Existen cinco tipos de argumentos:" #: ../Doc/glossary.rst:791 msgid "" -":dfn:`positional-or-keyword`: specifies an argument that can be passed " -"either :term:`positionally ` or as a :term:`keyword argument " -"`. This is the default kind of parameter, for example *foo* and " -"*bar* in the following::" +":dfn:`positional-or-keyword`: specifies an argument that can be passed either :" +"term:`positionally ` or as a :term:`keyword argument `. " +"This is the default kind of parameter, for example *foo* and *bar* in the " +"following::" msgstr "" +":dfn:`posicional o nombrado`: especifica un argumento que puede ser pasado " +"tanto como :term:`posicional ` o como :term:`nombrado `. " +"Este es el tipo por defecto de parámetro, como *foo* y *bar* en el siguiente " +"ejemplo::" #: ../Doc/glossary.rst:800 msgid "" @@ -1387,6 +1896,10 @@ msgid "" "However, some built-in functions have positional-only parameters (e.g. :func:" "`abs`)." msgstr "" +":dfn:`sólo posicional`: especifica un argumento que puede ser pasado sólo por " +"posición. Python no tiene una sintaxis específica para los parámetros que son " +"sólo por posición. Sin embargo, algunas funciones tienen parámetros sólo por " +"posición (por ejemplo :func:`abs`)." #: ../Doc/glossary.rst:807 msgid "" @@ -1396,89 +1909,118 @@ msgid "" "definition before them, for example *kw_only1* and *kw_only2* in the " "following::" msgstr "" +":dfn:`sólo nombrado`: especifica un argumento que sólo puede ser pasado por " +"nombre. Los parámetros sólo por nombre pueden ser definidos incluyendo un " +"parámetro posicional de una sola variable o un mero ``*``` antes de ellos en " +"la lista de parámetros en la definición de la función, como *kw_only1* y " +"*kw_only2* en el ejemplo siguiente::" #: ../Doc/glossary.rst:815 msgid "" ":dfn:`var-positional`: specifies that an arbitrary sequence of positional " "arguments can be provided (in addition to any positional arguments already " -"accepted by other parameters). Such a parameter can be defined by " -"prepending the parameter name with ``*``, for example *args* in the " -"following::" +"accepted by other parameters). Such a parameter can be defined by prepending " +"the parameter name with ``*``, for example *args* in the following::" msgstr "" +":dfn:`variable posicional`: especifica una secuencia arbitraria de argumentos " +"posicionales que pueden ser brindados (además de cualquier argumento " +"posicional aceptado por otros parámetros). Este parámetro puede ser definido " +"anteponiendo al nombre del parámetro ``*``, como a *args* en el siguiente " +"ejemplo::" #: ../Doc/glossary.rst:823 msgid "" ":dfn:`var-keyword`: specifies that arbitrarily many keyword arguments can be " "provided (in addition to any keyword arguments already accepted by other " -"parameters). Such a parameter can be defined by prepending the parameter " -"name with ``**``, for example *kwargs* in the example above." +"parameters). Such a parameter can be defined by prepending the parameter name " +"with ``**``, for example *kwargs* in the example above." msgstr "" +":dfn:`variable nombrado`: especifica que arbitrariamente muchos argumentos " +"nombrados pueden ser brindados (además de cualquier argumento nombrado ya " +"aceptado por cualquier otro parámetro). Este parámetro puede ser definido " +"anteponiendo al nombre del parámetro con ``**``, como *kwargs* en el ejemplo " +"más arriba." #: ../Doc/glossary.rst:829 msgid "" "Parameters can specify both optional and required arguments, as well as " "default values for some optional arguments." msgstr "" +"Los parámetros puede especificar tanto argumentos opcionales como requeridos, " +"así como valores por defecto para algunos argumentos opcionales." #: ../Doc/glossary.rst:832 msgid "" "See also the :term:`argument` glossary entry, the FAQ question on :ref:`the " -"difference between arguments and parameters `, " -"the :class:`inspect.Parameter` class, the :ref:`function` section, and :pep:" -"`362`." +"difference between arguments and parameters `, the :" +"class:`inspect.Parameter` class, the :ref:`function` section, and :pep:`362`." msgstr "" +"Vea también el glosario de :term:`argument`, la pregunta respondida en :ref:" +"`la diferencia entre argumentos y parámetros `, la " +"clase :class:`inspect.Parameter`, la sección :ref:`function` , y :pep:`362`." #: ../Doc/glossary.rst:836 msgid "path entry" -msgstr "" +msgstr "entrada de ruta" #: ../Doc/glossary.rst:838 msgid "" "A single location on the :term:`import path` which the :term:`path based " "finder` consults to find modules for importing." msgstr "" +"Una ubicación única en el :term:`import path` que el :term:`path based finder` " +"consulta para encontrar los módulos a importar." #: ../Doc/glossary.rst:840 msgid "path entry finder" -msgstr "" +msgstr "buscador de entradas de ruta" #: ../Doc/glossary.rst:842 msgid "" "A :term:`finder` returned by a callable on :data:`sys.path_hooks` (i.e. a :" -"term:`path entry hook`) which knows how to locate modules given a :term:" -"`path entry`." +"term:`path entry hook`) which knows how to locate modules given a :term:`path " +"entry`." msgstr "" +"Un :term:`finder` retornado por un invocable en :data:`sys.path_hooks` (esto " +"es, un :term:`path entry hook`) que sabe cómo localizar módulos dada una :term:" +"`path entry`." #: ../Doc/glossary.rst:846 msgid "" "See :class:`importlib.abc.PathEntryFinder` for the methods that path entry " "finders implement." msgstr "" +"Vea en :class:`importlib.abc.PathEntryFinder` los métodos que los buscadores " +"de entradas de paths implementan." #: ../Doc/glossary.rst:848 msgid "path entry hook" -msgstr "" +msgstr "gancho a entrada de ruta" #: ../Doc/glossary.rst:850 msgid "" -"A callable on the :data:`sys.path_hook` list which returns a :term:`path " -"entry finder` if it knows how to find modules on a specific :term:`path " -"entry`." +"A callable on the :data:`sys.path_hook` list which returns a :term:`path entry " +"finder` if it knows how to find modules on a specific :term:`path entry`." msgstr "" +"Un invocable en la lista :data:`sys.path_hook` que retorna un :term:`path " +"entry finder` si éste sabe cómo encontrar módulos en un :term:`path entry` " +"específico." #: ../Doc/glossary.rst:853 msgid "path based finder" -msgstr "" +msgstr "buscador basado en ruta" #: ../Doc/glossary.rst:855 msgid "" -"One of the default :term:`meta path finders ` which " -"searches an :term:`import path` for modules." +"One of the default :term:`meta path finders ` which searches " +"an :term:`import path` for modules." msgstr "" +"Uno de los :term:`meta buscadores de ruta ` por defecto que " +"busca un :term:`import path` para los módulos." #: ../Doc/glossary.rst:857 msgid "path-like object" -msgstr "" +msgstr "objeto tipo ruta" #: ../Doc/glossary.rst:859 msgid "" @@ -1486,65 +2028,92 @@ msgid "" "class:`str` or :class:`bytes` object representing a path, or an object " "implementing the :class:`os.PathLike` protocol. An object that supports the :" "class:`os.PathLike` protocol can be converted to a :class:`str` or :class:" -"`bytes` file system path by calling the :func:`os.fspath` function; :func:" -"`os.fsdecode` and :func:`os.fsencode` can be used to guarantee a :class:" -"`str` or :class:`bytes` result instead, respectively. Introduced by :pep:" -"`519`." -msgstr "" +"`bytes` file system path by calling the :func:`os.fspath` function; :func:`os." +"fsdecode` and :func:`os.fsencode` can be used to guarantee a :class:`str` or :" +"class:`bytes` result instead, respectively. Introduced by :pep:`519`." +msgstr "" +"Un objeto que representa una ruta del sistema de archivos. Un objeto tipo ruta " +"puede ser tanto una :class:`str` como un :class:`bytes` representando una " +"ruta, o un objeto que implementa el protocolo :class:`os.PathLike`. Un objeto " +"que soporta el protocolo :class:`os.PathLike` puede ser convertido a ruta del " +"sistema de archivo de clase :class:`str` o :class:`bytes` usando la función :" +"func:`os.fspath`; :func:`os.fsdecode` :func:`os.fsencode` pueden emplearse " +"para garantizar que retorne respectivamente :class:`str` o :class:`bytes`. " +"Introducido por :pep:`519`." #: ../Doc/glossary.rst:867 msgid "PEP" -msgstr "" +msgstr "PEP" #: ../Doc/glossary.rst:869 msgid "" -"Python Enhancement Proposal. A PEP is a design document providing " -"information to the Python community, or describing a new feature for Python " -"or its processes or environment. PEPs should provide a concise technical " +"Python Enhancement Proposal. A PEP is a design document providing information " +"to the Python community, or describing a new feature for Python or its " +"processes or environment. PEPs should provide a concise technical " "specification and a rationale for proposed features." msgstr "" +"Propuesta de mejora de Python, del inglés \"Python Enhancement Proposal\". Un " +"PEP es un documento de diseño que brinda información a la comunidad Python, o " +"describe una nueva capacidad para Python, sus procesos o entorno. Los PEPs " +"deberían dar una especificación técnica concisa y una fundamentación para las " +"capacidades propuestas." #: ../Doc/glossary.rst:875 msgid "" "PEPs are intended to be the primary mechanisms for proposing major new " -"features, for collecting community input on an issue, and for documenting " -"the design decisions that have gone into Python. The PEP author is " -"responsible for building consensus within the community and documenting " -"dissenting opinions." +"features, for collecting community input on an issue, and for documenting the " +"design decisions that have gone into Python. The PEP author is responsible for " +"building consensus within the community and documenting dissenting opinions." msgstr "" +"Los PEPs tienen como propósito ser los mecanismos primarios para proponer " +"nuevas y mayores capacidad, para recoger la opinión de la comunidad sobre un " +"tema, y para documentar las decisiones de diseño que se han hecho en Python. " +"El autor del PEP es el responsable de lograr consenso con la comunidad y " +"documentar las opiniones disidentes." #: ../Doc/glossary.rst:881 msgid "See :pep:`1`." -msgstr "" +msgstr "Vea :pep:`1`." #: ../Doc/glossary.rst:882 msgid "portion" -msgstr "" +msgstr "porción" #: ../Doc/glossary.rst:884 msgid "" "A set of files in a single directory (possibly stored in a zip file) that " "contribute to a namespace package, as defined in :pep:`420`." msgstr "" +"Un conjunto de archivos en un único directorio (posiblemente guardo en un " +"archivo comprimido zip) que contribuye a un espacio de nombres de paquete, " +"como está definido en :pep:`420`." #: ../Doc/glossary.rst:886 msgid "positional argument" -msgstr "" +msgstr "argumento posicional" #: ../Doc/glossary.rst:889 msgid "provisional API" -msgstr "" +msgstr "API provisoria" #: ../Doc/glossary.rst:891 msgid "" "A provisional API is one which has been deliberately excluded from the " -"standard library's backwards compatibility guarantees. While major changes " -"to such interfaces are not expected, as long as they are marked provisional, " -"backwards incompatible changes (up to and including removal of the " -"interface) may occur if deemed necessary by core developers. Such changes " -"will not be made gratuitously -- they will occur only if serious fundamental " -"flaws are uncovered that were missed prior to the inclusion of the API." -msgstr "" +"standard library's backwards compatibility guarantees. While major changes to " +"such interfaces are not expected, as long as they are marked provisional, " +"backwards incompatible changes (up to and including removal of the interface) " +"may occur if deemed necessary by core developers. Such changes will not be " +"made gratuitously -- they will occur only if serious fundamental flaws are " +"uncovered that were missed prior to the inclusion of the API." +msgstr "" +"Una API provisoria es aquella que deliberadamente fue excluida de las " +"garantías de compatibilidad hacia atrás de la biblioteca estándar. Aunque no " +"se esperan cambios fundamentales en dichas interfaces, como están marcadas " +"como provisionales, los cambios incompatibles hacia atrás (incluso remover la " +"misma interfaz) podrían ocurrir si los desarrolladores principales lo " +"estiman. Estos cambios no se hacen gratuitamente -- solo ocurrirán si fallas " +"fundamentales y serias son descubiertas que no fueron vistas antes de la " +"inclusión de la API." #: ../Doc/glossary.rst:900 msgid "" @@ -1552,6 +2121,9 @@ msgid "" "\"solution of last resort\" - every attempt will still be made to find a " "backwards compatible resolution to any identified problems." msgstr "" +"Incluso para APIs provisorias, los cambios incompatibles hacia atrás son " +"vistos como una \"solución de último recurso\" - se intentará todo para " +"encontrar una solución compatible hacia atrás para los problemas identificados." #: ../Doc/glossary.rst:904 msgid "" @@ -1559,55 +2131,72 @@ msgid "" "without locking in problematic design errors for extended periods of time. " "See :pep:`411` for more details." msgstr "" +"Este proceso permite que la biblioteca estándar continúe evolucionando con el " +"tiempo, sin bloquearse por errores de diseño problemáticos por períodos " +"extensos de tiempo. Vea :pep`241` para más detalles." #: ../Doc/glossary.rst:907 msgid "provisional package" -msgstr "" +msgstr "paquete provisorio" #: ../Doc/glossary.rst:909 msgid "See :term:`provisional API`." -msgstr "" +msgstr "Vea :term:`provisional API`." #: ../Doc/glossary.rst:910 msgid "Python 3000" -msgstr "" +msgstr "Python 3000" #: ../Doc/glossary.rst:912 msgid "" -"Nickname for the Python 3.x release line (coined long ago when the release " -"of version 3 was something in the distant future.) This is also abbreviated " +"Nickname for the Python 3.x release line (coined long ago when the release of " +"version 3 was something in the distant future.) This is also abbreviated " "\"Py3k\"." msgstr "" +"Apodo para la fecha de lanzamiento de Python 3.x (acuñada en un tiempo cuando " +"llegar a la versión 3 era algo distante en el futuro.) También se lo abrevió " +"como \"Py3k\"." #: ../Doc/glossary.rst:915 msgid "Pythonic" -msgstr "" +msgstr "Pythónico" #: ../Doc/glossary.rst:917 msgid "" "An idea or piece of code which closely follows the most common idioms of the " -"Python language, rather than implementing code using concepts common to " -"other languages. For example, a common idiom in Python is to loop over all " -"elements of an iterable using a :keyword:`for` statement. Many other " -"languages don't have this type of construct, so people unfamiliar with " -"Python sometimes use a numerical counter instead::" -msgstr "" +"Python language, rather than implementing code using concepts common to other " +"languages. For example, a common idiom in Python is to loop over all elements " +"of an iterable using a :keyword:`for` statement. Many other languages don't " +"have this type of construct, so people unfamiliar with Python sometimes use a " +"numerical counter instead::" +msgstr "" +"Una idea o pieza de código que sigue ajustadamente la convenciones idiomáticas " +"comunes del lenguaje Python, en vez de implementar código usando conceptos " +"comunes a otros lenguajes. Por ejemplo, una convención común en Python es " +"hacer bucles sobre todos los elementos de un iterable con la sentencia :" +"keyword:`for`. Muchos otros lenguajes no tienen este tipo de construcción, " +"así que los que no están familiarizados con Python podrían usar contadores " +"numéricos::" #: ../Doc/glossary.rst:927 msgid "As opposed to the cleaner, Pythonic method::" -msgstr "" +msgstr "En contraste, un método Pythónico más limpio::" #: ../Doc/glossary.rst:931 msgid "qualified name" -msgstr "" +msgstr "nombre calificado" #: ../Doc/glossary.rst:933 msgid "" "A dotted name showing the \"path\" from a module's global scope to a class, " -"function or method defined in that module, as defined in :pep:`3155`. For " -"top-level functions and classes, the qualified name is the same as the " -"object's name::" +"function or method defined in that module, as defined in :pep:`3155`. For top-" +"level functions and classes, the qualified name is the same as the object's " +"name::" msgstr "" +"Un nombre con puntos mostrando la ruta desde el alcance global del módulo a la " +"clase, función o método definido en dicho módulo, como se define en :pep:" +"`3155`. Para las funciones o clases de más alto nivel, el nombre calificado " +"es el igual al nombre del objeto::" #: ../Doc/glossary.rst:950 msgid "" @@ -1615,38 +2204,49 @@ msgid "" "dotted path to the module, including any parent packages, e.g. ``email.mime." "text``::" msgstr "" +"Cuando es usado para referirse a los módulos, *nombre completamente " +"calificado* significa la ruta con puntos completo al módulo, incluyendo " +"cualquier paquete padre, por ejemplo, `email.mime.text``::" #: ../Doc/glossary.rst:957 msgid "reference count" -msgstr "" +msgstr "contador de referencias" #: ../Doc/glossary.rst:959 msgid "" -"The number of references to an object. When the reference count of an " -"object drops to zero, it is deallocated. Reference counting is generally " -"not visible to Python code, but it is a key element of the :term:`CPython` " +"The number of references to an object. When the reference count of an object " +"drops to zero, it is deallocated. Reference counting is generally not visible " +"to Python code, but it is a key element of the :term:`CPython` " "implementation. The :mod:`sys` module defines a :func:`~sys.getrefcount` " "function that programmers can call to return the reference count for a " "particular object." msgstr "" +"El número de referencias a un objeto. Cuando el contador de referencias de un " +"objeto cae hasta cero, éste es desalojable. En conteo de referencias no suele " +"ser visible en el código de Python, pero es un elemento clave para la " +"implementación de :term:`CPython`. El módulo :mod:`sys` define la :func:" +"`~sys.getrefcount` que los programadores pueden emplear para retornar el " +"conteo de referencias de un objeto en particular." #: ../Doc/glossary.rst:965 msgid "regular package" -msgstr "" +msgstr "paquete regular" #: ../Doc/glossary.rst:967 msgid "" "A traditional :term:`package`, such as a directory containing an ``__init__." "py`` file." msgstr "" +"Un :term:`package` tradicional, como aquellos con un directorio conteniendo " +"el archivo ``__init__.py``." #: ../Doc/glossary.rst:970 msgid "See also :term:`namespace package`." -msgstr "" +msgstr "Vea también :term:`namespace package`." #: ../Doc/glossary.rst:971 msgid "__slots__" -msgstr "" +msgstr "__slots__" #: ../Doc/glossary.rst:973 msgid "" @@ -1656,10 +2256,15 @@ msgid "" "cases where there are large numbers of instances in a memory-critical " "application." msgstr "" +"Es una declaración dentro de una clase que ahorra memoria pre declarando " +"espacio para las atributos de la instancia y eliminando diccionarios de la " +"instancia. Aunque es popular, esta técnica es algo dificultosa de lograr " +"correctamente y es mejor reservarla para los casos raros en los que existen " +"grandes cantidades de instancias en aplicaciones con uso crítico de memoria." #: ../Doc/glossary.rst:978 msgid "sequence" -msgstr "" +msgstr "secuencia" #: ../Doc/glossary.rst:980 msgid "" @@ -1671,6 +2276,14 @@ msgid "" "`__len__`, but is considered a mapping rather than a sequence because the " "lookups use arbitrary :term:`immutable` keys rather than integers." msgstr "" +"Un :term:`iterable` que logra un acceso eficiente a los elementos usando " +"índices enteros a través del método especial :meth:`__getitem__` y que define " +"un método :meth:`__len__` que devuelve la longitud de la secuencia. Algunas de " +"las secuencias incorporadas son :class:`list`, :class:`str`, :class:`tuple`, " +"y :class:`bytes`. Observe que :class:`dict` también soporta :meth:" +"`__getitem__` y :meth:`__len__`, pero es considerada un mapeo más que una " +"secuencia porque las búsquedas son por claves arbitraria :term:`immutable` y " +"no por enteros." #: ../Doc/glossary.rst:989 msgid "" @@ -1680,44 +2293,58 @@ msgid "" "meth:`__reversed__`. Types that implement this expanded interface can be " "registered explicitly using :func:`~abc.register`." msgstr "" +"La clase base abstracta :class:`collections.abc.Sequence` define una interfaz " +"mucho más rica que va más allá de sólo :meth:`__getitem__` y :meth:`__len__`, " +"agregando :meth:`count`, :meth:`index`, :meth:`__contains__`, y :meth:" +"`__reversed__`. Los tipos que implementan esta interfaz expandida pueden ser " +"registrados explícitamente usando :func:`~abc.register`." #: ../Doc/glossary.rst:996 msgid "single dispatch" -msgstr "" +msgstr "despacho único" #: ../Doc/glossary.rst:998 msgid "" -"A form of :term:`generic function` dispatch where the implementation is " -"chosen based on the type of a single argument." +"A form of :term:`generic function` dispatch where the implementation is chosen " +"based on the type of a single argument." msgstr "" +"Una forma de despacho de una :term:`generic function` donde la implementación " +"es elegida a partir del tipo de un sólo argumento." #: ../Doc/glossary.rst:1000 msgid "slice" -msgstr "" +msgstr "rebanada" #: ../Doc/glossary.rst:1002 msgid "" "An object usually containing a portion of a :term:`sequence`. A slice is " -"created using the subscript notation, ``[]`` with colons between numbers " -"when several are given, such as in ``variable_name[1:3:5]``. The bracket " +"created using the subscript notation, ``[]`` with colons between numbers when " +"several are given, such as in ``variable_name[1:3:5]``. The bracket " "(subscript) notation uses :class:`slice` objects internally." msgstr "" +"Un objeto que contiene una porción de una :term:`sequence`. Una rebanada es " +"creada usando la notación de suscripto, ``[]`` con dos puntos entre los " +"números cuando se ponen varios, como en ``nombre_variable[1:3:5]``. La " +"notación con corchete (suscrito) usa internamente objetos :class:`slice`." #: ../Doc/glossary.rst:1006 msgid "special method" -msgstr "" +msgstr "método especial" #: ../Doc/glossary.rst:1010 msgid "" -"A method that is called implicitly by Python to execute a certain operation " -"on a type, such as addition. Such methods have names starting and ending " -"with double underscores. Special methods are documented in :ref:" -"`specialnames`." +"A method that is called implicitly by Python to execute a certain operation on " +"a type, such as addition. Such methods have names starting and ending with " +"double underscores. Special methods are documented in :ref:`specialnames`." msgstr "" +"Un método que es llamado implícitamente por Python cuando ejecuta ciertas " +"operaciones en un tipo, como la adición. Estos métodos tienen nombres que " +"comienzan y terminan con doble barra baja. Los métodos especiales están " +"documentados en :ref:`specialnames`." #: ../Doc/glossary.rst:1014 msgid "statement" -msgstr "" +msgstr "sentencia" #: ../Doc/glossary.rst:1016 msgid "" @@ -1725,164 +2352,212 @@ msgid "" "an :term:`expression` or one of several constructs with a keyword, such as :" "keyword:`if`, :keyword:`while` or :keyword:`for`." msgstr "" +"Una sentencia es parte de un conjunto (un \"bloque\" de código). Una " +"sentencia tanto es una :term:`expression` como alguna de las varias sintaxis " +"usando una palabra clave, como :keyword:`if`, :keyword:`while` o :keyword:" +"`for`." #: ../Doc/glossary.rst:1019 msgid "struct sequence" -msgstr "" +msgstr "secuencias estructuradas" #: ../Doc/glossary.rst:1021 msgid "" -"A tuple with named elements. Struct sequences expose an interface similar " -"to :term:`named tuple` in that elements can be accessed either by index or " -"as an attribute. However, they do not have any of the named tuple methods " -"like :meth:`~collections.somenamedtuple._make` or :meth:`~collections." -"somenamedtuple._asdict`. Examples of struct sequences include :data:`sys." -"float_info` and the return value of :func:`os.stat`." -msgstr "" +"A tuple with named elements. Struct sequences expose an interface similar to :" +"term:`named tuple` in that elements can be accessed either by index or as an " +"attribute. However, they do not have any of the named tuple methods like :meth:" +"`~collections.somenamedtuple._make` or :meth:`~collections.somenamedtuple." +"_asdict`. Examples of struct sequences include :data:`sys.float_info` and the " +"return value of :func:`os.stat`." +msgstr "" +"Una tupla con elementos nombrados. Las secuencias estructuradas exponen una " +"interfaz similar a :term:`named tuple` ya que los elementos pueden ser " +"accedidos mediante un índice o como si fueran un atributo. Sin embargo, no " +"tienen ninguno de los métodos de las tuplas nombradas como :meth:`~collections." +"somenamedtuple._make` o :meth:`~collections.somenamedtuple._asdict`. Ejemplos " +"de secuencias estructuradas son :data:`sys.float_info` y el valor de retorno " +"de :func:`os.stat`." #: ../Doc/glossary.rst:1027 msgid "text encoding" -msgstr "" +msgstr "codificación de texto" #: ../Doc/glossary.rst:1029 msgid "A codec which encodes Unicode strings to bytes." -msgstr "" +msgstr "Un códec que codifica las cadenas Unicode a bytes." #: ../Doc/glossary.rst:1030 msgid "text file" -msgstr "" +msgstr "archivo de texto" #: ../Doc/glossary.rst:1032 msgid "" "A :term:`file object` able to read and write :class:`str` objects. Often, a " "text file actually accesses a byte-oriented datastream and handles the :term:" -"`text encoding` automatically. Examples of text files are files opened in " -"text mode (``'r'`` or ``'w'``), :data:`sys.stdin`, :data:`sys.stdout`, and " +"`text encoding` automatically. Examples of text files are files opened in text " +"mode (``'r'`` or ``'w'``), :data:`sys.stdin`, :data:`sys.stdout`, and " "instances of :class:`io.StringIO`." msgstr "" +"Un :term:`file object` capaz de leer y escribir objetos :class:`str`. " +"Frecuentemente, un archivo de texto también accede a un flujo de datos binario " +"y maneja automáticamente el :term:`text encoding`. Ejemplos de archivos de " +"texto que son abiertos en modo texto (``'r'`` o ``'w'``), :data:`sys.stdin`, :" +"data:`sys.stdout`, y las instancias de :class:`io.StringIO`." #: ../Doc/glossary.rst:1039 msgid "" "See also :term:`binary file` for a file object able to read and write :term:" "`bytes-like objects `." msgstr "" +"Vea también :term:`binary file` por objeto de archivos capaces de leer y " +"escribir :term:`objeto tipo binario `." #: ../Doc/glossary.rst:1041 msgid "triple-quoted string" -msgstr "" +msgstr "cadena con triple comilla" #: ../Doc/glossary.rst:1043 msgid "" -"A string which is bound by three instances of either a quotation mark (\") " -"or an apostrophe ('). While they don't provide any functionality not " -"available with single-quoted strings, they are useful for a number of " -"reasons. They allow you to include unescaped single and double quotes " -"within a string and they can span multiple lines without the use of the " -"continuation character, making them especially useful when writing " -"docstrings." +"A string which is bound by three instances of either a quotation mark (\") or " +"an apostrophe ('). While they don't provide any functionality not available " +"with single-quoted strings, they are useful for a number of reasons. They " +"allow you to include unescaped single and double quotes within a string and " +"they can span multiple lines without the use of the continuation character, " +"making them especially useful when writing docstrings." msgstr "" +"Una cadena que está enmarcada por tres instancias de comillas (\") o " +"apostrofes ('). Aunque no brindan ninguna funcionalidad que no está " +"disponible usando cadenas con comillas simple, son útiles por varias razones. " +"Permiten incluir comillas simples o dobles sin escapar dentro de las cadenas y " +"pueden abarcar múltiples líneas sin el uso de caracteres de continuación, " +"haciéndolas particularmente útiles para escribir docstrings." #: ../Doc/glossary.rst:1050 msgid "type" -msgstr "" +msgstr "tipo" #: ../Doc/glossary.rst:1052 msgid "" -"The type of a Python object determines what kind of object it is; every " -"object has a type. An object's type is accessible as its :attr:`~instance." -"__class__` attribute or can be retrieved with ``type(obj)``." +"The type of a Python object determines what kind of object it is; every object " +"has a type. An object's type is accessible as its :attr:`~instance.__class__` " +"attribute or can be retrieved with ``type(obj)``." msgstr "" +"El tipo de un objeto Python determina qué tipo de objeto es; cada objeto tiene " +"un tipo. El tipo de un objeto puede ser accedido por su atributo :attr:" +"`~instance.__class__` o puede ser conseguido usando ``type(obj)``." #: ../Doc/glossary.rst:1056 msgid "type alias" -msgstr "" +msgstr "alias de tipos" #: ../Doc/glossary.rst:1058 msgid "A synonym for a type, created by assigning the type to an identifier." -msgstr "" +msgstr "Un sinónimo para un tipo, creado al asignar un tipo a un identificador." #: ../Doc/glossary.rst:1060 msgid "" "Type aliases are useful for simplifying :term:`type hints `. For " "example::" msgstr "" +"Los alias de tipos son útiles para simplificar los :term:`indicadores de tipo " +"`. Por ejemplo::" #: ../Doc/glossary.rst:1069 msgid "could be made more readable like this::" -msgstr "" +msgstr "podría ser más legible así::" #: ../Doc/glossary.rst:1078 ../Doc/glossary.rst:1092 msgid "See :mod:`typing` and :pep:`484`, which describe this functionality." -msgstr "" +msgstr "Vea :mod:`typing` y :pep:`484`, que describen esta funcionalidad." #: ../Doc/glossary.rst:1079 msgid "type hint" -msgstr "" +msgstr "indicador de tipo" #: ../Doc/glossary.rst:1081 msgid "" -"An :term:`annotation` that specifies the expected type for a variable, a " -"class attribute, or a function parameter or return value." +"An :term:`annotation` that specifies the expected type for a variable, a class " +"attribute, or a function parameter or return value." msgstr "" +"Una :term:`annotation` que especifica el tipo esperado para una variable, un " +"atributo de clase, un parámetro para una función o un valor de retorno." #: ../Doc/glossary.rst:1084 msgid "" -"Type hints are optional and are not enforced by Python but they are useful " -"to static type analysis tools, and aid IDEs with code completion and " -"refactoring." +"Type hints are optional and are not enforced by Python but they are useful to " +"static type analysis tools, and aid IDEs with code completion and refactoring." msgstr "" +"Los indicadores de tipo son opcionales y no son obligados por Python pero son " +"útiles para las herramientas de análisis de tipos estático, y ayuda a las IDE " +"en el completado del código y la refactorización." #: ../Doc/glossary.rst:1088 msgid "" -"Type hints of global variables, class attributes, and functions, but not " -"local variables, can be accessed using :func:`typing.get_type_hints`." +"Type hints of global variables, class attributes, and functions, but not local " +"variables, can be accessed using :func:`typing.get_type_hints`." msgstr "" +"Los indicadores de tipo de las variables globales, atributos de clase, y " +"funciones, no de variables locales, pueden ser accedidos usando :func:`typing." +"get_type_hints`." #: ../Doc/glossary.rst:1093 msgid "universal newlines" -msgstr "" +msgstr "saltos de líneas universales" #: ../Doc/glossary.rst:1095 msgid "" "A manner of interpreting text streams in which all of the following are " "recognized as ending a line: the Unix end-of-line convention ``'\\n'``, the " -"Windows convention ``'\\r\\n'``, and the old Macintosh convention " -"``'\\r'``. See :pep:`278` and :pep:`3116`, as well as :func:`bytes." -"splitlines` for an additional use." +"Windows convention ``'\\r\\n'``, and the old Macintosh convention ``'\\r'``. " +"See :pep:`278` and :pep:`3116`, as well as :func:`bytes.splitlines` for an " +"additional use." msgstr "" +"Una manera de interpretar flujos de texto en la cual son reconocidos como " +"finales de línea todas siguientes formas: la convención de Unix para fin de " +"línea ``'\\n'``, la convención de Windows ``'\\r\\n'``, y la vieja convención " +"de Macintosh ``'\\r'``. Vea :pep:`278` y :pep:`3116`, además de:func:`bytes." +"splitlines` para usos adicionales." #: ../Doc/glossary.rst:1100 msgid "variable annotation" -msgstr "" +msgstr "anotación de variable" #: ../Doc/glossary.rst:1102 msgid "An :term:`annotation` of a variable or a class attribute." -msgstr "" +msgstr "Una :term:`annotation` de una variable o un atributo de clase." #: ../Doc/glossary.rst:1104 -msgid "" -"When annotating a variable or a class attribute, assignment is optional::" +msgid "When annotating a variable or a class attribute, assignment is optional::" msgstr "" +"Cuando se anota una variable o un atributo de clase, la asignación es " +"opcional::" #: ../Doc/glossary.rst:1109 msgid "" -"Variable annotations are usually used for :term:`type hints `: " -"for example this variable is expected to take :class:`int` values::" +"Variable annotations are usually used for :term:`type hints `: for " +"example this variable is expected to take :class:`int` values::" msgstr "" +"Las anotaciones de variables son frecuentemente usadas para :term:`type hints " +"`: por ejemplo, se espera que esta variable tenga valores de clase :" +"class:`int`::" #: ../Doc/glossary.rst:1115 msgid "Variable annotation syntax is explained in section :ref:`annassign`." msgstr "" +"La sintaxis de la anotación de variables está explicada en la sección :ref:" +"`annassign`." #: ../Doc/glossary.rst:1117 msgid "" "See :term:`function annotation`, :pep:`484` and :pep:`526`, which describe " "this functionality." msgstr "" +"Vea :term:`function annotation`, :pep:`484` y :pep:`526`, los cuales describen " +"esta funcionalidad." #: ../Doc/glossary.rst:1119 msgid "virtual environment" -msgstr "" +msgstr "entorno virtual" #: ../Doc/glossary.rst:1121 msgid "" @@ -1891,24 +2566,30 @@ msgid "" "interfering with the behaviour of other Python applications running on the " "same system." msgstr "" +"Un entorno cooperativamente aislado de ejecución que permite a los usuarios de " +"Python y a las aplicaciones instalar y actualizar paquetes de distribución de " +"Python sin interferir con el comportamiento de otras aplicaciones de Python en " +"el mismo sistema." #: ../Doc/glossary.rst:1126 msgid "See also :mod:`venv`." -msgstr "" +msgstr "Vea también :mod:`venv`." #: ../Doc/glossary.rst:1127 msgid "virtual machine" -msgstr "" +msgstr "máquina virtual" #: ../Doc/glossary.rst:1129 msgid "" "A computer defined entirely in software. Python's virtual machine executes " "the :term:`bytecode` emitted by the bytecode compiler." msgstr "" +"Una computadora definida enteramente por software. La máquina virtual de " +"Python ejecuta el :term:`bytecode` generado por el compilador de bytecode." #: ../Doc/glossary.rst:1131 msgid "Zen of Python" -msgstr "" +msgstr "Zen de Python" #: ../Doc/glossary.rst:1133 msgid "" @@ -1916,3 +2597,6 @@ msgid "" "understanding and using the language. The listing can be found by typing " "\"``import this``\" at the interactive prompt." msgstr "" +"Un listado de los principios de diseño y la filosofía de Python que son útiles " +"para entender y usar el lenguaje. El listado puede encontrarse ingresando " +"\"``import this``\" en la consola interactiva." diff --git a/scripts/find_in_po.py b/scripts/find_in_po.py old mode 100644 new mode 100755 index d38d306cef..f0744aad19 --- a/scripts/find_in_po.py +++ b/scripts/find_in_po.py @@ -5,9 +5,9 @@ import os from textwrap import fill -import regex -import polib -from tabulate import tabulate +import regex # fades +import polib # fades +from tabulate import tabulate # fades def find_in_po(pattern): @@ -22,9 +22,10 @@ def find_in_po(pattern): pofile = polib.pofile(file) for entry in pofile: if entry.msgstr and regex.search(pattern, entry.msgid): + add_str = entry.msgstr + " ·filename: " + file + "·" table.append( [ - fill(entry.msgid, width=available_width), + fill(add_str, width=available_width), fill(entry.msgstr, width=available_width), ] )