functional.po

# Copyright (C) 2001-2020, Python Software Foundation
# This file is distributed under the same license as the Python package.
# Maintained by the python-doc-es workteam.
# docs-es@python.org /
# https://mail.python.org/mailman3/lists/docs-es.python.org/
# Check https://github.com/python/python-docs-es/blob/3.8/TRANSLATORS to
# get the list of volunteers
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.8\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2022-10-25 19:47+0200\n"
"PO-Revision-Date: 2021-10-22 10:38-0500\n"
"Last-Translator: Kevin Cajachuán <kevincajachuan@hotmail.com>\n"
"Language: es\n"
"Language-Team: python-doc-es\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.10.3\n"

#: ../Doc/howto/functional.rst:3
msgid "Functional Programming HOWTO"
msgstr "HOWTO - Programación funcional"

#: ../Doc/howto/functional.rst
msgid "Author"
msgstr "Autor"

#: ../Doc/howto/functional.rst:5
msgid "A. M. Kuchling"
msgstr "A. M. Kuchling"

#: ../Doc/howto/functional.rst
msgid "Release"
msgstr "Publicación"

#: ../Doc/howto/functional.rst:6
msgid "0.32"
msgstr "0.32"

#: ../Doc/howto/functional.rst:8
msgid ""
"In this document, we'll take a tour of Python's features suitable for "
"implementing programs in a functional style.  After an introduction to the "
"concepts of functional programming, we'll look at language features such as :"
"term:`iterator`\\s and :term:`generator`\\s and relevant library modules "
"such as :mod:`itertools` and :mod:`functools`."
msgstr ""
"En este documento, haremos un recorrido de las características de Python "
"adecuadas para implementar programas en un estilo funcional. Después de una "
"introducción de los conceptos de programación funcional, veremos las "
"características del lenguaje como :term:`iterador <iterator>`\\es y :term:"
"`generador <generator>`\\es y módulos de librería relevantes como :mod:"
"`itertools` y :mod:`functools`."

#: ../Doc/howto/functional.rst:16
msgid "Introduction"
msgstr "Introducción"

#: ../Doc/howto/functional.rst:18
msgid ""
"This section explains the basic concept of functional programming; if you're "
"just interested in learning about Python language features, skip to the next "
"section on :ref:`functional-howto-iterators`."
msgstr ""
"Esta sección explica el concepto básico de programación funcional; si solo "
"está interesado en aprender acerca de las características del lenguaje "
"Python, pase a la siguiente sección en :ref:`iteradores <functional-howto-"
"iterators>`."

#: ../Doc/howto/functional.rst:22
msgid ""
"Programming languages support decomposing problems in several different ways:"
msgstr ""
"Los lenguajes de programación soportan la descomposición de problemas en "
"muchas formas diferentes:"

#: ../Doc/howto/functional.rst:24
msgid ""
"Most programming languages are **procedural**: programs are lists of "
"instructions that tell the computer what to do with the program's input.  C, "
"Pascal, and even Unix shells are procedural languages."
msgstr ""
"La mayoría de los lenguajes de programación son **procedimentales**: los "
"programas son listas de instrucciones que le dicen a la computadora qué "
"hacer con la entrada del programa. C, Pascal e incluso las terminales Unix "
"son lenguajes procedimentales."

#: ../Doc/howto/functional.rst:28
msgid ""
"In **declarative** languages, you write a specification that describes the "
"problem to be solved, and the language implementation figures out how to "
"perform the computation efficiently.  SQL is the declarative language you're "
"most likely to be familiar with; a SQL query describes the data set you want "
"to retrieve, and the SQL engine decides whether to scan tables or use "
"indexes, which subclauses should be performed first, etc."
msgstr ""
"En los lenguajes **declarativos**, se escribe una especificación que "
"describe el problema que se resolverá, y la implementación del lenguaje "
"averigua como realizar el cálculo de forma eficiente. SQL es el lenguaje "
"declarativo con el que probablemente esté más familiarizado; una consulta "
"SQL describe el conjunto de datos que quiere recuperar, y el motor SQL "
"decide si escanear tablas o usar índices, qué subcláusulas deben ejecutarse "
"primero, etc."

#: ../Doc/howto/functional.rst:35
msgid ""
"**Object-oriented** programs manipulate collections of objects.  Objects "
"have internal state and support methods that query or modify this internal "
"state in some way. Smalltalk and Java are object-oriented languages.  C++ "
"and Python are languages that support object-oriented programming, but don't "
"force the use of object-oriented features."
msgstr ""
"Los programas **orientados a objetos** manipulan colecciones de objetos. Los "
"objetos tienen estado interno y soportan métodos que consultan o modifican "
"su estado interno de alguna manera. Smalltalk y Java son lenguajes "
"orientados a objetos. C++ y Python son lenguajes que soportan la "
"programación orientada a objetos, pero no fuerzan el uso de las "
"características orientadas a objetos."

#: ../Doc/howto/functional.rst:41
msgid ""
"**Functional** programming decomposes a problem into a set of functions. "
"Ideally, functions only take inputs and produce outputs, and don't have any "
"internal state that affects the output produced for a given input.  Well-"
"known functional languages include the ML family (Standard ML, OCaml, and "
"other variants) and Haskell."
msgstr ""
"La programación **funcional** descompone un problema en un conjunto de "
"funciones. Idealmente, las funciones solo reciben entradas y producen "
"salidas, y no tienen ningún estado interno que afecte la salida producida "
"para una entrada dada. Los lenguajes funcionales bien conocidos incluyen la "
"familia ML (Standard ML, OCaml, y otras variantes) y Haskell."

#: ../Doc/howto/functional.rst:47
msgid ""
"The designers of some computer languages choose to emphasize one particular "
"approach to programming.  This often makes it difficult to write programs "
"that use a different approach.  Other languages are multi-paradigm languages "
"that support several different approaches. Lisp, C++, and Python are multi-"
"paradigm; you can write programs or libraries that are largely procedural, "
"object-oriented, or functional in all of these languages.  In a large "
"program, different sections might be written using different approaches; the "
"GUI might be object-oriented while the processing logic is procedural or "
"functional, for example."
msgstr ""
"Los diseñadores de algunos lenguajes de computadora eligen enfatizar en un "
"enfoque particular para programar. Esto a menudo hace difícil escribir "
"programas que usen un enfoque diferente. Otros lenguajes son lenguajes "
"multiparadigma que soportan varios enfoques diferentes. Lisp, C++ y Python "
"son multiparadigma; puede escribir programas o librerías que son en gran "
"parte procedimentales, orientados a objetos o funcionales en todos estos "
"lenguajes. En un programa grande, las diferentes secciones podrían "
"escribirse usando diferentes enfoques; la GUI podría ser orientada a objetos "
"mientras la lógica de procesamiento es procedimental o funcional, por "
"ejemplo."

#: ../Doc/howto/functional.rst:58
msgid ""
"In a functional program, input flows through a set of functions. Each "
"function operates on its input and produces some output.  Functional style "
"discourages functions with side effects that modify internal state or make "
"other changes that aren't visible in the function's return value.  Functions "
"that have no side effects at all are called **purely functional**.  Avoiding "
"side effects means not using data structures that get updated as a program "
"runs; every function's output must only depend on its input."
msgstr ""
"En un programa funcional, la entrada fluye a través de un conjunto de "
"funciones. Cada función opera sobre su entrada y produce alguna salida. El "
"estilo funcional desalienta las funciones con efectos secundarios que "
"modifican el estado interno o hacen otros cambios que no son visibles en el "
"valor de retorno de la función. Las funciones que no tienen ningún efecto "
"secundario se llaman **puramente funcionales**. Evitar los efectos "
"secundarios significa no usar estructuras de datos que se actualicen "
"mientras se ejecuta un programa; cada salida de la función debe depender "
"solo de su entrada."

#: ../Doc/howto/functional.rst:66
msgid ""
"Some languages are very strict about purity and don't even have assignment "
"statements such as ``a=3`` or ``c = a + b``, but it's difficult to avoid all "
"side effects, such as printing to the screen or writing to a disk file. "
"Another example is a call to the :func:`print` or :func:`time.sleep` "
"function, neither of which returns a useful value. Both are called only for "
"their side effects of sending some text to the screen or pausing execution "
"for a second."
msgstr ""
"Algunos lenguajes son demasiado estrictos y ni siquiera tienen declaraciones "
"de asignación como ``a=3`` o ``c = a + b``, pero es difícil evitar todos los "
"efectos secundarios, como imprimir en pantalla o escribir en un archivo de "
"disco. Otro ejemplo es llamar a las funciones :func:`print` o :func:`time."
"sleep`, ninguna de las dos retorna un valor útil, ambas son llamadas solo "
"por sus efectos secundarios de enviar texto a la pantalla o pausar la "
"ejecución por un segundo."

#: ../Doc/howto/functional.rst:73
msgid ""
"Python programs written in functional style usually won't go to the extreme "
"of avoiding all I/O or all assignments; instead, they'll provide a "
"functional-appearing interface but will use non-functional features "
"internally. For example, the implementation of a function will still use "
"assignments to local variables, but won't modify global variables or have "
"other side effects."
msgstr ""
"Los programas de Python escritos en estilo funcional usualmente no irán al "
"extremo de evitar todas las E/S o todas las asignaciones; en cambio, "
"proveerán una interfaz aparentemente funcional pero internamente usará "
"características no funcionales. Por ejemplo, la implementación de una "
"función todavía usará asignaciones a variables locales, pero no modificará "
"variables globales ni tendrá otros efectos secundarios."

#: ../Doc/howto/functional.rst:79
msgid ""
"Functional programming can be considered the opposite of object-oriented "
"programming.  Objects are little capsules containing some internal state "
"along with a collection of method calls that let you modify this state, and "
"programs consist of making the right set of state changes.  Functional "
"programming wants to avoid state changes as much as possible and works with "
"data flowing between functions.  In Python you might combine the two "
"approaches by writing functions that take and return instances representing "
"objects in your application (e-mail messages, transactions, etc.)."
msgstr ""
"La programación funcional se puede considerar lo opuesto a la programación "
"orientada a objetos. Los objetos son pequeñas capsulas que contienen algún "
"estado interno junto con una colección de llamadas a métodos que le permiten "
"modificar este estado, y los programas consisten en realizar el conjunto "
"correcto de cambios de estado. La programación funcional quiere evitar "
"cambios de estado tanto como sea posible y trabaja con flujos de datos entre "
"funciones. En Python podría combinar los dos enfoques para escribir "
"funciones que reciban y retornen instancias que representen objetos en su "
"aplicación (mensajes de e-mail, transacciones, etc.)."

#: ../Doc/howto/functional.rst:88
msgid ""
"Functional design may seem like an odd constraint to work under.  Why should "
"you avoid objects and side effects?  There are theoretical and practical "
"advantages to the functional style:"
msgstr ""
"El diseño funcional puede parecer una restricción extraña bajo la cuál "
"trabajar. ¿Por qué evitaría objetos y efectos secundarios? Hay ventajas "
"teóricas y prácticas para el estilo funcional:"

#: ../Doc/howto/functional.rst:92
msgid "Formal provability."
msgstr "Demostrabilidad formal."

#: ../Doc/howto/functional.rst:93
msgid "Modularity."
msgstr "Modularidad."

#: ../Doc/howto/functional.rst:94
msgid "Composability."
msgstr "Componibilidad."

#: ../Doc/howto/functional.rst:95
msgid "Ease of debugging and testing."
msgstr "Facilidad de depurar y probar."

#: ../Doc/howto/functional.rst:99
msgid "Formal provability"
msgstr "Demostrabilidad formal"

#: ../Doc/howto/functional.rst:101
msgid ""
"A theoretical benefit is that it's easier to construct a mathematical proof "
"that a functional program is correct."
msgstr ""
"Un beneficio teórico es que es más fácil construir una demostración "
"matemática de que un programa funcional es correcto."

#: ../Doc/howto/functional.rst:104
msgid ""
"For a long time researchers have been interested in finding ways to "
"mathematically prove programs correct.  This is different from testing a "
"program on numerous inputs and concluding that its output is usually "
"correct, or reading a program's source code and concluding that the code "
"looks right; the goal is instead a rigorous proof that a program produces "
"the right result for all possible inputs."
msgstr ""
"Por un largo tiempo los investigadores se han interesado en buscar formas de "
"demostrar matemáticamente que los programas son correctos. Esto es diferente "
"de probar un programa sobre numerosas entradas y concluir que su salida es "
"usualmente correcta, o leer el código fuente de un programa y concluir que "
"el código se ve bien; en lugar de eso el objetivo es una demostración "
"rigurosa de que un programa produce el resultado correcto para todas las "
"entradas posibles."

#: ../Doc/howto/functional.rst:111
msgid ""
"The technique used to prove programs correct is to write down "
"**invariants**, properties of the input data and of the program's variables "
"that are always true.  For each line of code, you then show that if "
"invariants X and Y are true **before** the line is executed, the slightly "
"different invariants X' and Y' are true **after** the line is executed.  "
"This continues until you reach the end of the program, at which point the "
"invariants should match the desired conditions on the program's output."
msgstr ""
"La técnica utilizada para demostrar que los programas son correctos es "
"anotar **invariantes**, propiedades de los datos de entrada y de las "
"variables del programa que siempre son verdaderas. Por cada línea de código, "
"debe mostrar que si las invariantes X e Y son verdaderas **antes** que la "
"línea sea ejecutada, las invariantes ligeramente diferentes X' e Y' son "
"verdaderas **después** que la línea se ejecutó. Esto continúa hasta que "
"alcance el fin del programa, punto en el cuál las invariantes deben "
"coincidir con las condiciones deseadas en la salida del programa."

#: ../Doc/howto/functional.rst:119
msgid ""
"Functional programming's avoidance of assignments arose because assignments "
"are difficult to handle with this technique; assignments can break "
"invariants that were true before the assignment without producing any new "
"invariants that can be propagated onward."
msgstr ""
"La evitación de las asignaciones de la programación funcional surge porque "
"las asignaciones son difíciles de manejar con esta técnica; las asignaciones "
"pueden romper invariantes que eran verdaderas antes de la asignación sin "
"producir nuevas invariantes que se puedan propagar hacia adelante."

#: ../Doc/howto/functional.rst:124
msgid ""
"Unfortunately, proving programs correct is largely impractical and not "
"relevant to Python software. Even trivial programs require proofs that are "
"several pages long; the proof of correctness for a moderately complicated "
"program would be enormous, and few or none of the programs you use daily "
"(the Python interpreter, your XML parser, your web browser) could be proven "
"correct.  Even if you wrote down or generated a proof, there would then be "
"the question of verifying the proof; maybe there's an error in it, and you "
"wrongly believe you've proved the program correct."
msgstr ""
"Desafortunadamente, demostrar que los programas son correctos es en gran "
"parte impráctico y no relevante al software de Python. Incluso los programas "
"triviales requieren demostraciones que tienen varias páginas; la "
"demostración de correctitud para un programa moderadamente complicado sería "
"enorme, y pocos o ninguno de los programas que usa diariamente (el "
"interprete de Python, su analizador XML, su navegador web) se podrían "
"demostrar que son correctos. Aún si anotó o generó una demostración, "
"entonces estaría la cuestión de verificar la demostración; quizás hay un "
"error en ella, y equivocadamente cree que demostró que el programa es "
"correcto."

#: ../Doc/howto/functional.rst:135
msgid "Modularity"
msgstr "Modularidad"

#: ../Doc/howto/functional.rst:137
msgid ""
"A more practical benefit of functional programming is that it forces you to "
"break apart your problem into small pieces.  Programs are more modular as a "
"result.  It's easier to specify and write a small function that does one "
"thing than a large function that performs a complicated transformation.  "
"Small functions are also easier to read and to check for errors."
msgstr ""
"Un beneficio más práctico de la programación funcional es que fuerza a "
"romper su problema en pequeñas piezas. Como resultado los programas son más "
"modulares. Es más fácil especificar y escribir una función pequeña que hace "
"una cosa que una función grande que realiza una transformación complicada. "
"Las funciones pequeñas también son más fáciles de leer y comprobar si hay "
"errores."

#: ../Doc/howto/functional.rst:145
msgid "Ease of debugging and testing"
msgstr "Facilidad de depurar y probar"

#: ../Doc/howto/functional.rst:147
msgid "Testing and debugging a functional-style program is easier."
msgstr "Probar y depurar un programa en estilo funcional es más fácil."

#: ../Doc/howto/functional.rst:149
msgid ""
"Debugging is simplified because functions are generally small and clearly "
"specified.  When a program doesn't work, each function is an interface point "
"where you can check that the data are correct.  You can look at the "
"intermediate inputs and outputs to quickly isolate the function that's "
"responsible for a bug."
msgstr ""
"La depuración se simplifica porque las funciones generalmente son pequeñas y "
"claramente especificadas. Cuando un programa no funciona, cada función es un "
"punto de interfaz donde puede comprobar si los datos son correctos. Puede "
"ver las entradas y salidas intermedias para aislar rápidamente la función "
"que es responsable de un error."

#: ../Doc/howto/functional.rst:154
msgid ""
"Testing is easier because each function is a potential subject for a unit "
"test. Functions don't depend on system state that needs to be replicated "
"before running a test; instead you only have to synthesize the right input "
"and then check that the output matches expectations."
msgstr ""
"Las pruebas son más fáciles porque cada función es un sujeto potencial para "
"una prueba unitaria. Las funciones no dependen de un estado del sistema que "
"necesite ser replicado antes de correr una prueba; en lugar de eso solo "
"tiene que sintetizar la entrada correcta y comprobar que la salida coincida "
"con las expectativas."

#: ../Doc/howto/functional.rst:161
msgid "Composability"
msgstr "Componibilidad"

#: ../Doc/howto/functional.rst:163
msgid ""
"As you work on a functional-style program, you'll write a number of "
"functions with varying inputs and outputs.  Some of these functions will be "
"unavoidably specialized to a particular application, but others will be "
"useful in a wide variety of programs.  For example, a function that takes a "
"directory path and returns all the XML files in the directory, or a function "
"that takes a filename and returns its contents, can be applied to many "
"different situations."
msgstr ""
"Mientras trabaja en un programa en estilo funcional, escribirá un número de "
"funciones con diferentes entradas y salidas. Algunas de estas funciones "
"inevitablemente estarán especializadas en una aplicación en particular, pero "
"otras serán útiles en una amplia variedad de programas. Por ejemplo, una "
"función que recibe la ruta de un directorio y retorna todos los archivos XML "
"en el directorio, o una función que recibe el nombre de un archivo y retorna "
"su contenido, se puede aplicar a muchas situaciones diferentes."

#: ../Doc/howto/functional.rst:170
msgid ""
"Over time you'll form a personal library of utilities.  Often you'll "
"assemble new programs by arranging existing functions in a new configuration "
"and writing a few functions specialized for the current task."
msgstr ""
"Con el tiempo formará una librería personal de utilidades. A menudo "
"ensamblará nuevos programas organizando funciones existentes en una nueva "
"configuración y escribiendo unas pocas funciones especializadas para la "
"tarea actual."

#: ../Doc/howto/functional.rst:178
msgid "Iterators"
msgstr "Iteradores"

#: ../Doc/howto/functional.rst:180
msgid ""
"I'll start by looking at a Python language feature that's an important "
"foundation for writing functional-style programs: iterators."
msgstr ""
"Comenzaré viendo una característica del lenguaje Python que es una base "
"importante para escribir programas en estilo funcional: iteradores."

#: ../Doc/howto/functional.rst:183
msgid ""
"An iterator is an object representing a stream of data; this object returns "
"the data one element at a time.  A Python iterator must support a method "
"called :meth:`~iterator.__next__` that takes no arguments and always returns "
"the next element of the stream.  If there are no more elements in the "
"stream, :meth:`~iterator.__next__` must raise the :exc:`StopIteration` "
"exception. Iterators don't have to be finite, though; it's perfectly "
"reasonable to write an iterator that produces an infinite stream of data."
msgstr ""
"Un iterador es un objeto que representa un flujo de datos; este objeto "
"retorna los datos de a un elemento a la vez. Un iterador de Python debe "
"soportar un método llamado :meth:`~iterator.__next__` que no recibe "
"argumentos y siempre retorna el siguiente elemento en el flujo. Si no hay "
"más elementos en el flujo, :meth:`~iterator.__next__` debe lanzar la "
"excepción :exc:`StopIteration`. Los iteradores no tienen que ser finitos; es "
"perfectamente razonable escribir un iterador que produce un flujo de datos "
"infinito."

#: ../Doc/howto/functional.rst:191
msgid ""
"The built-in :func:`iter` function takes an arbitrary object and tries to "
"return an iterator that will return the object's contents or elements, "
"raising :exc:`TypeError` if the object doesn't support iteration.  Several "
"of Python's built-in data types support iteration, the most common being "
"lists and dictionaries.  An object is called :term:`iterable` if you can get "
"an iterator for it."
msgstr ""
"La función incorporada :func:`iter` recibe un objeto arbitrario e intenta "
"retornar un iterador que retornará los contenidos o elementos del objeto, "
"lanzando :exc:`TypeError` si el objeto no soporta iteración. Muchos tipos de "
"datos integrados de Python soportan iteración, siendo los más comunes las "
"listas y los diccionarios. Un objeto se llama :term:`iterable` si puede "
"obtener un iterador para él."

#: ../Doc/howto/functional.rst:198
msgid "You can experiment with the iteration interface manually:"
msgstr "Puede experimentar con la interfaz de iteración manualmente:"

#: ../Doc/howto/functional.rst:216
msgid ""
"Python expects iterable objects in several different contexts, the most "
"important being the :keyword:`for` statement.  In the statement ``for X in "
"Y``, Y must be an iterator or some object for which :func:`iter` can create "
"an iterator.  These two statements are equivalent::"
msgstr ""
"Python espera objetos iterables en muchos contextos diferentes, siendo el "
"más importante la sentencia :keyword:`for`. En la sentencia ``for X in Y``, "
"Y debe ser un iterador o algún objeto para el que :func:`iter` puede crear "
"un iterador. Estas dos sentencias son equivalentes::"

#: ../Doc/howto/functional.rst:228
msgid ""
"Iterators can be materialized as lists or tuples by using the :func:`list` "
"or :func:`tuple` constructor functions:"
msgstr ""
"Los iteradores se pueden materializar como listas o tuplas utilizando las "
"funciones constructoras :func:`list` o :func:`tuple`:"

#: ../Doc/howto/functional.rst:237
msgid ""
"Sequence unpacking also supports iterators: if you know an iterator will "
"return N elements, you can unpack them into an N-tuple:"
msgstr ""
"El desempaquetado de secuencias también soporta iteradores: si sabe que un "
"iterador retornará N elementos, puede desempaquetarlos en una N-tupla:"

#: ../Doc/howto/functional.rst:246
msgid ""
"Built-in functions such as :func:`max` and :func:`min` can take a single "
"iterator argument and will return the largest or smallest element.  The "
"``\"in\"`` and ``\"not in\"`` operators also support iterators: ``X in "
"iterator`` is true if X is found in the stream returned by the iterator.  "
"You'll run into obvious problems if the iterator is infinite; :func:`max`, :"
"func:`min` will never return, and if the element X never appears in the "
"stream, the ``\"in\"`` and ``\"not in\"`` operators won't return either."
msgstr ""
"Las funciones incorporadas como :func:`max` y :func:`min` pueden recibir un "
"solo iterador como argumento y retornarán el elemento más grande o más "
"pequeño. Los operadores ``\"in\"`` y ``\"not in\"`` también soportan "
"iteradores: ``X in iterator`` es verdadero si X se encuentra en el flujo que "
"retornó el iterador. Se encontrará con problemas obvios si el iterador es "
"infinito; :func:`max`, :func:`min` nunca retornarán, y si el elemento X "
"nunca aparece en el flujo, los operadores ``\"in\"`` y ``\"not in\"`` "
"tampoco retornarán."

#: ../Doc/howto/functional.rst:254
msgid ""
"Note that you can only go forward in an iterator; there's no way to get the "
"previous element, reset the iterator, or make a copy of it.  Iterator "
"objects can optionally provide these additional capabilities, but the "
"iterator protocol only specifies the :meth:`~iterator.__next__` method.  "
"Functions may therefore consume all of the iterator's output, and if you "
"need to do something different with the same stream, you'll have to create a "
"new iterator."
msgstr ""
"Note que solo puede ir hacia adelante en un iterador; no hay forma de "
"obtener el elemento anterior, reiniciar el iterador o hacer una copia de él. "
"Los objetos iteradores opcionalmente pueden proveer estas capacidades "
"adicionales, pero el protocolo del iterador solo especifica el método :meth:"
"`~iterator.__next__`. Por lo tanto las funciones pueden consumir toda la "
"salida del iterador, y si necesita hacer algo diferente con el mismo flujo, "
"tendrá que crear un nuevo iterador."

#: ../Doc/howto/functional.rst:264
msgid "Data Types That Support Iterators"
msgstr "Tipos de datos que soportan iteradores"

#: ../Doc/howto/functional.rst:266
msgid ""
"We've already seen how lists and tuples support iterators.  In fact, any "
"Python sequence type, such as strings, will automatically support creation "
"of an iterator."
msgstr ""
"Ya hemos visto cómo las listas y tuplas soportan iteradores. De hecho, "
"cualquier tipo de secuencia de Python, como cadenas de caracteres, "
"automáticamente soportará la creación de un iterador."

#: ../Doc/howto/functional.rst:270
msgid ""
"Calling :func:`iter` on a dictionary returns an iterator that will loop over "
"the dictionary's keys::"
msgstr ""
"Llamar a :func:`iter` en un diccionario retornará un iterador que recorrerá "
"sobre las claves del diccionario::"

#: ../Doc/howto/functional.rst:290
msgid ""
"Note that starting with Python 3.7, dictionary iteration order is guaranteed "
"to be the same as the insertion order. In earlier versions, the behaviour "
"was unspecified and could vary between implementations."
msgstr ""
"Note que a partir de Python 3.7, se garantiza que el orden de iteración del "
"diccionario es el mismo que el orden de inserción. En versiones anteriores, "
"el comportamiento no estaba especificado y podía variar entre "
"implementaciones."

#: ../Doc/howto/functional.rst:294
msgid ""
"Applying :func:`iter` to a dictionary always loops over the keys, but "
"dictionaries have methods that return other iterators.  If you want to "
"iterate over values or key/value pairs, you can explicitly call the :meth:"
"`~dict.values` or :meth:`~dict.items` methods to get an appropriate iterator."
msgstr ""
"Aplicar :func:`iter` a un diccionario siempre recorre sobre las claves, pero "
"los diccionarios tienen métodos que retornan otros iteradores. Si quiere "
"iterar sobre valores o pares clave/valor, puede explícitamente llamar a los "
"métodos :meth:`~dict.values` o :meth:`~dict.items` para obtener un iterador "
"apropiado."

#: ../Doc/howto/functional.rst:300
msgid ""
"The :func:`dict` constructor can accept an iterator that returns a finite "
"stream of ``(key, value)`` tuples:"
msgstr ""
"El constructor :func:`dict` puede aceptar un iterador que retorna un flujo "
"finito de tuplas ``(key, value)``:"

#: ../Doc/howto/functional.rst:307
msgid ""
"Files also support iteration by calling the :meth:`~io.TextIOBase.readline` "
"method until there are no more lines in the file.  This means you can read "
"each line of a file like this::"
msgstr ""
"Los archivos también soportan iteración llamando al método :meth:`~io."
"TextIOBase.readline` hasta que no haya más líneas en el archivo. Esto "
"significa que puede leer cada línea de un archivo de esta forma::"

#: ../Doc/howto/functional.rst:315
msgid ""
"Sets can take their contents from an iterable and let you iterate over the "
"set's elements::"
msgstr ""
"Los conjuntos pueden recibir sus contenidos de un iterable y le permiten "
"iterar sobre los elementos del conjunto::"

#: ../Doc/howto/functional.rst:331
msgid "Generator expressions and list comprehensions"
msgstr "Expresiones generadoras y listas por comprensión"

#: ../Doc/howto/functional.rst:333
msgid ""
"Two common operations on an iterator's output are 1) performing some "
"operation for every element, 2) selecting a subset of elements that meet "
"some condition. For example, given a list of strings, you might want to "
"strip off trailing whitespace from each line or extract all the strings "
"containing a given substring."
msgstr ""
"Dos operaciones comunes en la salida de un iterador son 1) realizar alguna "
"operación para cada elemento, 2) elegir un subconjunto de elementos que "
"reúnen alguna condición. Por ejemplo, dada una lista de cadena de "
"caracteres, podría querer remover los espacios finales de cada línea o "
"extraer todas las cadenas de caracteres que contienen una subcadena de "
"caracteres dada."

#: ../Doc/howto/functional.rst:339
msgid ""
"List comprehensions and generator expressions (short form: \"listcomps\" and "
"\"genexps\") are a concise notation for such operations, borrowed from the "
"functional programming language Haskell (https://www.haskell.org/).  You can "
"strip all the whitespace from a stream of strings with the following code::"
msgstr ""
"Las listas por comprensión y las expresiones generadoras (forma abreviada: "
"\"listcomps\" y \"genexps\") son una notación concisa para tales "
"operaciones, prestadas del lenguaje de programación funcional Haskell "
"(https://www.haskell.org/). Puede remover todos los espacios de un flujo de "
"cadena de caracteres con el siguiente código::"

#: ../Doc/howto/functional.rst:352
msgid ""
"You can select only certain elements by adding an ``\"if\"`` condition::"
msgstr ""
"Puede seleccionar solo ciertos elementos agregando una condición ``\"if\"``::"

#: ../Doc/howto/functional.rst:357
msgid ""
"With a list comprehension, you get back a Python list; ``stripped_list`` is "
"a list containing the resulting lines, not an iterator.  Generator "
"expressions return an iterator that computes the values as necessary, not "
"needing to materialize all the values at once.  This means that list "
"comprehensions aren't useful if you're working with iterators that return an "
"infinite stream or a very large amount of data.  Generator expressions are "
"preferable in these situations."
msgstr ""
"Con una lista por comprensión, obtiene una lista de Python; "
"``stripped_list`` es una lista que contiene las líneas resultantes, no un "
"iterador. Las expresiones generadoras retornan un iterador que calcula los "
"valores cuando es necesario, sin necesidad de materializar todos los valores "
"a la vez. Esto significa que las listas por comprensión son inútiles si está "
"trabajando con iteradores que retornan un flujo infinito o una gran cantidad "
"de datos. En estas situaciones son preferibles las expresiones generadoras."

#: ../Doc/howto/functional.rst:364
msgid ""
"Generator expressions are surrounded by parentheses (\"()\") and list "
"comprehensions are surrounded by square brackets (\"[]\").  Generator "
"expressions have the form::"
msgstr ""
"Las expresiones generadoras están rodeadas por paréntesis (\"()\") y las "
"listas por comprensión están rodeadas por corchetes (\"[]\"). Las "
"expresiones generadoras tienen la forma::"

#: ../Doc/howto/functional.rst:378
msgid ""
"Again, for a list comprehension only the outside brackets are different "
"(square brackets instead of parentheses)."
msgstr ""
"Nuevamente, para una lista por comprensión solo los corchetes exteriores son "
"diferentes (corchetes en lugar de paréntesis)."

#: ../Doc/howto/functional.rst:381
msgid ""
"The elements of the generated output will be the successive values of "
"``expression``.  The ``if`` clauses are all optional; if present, "
"``expression`` is only evaluated and added to the result when ``condition`` "
"is true."
msgstr ""
"Los elementos de la salida generada serán valores sucesivos de "
"``expression``. Las cláusulas ``if`` son todas opcionales; si está presente, "
"``expression`` es solo evaluado y añadido al resultado cuando ``condition`` "
"es verdadero."

#: ../Doc/howto/functional.rst:385
msgid ""
"Generator expressions always have to be written inside parentheses, but the "
"parentheses signalling a function call also count.  If you want to create an "
"iterator that will be immediately passed to a function you can write::"
msgstr ""
"Las expresiones generadoras siempre se tienen que escribir dentro de "
"paréntesis, pero los paréntesis que indican la llamada a una función también "
"cuentan. Si quiere crear un iterador que se pase inmediatamente a una "
"función puede escribir::"

#: ../Doc/howto/functional.rst:391
msgid ""
"The ``for...in`` clauses contain the sequences to be iterated over.  The "
"sequences do not have to be the same length, because they are iterated over "
"from left to right, **not** in parallel.  For each element in ``sequence1``, "
"``sequence2`` is looped over from the beginning.  ``sequence3`` is then "
"looped over for each resulting pair of elements from ``sequence1`` and "
"``sequence2``."
msgstr ""
"Las cláusulas ``for...in`` contienen las secuencias sobre las que se itera. "
"Las secuencias no tienen que tener la misma longitud, porque son iteradas de "
"izquierda a derecha, **no** en paralelo. Por cada elemento en ``sequence1``, "
"se recorre ``sequence2`` desde el inicio. Luego se recorre ``sequence3`` por "
"cada par de elementos resultante de ``sequence1`` y ``sequence2``."

#: ../Doc/howto/functional.rst:397
msgid ""
"To put it another way, a list comprehension or generator expression is "
"equivalent to the following Python code::"
msgstr ""
"Para ponerlo en otra forma, una lista por comprensión o expresión generadora "
"es equivalente al siguiente código Python::"

#: ../Doc/howto/functional.rst:414
msgid ""
"This means that when there are multiple ``for...in`` clauses but no ``if`` "
"clauses, the length of the resulting output will be equal to the product of "
"the lengths of all the sequences.  If you have two lists of length 3, the "
"output list is 9 elements long:"
msgstr ""
"Esto significa que cuando hay múltiples cláusulas ``for...in`` pero no "
"cláusulas ``if``, la longitud de la salida resultante será igual al producto "
"de las longitudes de todas las secuencias. Si tiene dos listas de longitud "
"3, la lista de salida tendrá 9 elementos:"

#: ../Doc/howto/functional.rst:426
msgid ""
"To avoid introducing an ambiguity into Python's grammar, if ``expression`` "
"is creating a tuple, it must be surrounded with parentheses.  The first list "
"comprehension below is a syntax error, while the second one is correct::"
msgstr ""
"Para evitar introducir una ambigüedad en la gramática de Python, si "
"``expression`` está creando una tupla, debe estar rodeada de paréntesis. La "
"primera lista por comprensión de abajo tiene un error de sintaxis, mientras "
"que la segunda es correcta::"

#: ../Doc/howto/functional.rst:437
msgid "Generators"
msgstr "Generadores"

#: ../Doc/howto/functional.rst:439
msgid ""
"Generators are a special class of functions that simplify the task of "
"writing iterators.  Regular functions compute a value and return it, but "
"generators return an iterator that returns a stream of values."
msgstr ""
"Los generadores son una clase especial de funciones que simplifican la tarea "
"de escribir iteradores. Las funciones regulares calculan un valor y lo "
"retornan, pero los generadores retornan un iterador que retorna un flujo de "
"valores."

#: ../Doc/howto/functional.rst:443
msgid ""
"You're doubtless familiar with how regular function calls work in Python or "
"C. When you call a function, it gets a private namespace where its local "
"variables are created.  When the function reaches a ``return`` statement, "
"the local variables are destroyed and the value is returned to the caller.  "
"A later call to the same function creates a new private namespace and a "
"fresh set of local variables. But, what if the local variables weren't "
"thrown away on exiting a function?  What if you could later resume the "
"function where it left off?  This is what generators provide; they can be "
"thought of as resumable functions."
msgstr ""
"Sin duda está relacionado con cómo funcionan las llamadas a funciones "
"regulares en Python o C. Cuando llama a una función, esta obtiene su espacio "
"de nombres privado donde se crean sus variables locales. Cuando la función "
"alcanza una sentencia ``return``, las variables locales son destruidas y el "
"valor se retorna al llamador. Una llamada posterior a la misma función crea "
"un nuevo espacio de nombres privado y un conjunto limpio de variables "
"locales. Pero, ¿qué pasa si las variables locales no fueron desechadas en la "
"salida de una función? ¿Qué pasa si más tarde podría reanudar la función "
"desde donde quedó? Esto es lo que proveen los generadores; se pueden pensar "
"como funciones que se reanudan."

#: ../Doc/howto/functional.rst:452
msgid "Here's the simplest example of a generator function:"
msgstr "Este es el ejemplo más simple de una función generadora:"

#: ../Doc/howto/functional.rst:458
msgid ""
"Any function containing a :keyword:`yield` keyword is a generator function; "
"this is detected by Python's :term:`bytecode` compiler which compiles the "
"function specially as a result."
msgstr ""
"Cualquier función que contiene una palabra clave :keyword:`yield` es una "
"función generadora; esto es detectado por el compilador :term:`bytecode` de "
"Python que compila la función de forma especial como resultado."

#: ../Doc/howto/functional.rst:462
msgid ""
"When you call a generator function, it doesn't return a single value; "
"instead it returns a generator object that supports the iterator protocol.  "
"On executing the ``yield`` expression, the generator outputs the value of "
"``i``, similar to a ``return`` statement.  The big difference between "
"``yield`` and a ``return`` statement is that on reaching a ``yield`` the "
"generator's state of execution is suspended and local variables are "
"preserved.  On the next call to the generator's :meth:`~generator.__next__` "
"method, the function will resume executing."
msgstr ""
"Cuando llama a una función generadora, no retorna un solo valor; en lugar de "
"eso retorna un objeto generador que soporta el protocolo iterador. Al "
"ejecutar la expresión ``yield``, el generador produce el valor de ``i``, de "
"forma similar a una sentencia ``return``. La gran diferencia entre una "
"sentencia ``yield`` y un ``return`` es que al alcanzar un ``yield`` se "
"suspende el estado de ejecución del generador y se preservan las variables "
"locales. En la próxima llamada al método :meth:`~generator.__next__` del "
"generador, la función reanudará la ejecución."

#: ../Doc/howto/functional.rst:471
msgid "Here's a sample usage of the ``generate_ints()`` generator:"
msgstr "Este es un ejemplo de uso del generador ``generate_ints()``:"

#: ../Doc/howto/functional.rst:488
msgid ""
"You could equally write ``for i in generate_ints(5)``, or ``a, b, c = "
"generate_ints(3)``."
msgstr ""
"De igual forma podría escribir ``for i in generate_ints(5)``, o ``a, b, c = "
"generate_ints(3)``."

#: ../Doc/howto/functional.rst:491
msgid ""
"Inside a generator function, ``return value`` causes "
"``StopIteration(value)`` to be raised from the :meth:`~generator.__next__` "
"method.  Once this happens, or the bottom of the function is reached, the "
"procession of values ends and the generator cannot yield any further values."
msgstr ""
"Dentro de una función generadora, ``return value`` causa que se lance "
"``StopIteration(value)`` del método :meth:`~generator.__next__`\\. Una vez "
"que esto pase, o que se alcance el final de la función, termina la procesión "
"de valores y el generador no puede producir más valores."

#: ../Doc/howto/functional.rst:496
msgid ""
"You could achieve the effect of generators manually by writing your own "
"class and storing all the local variables of the generator as instance "
"variables.  For example, returning a list of integers could be done by "
"setting ``self.count`` to 0, and having the :meth:`~iterator.__next__` "
"method increment ``self.count`` and return it. However, for a moderately "
"complicated generator, writing a corresponding class can be much messier."
msgstr ""
"Podría lograr el efecto de los generadores manualmente escribiendo su propia "
"clase y guardando todas las variables locales del generador como variables "
"de instancia. Por ejemplo, retornar una lista de enteros se podría hacer "
"estableciendo ``self.count`` a 0, y teniendo el método :meth:`~iterator."
"__next__` que incrementa ``self.count`` y lo retorna. Sin embargo, para un "
"generador moderadamente complicado, escribir una clase correspondiente puede "
"ser mucho más confuso."

#: ../Doc/howto/functional.rst:504
msgid ""
"The test suite included with Python's library, :source:`Lib/test/"
"test_generators.py`, contains a number of more interesting examples.  Here's "
"one generator that implements an in-order traversal of a tree using "
"generators recursively. ::"
msgstr ""
"El banco de pruebas incluido con la librería de Python, :source:`Lib/test/"
"test_generators.py`, contiene un número de ejemplos más interesantes. Este "
"es un generador que implementa un recorrido inorden de un árbol usando "
"generadores recursivamente. ::"

#: ../Doc/howto/functional.rst:520
msgid ""
"Two other examples in ``test_generators.py`` produce solutions for the N-"
"Queens problem (placing N queens on an NxN chess board so that no queen "
"threatens another) and the Knight's Tour (finding a route that takes a "
"knight to every square of an NxN chessboard without visiting any square "
"twice)."
msgstr ""
"Otros dos ejemplos en ``test_generators.py`` producen soluciones al problema "
"de N-reinas (ubicar N reinas en un tablero de ajedrez de NxN de forma que "
"ninguna reina amenace a otra) y el problema del caballo (encontrar una ruta "
"que lleve a un caballo a cada cuadro de un tablero de ajedrez de NxN sin "
"visitar ningún cuadro dos veces)."

#: ../Doc/howto/functional.rst:528
msgid "Passing values into a generator"
msgstr "Pasar valores a un generador"

#: ../Doc/howto/functional.rst:530
msgid ""
"In Python 2.4 and earlier, generators only produced output.  Once a "
"generator's code was invoked to create an iterator, there was no way to pass "
"any new information into the function when its execution is resumed.  You "
"could hack together this ability by making the generator look at a global "
"variable or by passing in some mutable object that callers then modify, but "
"these approaches are messy."
msgstr ""
"En Python 2.4 y anteriores, los generadores solo producían salida. Una vez "
"que el código de un generador era invocado para crear un iterador, no había "
"forma de pasar ninguna información nueva a la función cuando se reanuda su "
"ejecución. Podría lograr esta habilidad haciendo que el generador mire una "
"variable global o pasando en algún objeto mutable que el llamador luego "
"modifica, pero estos enfoques son confusos."

#: ../Doc/howto/functional.rst:537
msgid ""
"In Python 2.5 there's a simple way to pass values into a generator. :keyword:"
"`yield` became an expression, returning a value that can be assigned to a "
"variable or otherwise operated on::"
msgstr ""
"En Python 2.5 hay una forma más simple de pasar valores a un generador. :"
"keyword:`yield` se convirtió en una expresión, retornando un valor que se "
"puede asignar a una variable o sobre el que se puede operar::"

#: ../Doc/howto/functional.rst:543
msgid ""
"I recommend that you **always** put parentheses around a ``yield`` "
"expression when you're doing something with the returned value, as in the "
"above example. The parentheses aren't always necessary, but it's easier to "
"always add them instead of having to remember when they're needed."
msgstr ""
"Recomiendo que **siempre** ponga paréntesis alrededor de una expresión "
"``yield`` cuando esté haciendo algo con el valor retornado, como en el "
"ejemplo de arriba. Los paréntesis no siempre son necesarios, pero siempre es "
"más fácil agregarlos en lugar de tener que recordar cuándo son necesarios."

#: ../Doc/howto/functional.rst:548
msgid ""
"(:pep:`342` explains the exact rules, which are that a ``yield``-expression "
"must always be parenthesized except when it occurs at the top-level "
"expression on the right-hand side of an assignment.  This means you can "
"write ``val = yield i`` but have to use parentheses when there's an "
"operation, as in ``val = (yield i) + 12``.)"
msgstr ""
"(:pep:`342` explica las reglas exactas, que son que una expresión ``yield`` "
"siempre debe estar entre paréntesis excepto cuando se encuentra en la "
"expresión de primer nivel en el lado derecho de una asignación. Esto "
"significa que puede escribir ``val = yield i`` pero tiene que usar "
"paréntesis cuando hay una operación, como en ``val = (yield i) + 12``.)"

#: ../Doc/howto/functional.rst:554
msgid ""
"Values are sent into a generator by calling its :meth:`send(value) "
"<generator.send>` method.  This method resumes the generator's code and the "
"``yield`` expression returns the specified value.  If the regular :meth:"
"`~generator.__next__` method is called, the ``yield`` returns ``None``."
msgstr ""
"Los valores son enviados a un generador llamando a su método :meth:"
"`send(value) <generator.send>`. Este método reanuda el código del generador "
"y la expresión ``yield`` retorna el valor especificado. Si se llama al "
"método regular :meth:`~generator.__next__`, ``yield`` retorna ``None``."

#: ../Doc/howto/functional.rst:559
msgid ""
"Here's a simple counter that increments by 1 and allows changing the value "
"of the internal counter."
msgstr ""
"Este es un simple contador que incrementa por 1 y permite cambiar los "
"valores del contador interno."

#: ../Doc/howto/functional.rst:574
msgid "And here's an example of changing the counter:"
msgstr "Y este es un ejemplo del cambio del contador:"

#: ../Doc/howto/functional.rst:591
msgid ""
"Because ``yield`` will often be returning ``None``, you should always check "
"for this case.  Don't just use its value in expressions unless you're sure "
"that the :meth:`~generator.send` method will be the only method used to "
"resume your generator function."
msgstr ""
"Como ``yield`` a menudo retornará ``None``, siempre debería comprobar este "
"caso. No use simplemente su valor en expresiones a menos que esté seguro que "
"el método :meth:`~generator.send` será el único método utilizado para "
"reanudar su función generadora."

#: ../Doc/howto/functional.rst:596
msgid ""
"In addition to :meth:`~generator.send`, there are two other methods on "
"generators:"
msgstr ""
"Además del método :meth:`~generator.send`, hay otros dos métodos para "
"generadores:"