# 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-12-11 15:36-0300\n"

"Last-Translator: Juan C. Tello <juanctello@gmail.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/faq/programming.rst:5

msgid "Programming FAQ"

msgstr "Preguntas frecuentes de programación"

#: ../Doc/faq/programming.rst:8

msgid "Contents"

msgstr "Contenido"

#: ../Doc/faq/programming.rst:12

msgid "General Questions"

msgstr "Preguntas generales"

#: ../Doc/faq/programming.rst:15

msgid ""

"Is there a source code level debugger with breakpoints, single-stepping, "

"etc.?"

msgstr ""

"¿Existe un depurador a nivel de código fuente con puntos de interrupción, "

"depuración paso a paso, etc?"

#: ../Doc/faq/programming.rst:17 ../Doc/faq/programming.rst:57

msgid "Yes."

msgstr "Sí."

#: ../Doc/faq/programming.rst:19

msgid ""

"Several debuggers for Python are described below, and the built-in function :"

"func:`breakpoint` allows you to drop into any of them."

msgstr ""

"Debajo se describen algunos depuradores para Python y la función integrada :"

"func:`breakpoint` te permite ejecutar alguno de ellos."

#: ../Doc/faq/programming.rst:22

msgid ""

"The pdb module is a simple but adequate console-mode debugger for Python. It "

"is part of the standard Python library, and is :mod:`documented in the "

"Library Reference Manual <pdb>`. You can also write your own debugger by "

"using the code for pdb as an example."

msgstr ""

"El módulo pdb es en depurador en modo consola simple pero conveniente para "

"Python. Es parte de la biblioteca estándar de Python y está :mod:"

"`documentado en el manual de referencia de la biblioteca <pdb>`. Puedes "

"escribir tu propio depurador usando el código de pdb como ejemplo."

#: ../Doc/faq/programming.rst:27

msgid ""

"The IDLE interactive development environment, which is part of the standard "

"Python distribution (normally available as Tools/scripts/idle), includes a "

"graphical debugger."

msgstr ""

"El entorno interactivo de desarrollo IDLE, el cual es parte de la "

"distribución Python estándar (disponible, generalmente, como Tools/scripts/"

"idle), incluye un depurador gráfico."

#: ../Doc/faq/programming.rst:31

msgid ""

"PythonWin is a Python IDE that includes a GUI debugger based on pdb. The "

"PythonWin debugger colors breakpoints and has quite a few cool features such "

"as debugging non-PythonWin programs. PythonWin is available as part of "

"`pywin32 <https://github.com/mhammond/pywin32>`_ project and as a part of "

"the `ActivePython <https://www.activestate.com/products/python/>`_ "

"distribution."

msgstr ""

"PythonWin es un IDE Python que incluye un depurador con GUI basado en pdb. "

"El depurador PythonWin colorea los puntos de interrupción y dispone de "

"características geniales como la depuración de programas no modificados "

"mediante PythonWin. PythonWin está disponible como parte del proyecto `Las "

"extensiones de Python para Windows <https://sourceforge.net/ projects/"

"pywin32/>`_ y como parte de la distribución `ActivePython <https://www."

"activestate.com/activepython>`."

#: ../Doc/faq/programming.rst:38

#, fuzzy

msgid ""

"`Eric <https://eric-ide.python-projects.org/>`_ is an IDE built on PyQt and "

"the Scintilla editing component."

msgstr ""

"`Eric <http://eric-ide.python-projects.org/>`_ es un IDE creado usando PyQt "

"y el componente de edición Scintilla."

#: ../Doc/faq/programming.rst:41

msgid ""

"`trepan3k <https://github.com/rocky/python3-trepan/>`_ is a gdb-like "

"debugger."

msgstr ""

"`trepan3k <https://github.com/rocky/python3-trepan/>`_ es un depurador "

"similar a `gdb`."

#: ../Doc/faq/programming.rst:43

msgid ""

"`Visual Studio Code <https://code.visualstudio.com/>`_ is an IDE with "

"debugging tools that integrates with version-control software."

msgstr ""

"`Visual Studio Code <https://code.visualstudio.com/>`_ es un IDE con "

"herramientas de depuración que se integra con software de control de "

"versiones."

#: ../Doc/faq/programming.rst:46

msgid ""

"There are a number of commercial Python IDEs that include graphical "

"debuggers. They include:"

msgstr ""

"Existen varios IDEs comerciales para Python que incluyen depuradores "

"gráficos. Entre ellos tenemos:"

#: ../Doc/faq/programming.rst:49

msgid "`Wing IDE <https://wingware.com/>`_"

msgstr "`IDE Wing <https://wingware.com/>`_"

#: ../Doc/faq/programming.rst:50

msgid "`Komodo IDE <https://www.activestate.com/products/komodo-ide/>`_"

msgstr "`IDE Komodo <https://www.activestate.com/products/komodo-ide/>`_"

#: ../Doc/faq/programming.rst:51

msgid "`PyCharm <https://www.jetbrains.com/pycharm/>`_"

msgstr "`PyCharm <https://www.jetbrains.com/pycharm/>`_"

#: ../Doc/faq/programming.rst:55

msgid "Are there tools to help find bugs or perform static analysis?"

msgstr ""

"¿Existe alguna herramienta que ayude a encontrar errores o realizar análisis "

"estático?"

#: ../Doc/faq/programming.rst:59

#, fuzzy

msgid ""

"`Pylint <https://pylint.pycqa.org/en/latest/index.html>`_ and `Pyflakes "

"<https://github.com/PyCQA/pyflakes>`_ do basic checking that will help you "

"catch bugs sooner."

msgstr ""

"`Pylint <https://www.pylint.org/>`_ y `Pyflakes <https://github.com/PyCQA/"

"pyflakes>`_ realizan comprobaciones básicas que le ayudarán a detectar "

"errores antes."

#: ../Doc/faq/programming.rst:63

msgid ""

"Static type checkers such as `Mypy <http://mypy-lang.org/>`_, `Pyre <https://"

"pyre-check.org/>`_, and `Pytype <https://github.com/google/pytype>`_ can "

"check type hints in Python source code."

msgstr ""

"Inspectores estáticos de tipos como `Mypy <http://mypy-lang.org/>`_, `Pyre "

"<https://pyre-check.org/>`_, y `Pytype <https://github.com/google/pytype>`_ "

"pueden hacer comprobaciones de las anotaciones de tipos en código fuente "

"Python."

#: ../Doc/faq/programming.rst:72

msgid "How can I create a stand-alone binary from a Python script?"

msgstr ""

"¿Cómo puedo crear un binario independiente a partir de un programa Python?"

#: ../Doc/faq/programming.rst:74

msgid ""

"You don't need the ability to compile Python to C code if all you want is a "

"stand-alone program that users can download and run without having to "

"install the Python distribution first. There are a number of tools that "

"determine the set of modules required by a program and bind these modules "

"together with a Python binary to produce a single executable."

msgstr ""

"No necesitas tener la habilidad de compilar Python a código C si lo único "

"que necesitas es un programa independiente que los usuarios puedan descargar "

"y ejecutar sin necesidad de instalar primero una distribución Python. Existe "

"una serie de herramientas que determinan el conjunto de módulos que necesita "

"un programa y une estos módulos conjuntamente con un binario Python para "

"generar un único ejecutable."

#: ../Doc/faq/programming.rst:80

#, fuzzy

msgid ""

"One is to use the freeze tool, which is included in the Python source tree "

"as ``Tools/freeze``. It converts Python byte code to C arrays; with a C "

"compiler you can embed all your modules into a new program, which is then "

"linked with the standard Python modules."

msgstr ""

"Una forma es usando la herramienta *freeze*, la cual viene incluida con el "

"árbol de código Python como ``Tools/freeze``. Convierte el byte code Python "

"a arrays C; un compilador C permite incrustar todos tus módulos en un nuevo "

"programa que, posteriormente se puede enlazar con los módulos estándar de "

"Python."

#: ../Doc/faq/programming.rst:85

msgid ""

"It works by scanning your source recursively for import statements (in both "

"forms) and looking for the modules in the standard Python path as well as in "

"the source directory (for built-in modules). It then turns the bytecode for "

"modules written in Python into C code (array initializers that can be turned "

"into code objects using the marshal module) and creates a custom-made config "

"file that only contains those built-in modules which are actually used in "

"the program. It then compiles the generated C code and links it with the "

"rest of the Python interpreter to form a self-contained binary which acts "

"exactly like your script."

msgstr ""

"Funciona escaneando su fuente de forma recursiva en busca de declaraciones "

"de importación (en ambas formas) y buscando los módulos en la ruta estándar "

"de Python, así como en el directorio de la fuente (para los módulos "

"incorporados). Luego convierte el *bytecode* de los módulos escritos en "

"Python en código C (inicializadores de arrays que pueden ser convertidos en "

"objetos de código usando el módulo marshal) y crea un archivo de "

"configuración a medida que sólo contiene aquellos módulos incorporados que "

"se usan realmente en el programa. A continuación, compila el código C "

"generado y lo enlaza con el resto del intérprete de Python para formar un "

"binario autónomo que actúa exactamente igual que su script."

#: ../Doc/faq/programming.rst:94

msgid ""

"The following packages can help with the creation of console and GUI "

"executables:"

msgstr ""

"Los siguientes paquetes pueden ayudar con la creación de ejecutables de "

"consola y GUI:"

#: ../Doc/faq/programming.rst:97

msgid "`Nuitka <https://nuitka.net/>`_ (Cross-platform)"

msgstr "`Nuitka <https://nuitka.net/>`_ (Multiplataforma)"

#: ../Doc/faq/programming.rst:98

#, fuzzy

msgid "`PyInstaller <https://pyinstaller.org/>`_ (Cross-platform)"

msgstr "`PyInstaller <http://www.pyinstaller.org/>`_ (Multiplataforma)"

#: ../Doc/faq/programming.rst:99

msgid ""

"`PyOxidizer <https://pyoxidizer.readthedocs.io/en/stable/>`_ (Cross-platform)"

msgstr ""

"`PyOxidizer <https://pyoxidizer.readthedocs.io/en/stable/>`_ "

"(Multiplataforma)"

#: ../Doc/faq/programming.rst:100

msgid ""

"`cx_Freeze <https://marcelotduarte.github.io/cx_Freeze/>`_ (Cross-platform)"

msgstr ""

"`cx_Freeze <https://marcelotduarte.github.io/cx_Freeze/>`_ (Multiplataforma)"

#: ../Doc/faq/programming.rst:101

msgid "`py2app <https://github.com/ronaldoussoren/py2app>`_ (macOS only)"

msgstr "`py2app <https://github.com/ronaldoussoren/py2app>`_ (macOS solamente)"

#: ../Doc/faq/programming.rst:102

#, fuzzy

msgid "`py2exe <https://www.py2exe.org/>`_ (Windows only)"

msgstr "`py2exe <http://www.py2exe.org/>`_ (solo Windows)"

#: ../Doc/faq/programming.rst:105

msgid "Are there coding standards or a style guide for Python programs?"

msgstr ""

"¿Existen estándares de código o una guía de estilo para programas Python?"

#: ../Doc/faq/programming.rst:107

msgid ""

"Yes. The coding style required for standard library modules is documented "

"as :pep:`8`."

msgstr ""

"Sí. El estilo de código requerido para los módulos de la biblioteca estándar "

"se encuentra documentado como :pep:`8`."

#: ../Doc/faq/programming.rst:112

msgid "Core Language"

msgstr "Núcleo del lenguaje"

#: ../Doc/faq/programming.rst:115

msgid "Why am I getting an UnboundLocalError when the variable has a value?"

msgstr ""

"¿Por qué obtengo un *UnboundLocalError* cuando la variable tiene un valor?"

#: ../Doc/faq/programming.rst:117

msgid ""

"It can be a surprise to get the UnboundLocalError in previously working code "

"when it is modified by adding an assignment statement somewhere in the body "

"of a function."

msgstr ""

"Puede ser una sorpresa el hecho de obtener un UnboundLocalError en código "

"que había estado funcionando previamente cuando se modifica mediante el "

"añadido de una declaración de asignación en alguna parte del cuerpo de una "

"función."

#: ../Doc/faq/programming.rst:121

msgid "This code:"

msgstr "Este código:"

#: ../Doc/faq/programming.rst:129

msgid "works, but this code:"

msgstr "funciona, pero este código:"

#: ../Doc/faq/programming.rst:136

msgid "results in an UnboundLocalError:"

msgstr "resulta en un UnboundLocalError:"

#: ../Doc/faq/programming.rst:143

msgid ""

"This is because when you make an assignment to a variable in a scope, that "

"variable becomes local to that scope and shadows any similarly named "

"variable in the outer scope. Since the last statement in foo assigns a new "

"value to ``x``, the compiler recognizes it as a local variable. "

"Consequently when the earlier ``print(x)`` attempts to print the "

"uninitialized local variable and an error results."

msgstr ""

"Esto es debido a que cuando realizas una asignación a una variable en un "

"ámbito de aplicación, esa variable se convierte en local y enmascara "

"cualquier variable llamada de forma similar en un ámbito de aplicación "

"exterior. Desde la última declaración en foo asigna un nuevo valor a ``x``, "

"el compilador la reconoce como una variable local. Consecuentemente, cuando "

"el ``print(x)`` más próximo intenta mostrar la variable local no "

"inicializada se muestra un error."

#: ../Doc/faq/programming.rst:150

msgid ""

"In the example above you can access the outer scope variable by declaring it "

"global:"

msgstr ""

"En el ejemplo anterior puedes acceder al ámbito de aplicación exterior a la "

"variable declarándola como global:"

#: ../Doc/faq/programming.rst:161

msgid ""

"This explicit declaration is required in order to remind you that (unlike "

"the superficially analogous situation with class and instance variables) you "

"are actually modifying the value of the variable in the outer scope:"

msgstr ""

"Esta declaración explícita es necesaria de cara a recordarte que (a "

"diferencia de la situación superficialmente análoga con las variables de "

"clase e instancia) estás modificando el valor de la variable en un ámbito de "

"aplicación más externo:"

#: ../Doc/faq/programming.rst:168

msgid ""

"You can do a similar thing in a nested scope using the :keyword:`nonlocal` "

"keyword:"

msgstr ""

"Puedes hacer algo similar en un ámbito de aplicación anidado usando la "

"palabra clave :keyword:`nonlocal`:"

#: ../Doc/faq/programming.rst:185

msgid "What are the rules for local and global variables in Python?"

msgstr ""

"¿Cuáles son las reglas para las variables locales y globales en Python?"

#: ../Doc/faq/programming.rst:187

msgid ""

"In Python, variables that are only referenced inside a function are "

"implicitly global. If a variable is assigned a value anywhere within the "

"function's body, it's assumed to be a local unless explicitly declared as "

"global."

msgstr ""

"En Python, las variables que solo se encuentran referenciadas dentro de una "

"función son globales implícitamente. Si a una variable se le asigna un "

"valor en cualquier lugar dentro del cuerpo de una función, se asumirá que es "

"local a no ser que explícitamente se la declare como global."

#: ../Doc/faq/programming.rst:191

msgid ""

"Though a bit surprising at first, a moment's consideration explains this. "

"On one hand, requiring :keyword:`global` for assigned variables provides a "

"bar against unintended side-effects. On the other hand, if ``global`` was "

"required for all global references, you'd be using ``global`` all the time. "

"You'd have to declare as global every reference to a built-in function or to "

"a component of an imported module. This clutter would defeat the usefulness "

"of the ``global`` declaration for identifying side-effects."

msgstr ""

"Aunque, inicialmente, puede parecer sorprendente, un momento de "

"consideración permite explicar esto. Por una parte, requerir :keyword:"

"`global` para variables asignadas proporciona una barrera frente a efectos "

"secundarios indeseados. Por otra parte, si ``global`` es requerido para "

"todas las referencias globales, deberás usar ``global`` en todo momento. "

"Deberías declarar como global cualquier referencia a una función integrada o "

"a un componente de un módulo importado. Este embrollo arruinaría la utilidad "

"de la declaración \"global\" para identificar los efectos secundarios."

#: ../Doc/faq/programming.rst:201

msgid ""

"Why do lambdas defined in a loop with different values all return the same "

"result?"

msgstr ""

"¿Por qué las funciones lambda definidas en un bucle con diferentes valores "

"devuelven todas el mismo resultado?"

#: ../Doc/faq/programming.rst:203

msgid ""

"Assume you use a for loop to define a few different lambdas (or even plain "

"functions), e.g.::"

msgstr ""

"Considera que usas un bucle *for* para crear unas pocas funciones lambda (o, "

"incluso, funciones normales), por ejemplo.::"

#: ../Doc/faq/programming.rst:210

msgid ""

"This gives you a list that contains 5 lambdas that calculate ``x**2``. You "

"might expect that, when called, they would return, respectively, ``0``, "

"``1``, ``4``, ``9``, and ``16``. However, when you actually try you will "

"see that they all return ``16``::"

msgstr ""

"Lo siguiente proporciona una lista que contiene 5 funciones lambda que "

"calculan ``x**2``. Esperarías que, cuando se les invoca, retornaran, "

"respectivamente, ``0``, ``1``, ``4``, ``9``y ``16``. Sin embargo, cuando lo "

"ejecutes verás que todas devuelven ``16``::"

#: ../Doc/faq/programming.rst:220

msgid ""

"This happens because ``x`` is not local to the lambdas, but is defined in "

"the outer scope, and it is accessed when the lambda is called --- not when "

"it is defined. At the end of the loop, the value of ``x`` is ``4``, so all "

"the functions now return ``4**2``, i.e. ``16``. You can also verify this by "

"changing the value of ``x`` and see how the results of the lambdas change::"

msgstr ""

"Esto sucede porque ``x`` no es una función lambda local pero se encuentra "

"definida en un ámbito de aplicación externo y se accede cuando la lambda es "

"invocada --- no cuando ha sido definida. Al final del bucle, el valor de "

"``x`` es ``4``, por tanto, ahora todas las funciones devuelven ``4**2``, i."

"e. ``16``. También puedes verificar esto mediante el cambio del valor de "

"``x`` y ver como los resultados de las lambdas cambian::"

#: ../Doc/faq/programming.rst:230

msgid ""

"In order to avoid this, you need to save the values in variables local to "

"the lambdas, so that they don't rely on the value of the global ``x``::"

msgstr ""

"De cara a evitar esto necesitas guardar los valores en variables locales a "

"las funciones lambda de tal forma que no dependan del valor de la ``x`` "

"global::"

#: ../Doc/faq/programming.rst:237

msgid ""

"Here, ``n=x`` creates a new variable ``n`` local to the lambda and computed "

"when the lambda is defined so that it has the same value that ``x`` had at "

"that point in the loop. This means that the value of ``n`` will be ``0`` in "

"the first lambda, ``1`` in the second, ``2`` in the third, and so on. "

"Therefore each lambda will now return the correct result::"

msgstr ""

"Aquí, ``n=x`` crea una nueva variable ``n`` local a la función lambda y "

"ejecutada cuando la función lambda se define de tal forma que tiene el mismo "

"valor que tenía ``x`` en ese punto en el bucle. Esto significa que el valor "

"de ``n`` será ``0`` en la primera función lambda, ``1`` en la segunda, ``2`` "

"en la tercera y así sucesivamente. Por tanto, ahora cada lambda retornará el "

"resultado correcto::"

#: ../Doc/faq/programming.rst:248

msgid ""

"Note that this behaviour is not peculiar to lambdas, but applies to regular "

"functions too."

msgstr ""

"Es de destacar que este comportamiento no es peculiar de las funciones "

"lambda sino que aplica también a las funciones regulares."

#: ../Doc/faq/programming.rst:253

msgid "How do I share global variables across modules?"

msgstr "¿Cómo puedo compartir variables globales entre módulos?"

#: ../Doc/faq/programming.rst:255

msgid ""

"The canonical way to share information across modules within a single "

"program is to create a special module (often called config or cfg). Just "

"import the config module in all modules of your application; the module then "

"becomes available as a global name. Because there is only one instance of "

"each module, any changes made to the module object get reflected "

"everywhere. For example:"

msgstr ""

"La forma canónica de compartir información entre módulos dentro de un mismo "

"programa sería creando un módulo especial (a menudo llamado config o cfg). "

"Simplemente importa el módulo config en todos los módulos de tu aplicación; "

"el módulo estará disponible como un nombre global. Debido a que solo hay "

"una instancia de cada módulo, cualquier cambio hecho en el objeto módulo se "

"reflejará en todos los sitios. Por ejemplo:"

#: ../Doc/faq/programming.rst:261

msgid "config.py::"

msgstr "config.py::"

#: ../Doc/faq/programming.rst:265

msgid "mod.py::"

msgstr "mod.py::"

#: ../Doc/faq/programming.rst:270

msgid "main.py::"

msgstr "main.py::"

#: ../Doc/faq/programming.rst:276

msgid ""

"Note that using a module is also the basis for implementing the Singleton "

"design pattern, for the same reason."

msgstr ""

"Ten en cuenta que usar un módulo es también la base para la implementación "

"del patrón de diseño Singleton, por la misma razón."

#: ../Doc/faq/programming.rst:281

msgid "What are the \"best practices\" for using import in a module?"

msgstr "¿Cuáles son las \"buenas prácticas\" para usar import en un módulo?"

#: ../Doc/faq/programming.rst:283

msgid ""

"In general, don't use ``from modulename import *``. Doing so clutters the "

"importer's namespace, and makes it much harder for linters to detect "

"undefined names."

msgstr ""

"En general, no uses ``from modulename import *``. Haciendo eso embarulla el "

"espacio de nombres del importador y hace que sea más difícil para los "

"*linters* el detectar los nombres sin definir."

#: ../Doc/faq/programming.rst:287

msgid ""

"Import modules at the top of a file. Doing so makes it clear what other "

"modules your code requires and avoids questions of whether the module name "

"is in scope. Using one import per line makes it easy to add and delete "

"module imports, but using multiple imports per line uses less screen space."

msgstr ""

"Importar los módulos en la parte inicial del fichero. Haciéndolo así deja "

"claro los módulos que son necesarios para tu código y evita preguntas sobre "

"si el nombre del módulo se encuentra en el ámbito de la aplicación. Usar una "

"importación por línea hace que sea sencillo añadir y eliminar módulos "

"importados pero usar múltiples importaciones por línea usa menos espacio de "

"pantalla."

#: ../Doc/faq/programming.rst:292

msgid "It's good practice if you import modules in the following order:"

msgstr "Es una buena práctica si importas los módulos en el orden siguiente:"

#: ../Doc/faq/programming.rst:294

msgid "standard library modules -- e.g. ``sys``, ``os``, ``getopt``, ``re``"

msgstr ""

"módulos de la biblioteca estándar -- por ejemplo, ``sys``, ``os``, "

"``getopt``, ``re``"

#: ../Doc/faq/programming.rst:295

msgid ""

"third-party library modules (anything installed in Python's site-packages "

"directory) -- e.g. mx.DateTime, ZODB, PIL.Image, etc."

msgstr ""

"módulos de bibliotecas de terceros (cualquier cosa instalada en el "

"directorio *site-packages* de Python) -- por ejemplo, mx.DateTime, ZODB, PIL."

"Image, etc."

#: ../Doc/faq/programming.rst:297

#, fuzzy

msgid "locally developed modules"

msgstr "módulos desarrollados localmente"

#: ../Doc/faq/programming.rst:299

msgid ""

"It is sometimes necessary to move imports to a function or class to avoid "

"problems with circular imports. Gordon McMillan says:"

msgstr ""

"Hay veces en que es necesario mover las importaciones a una función o clase "

"para evitar problemas de importaciones circulares. Gordon McMillan dice:"

#: ../Doc/faq/programming.rst:302

msgid ""

"Circular imports are fine where both modules use the \"import <module>\" "

"form of import. They fail when the 2nd module wants to grab a name out of "

"the first (\"from module import name\") and the import is at the top level. "

"That's because names in the 1st are not yet available, because the first "

"module is busy importing the 2nd."

msgstr ""

"No hay problema con las importaciones circulares cuando ambos módulos usan "

"la forma de importación \"import <module>\". Fallará cuando el segundo "

"módulo quiera coger un nombre del primer módulo (\"from module import "

"name\") y la importación se encuentre en el nivel superior. Esto sucede "

"porque los nombres en el primero todavía no se encuentran disponibles debido "

"a que el primer módulo se encuentra ocupado importando al segundo."

#: ../Doc/faq/programming.rst:308

msgid ""

"In this case, if the second module is only used in one function, then the "

"import can easily be moved into that function. By the time the import is "

"called, the first module will have finished initializing, and the second "

"module can do its import."

msgstr ""

"En este caso, si el segundo módulo se usa solamente desde una función, la "

"importación se puede mover de forma sencilla dentro de la función. En el "

"momento en que se invoca a la importación el primer módulo habrá terminado "

"de inicializarse y el segundo módulo podrá hacer la importación."

#: ../Doc/faq/programming.rst:313

msgid ""

"It may also be necessary to move imports out of the top level of code if "

"some of the modules are platform-specific. In that case, it may not even be "

"possible to import all of the modules at the top of the file. In this case, "

"importing the correct modules in the corresponding platform-specific code is "

"a good option."

msgstr ""

"También podría ser necesario mover importaciones fuera del nivel superior "

"del código si alguno de loa módulos son específicos a la plataforma. En ese "

"caso podría, incluso, no ser posible importar todos los módulos en la parte "

"superior del fichero. Para esos casos, la importación correcta de los "

"módulos en el código correspondiente específico de la plataforma es una "

"buena opción."

#: ../Doc/faq/programming.rst:318

msgid ""

"Only move imports into a local scope, such as inside a function definition, "

"if it's necessary to solve a problem such as avoiding a circular import or "

"are trying to reduce the initialization time of a module. This technique is "

"especially helpful if many of the imports are unnecessary depending on how "

"the program executes. You may also want to move imports into a function if "

"the modules are only ever used in that function. Note that loading a module "

"the first time may be expensive because of the one time initialization of "

"the module, but loading a module multiple times is virtually free, costing "

"only a couple of dictionary lookups. Even if the module name has gone out "

"of scope, the module is probably available in :data:`sys.modules`."

msgstr ""

"Solo debes mover importaciones a un ámbito de aplicación local, como dentro "

"de la definición de una función, si es necesario resolver problemas como una "

"importación circular o al intentar reducir el tiempo de inicialización de un "

"módulo. Esta técnica es especialmente útil si muchas de las importaciones no "

"son necesarias dependiendo de cómo se ejecute el programa. También podrías "

"mover importaciones a una función si los módulos solo se usan dentro de esa "

"función. Nótese que la primera carga de un módulo puede ser costosa debido "

"al tiempo necesario para la inicialización del módulo,pero la carga de un "

"módulo múltiples veces está prácticamente libre de coste ya que solo es "

"necesario hacer búsquedas en un diccionario. Incluso si el nombre del módulo "

"ha salido del ámbito de aplicación el módulo se encuentre, probablemente, "

"en :data:`sys.modules`."

#: ../Doc/faq/programming.rst:331

msgid "Why are default values shared between objects?"

msgstr "¿Por qué los valores por defecto se comparten entre objetos?"

#: ../Doc/faq/programming.rst:333

msgid ""

"This type of bug commonly bites neophyte programmers. Consider this "

"function::"

msgstr ""

"Este tipo de error golpea a menudo a programadores novatos. Considera esta "

"función::"

#: ../Doc/faq/programming.rst:340

msgid ""

"The first time you call this function, ``mydict`` contains a single item. "

"The second time, ``mydict`` contains two items because when ``foo()`` begins "

"executing, ``mydict`` starts out with an item already in it."

msgstr ""

"La primera vez que llamas a esta función, ``mydict`` solamente contiene un "

"único elemento. La segunda vez, ``mydict`` contiene dos elementos debido a "

"que cuando comienza la ejecución de ``foo()``, ``mydict`` comienza "

"conteniendo un elemento de partida."

#: ../Doc/faq/programming.rst:344

msgid ""

"It is often expected that a function call creates new objects for default "

"values. This is not what happens. Default values are created exactly once, "

"when the function is defined. If that object is changed, like the "

"dictionary in this example, subsequent calls to the function will refer to "

"this changed object."

msgstr ""

"A menudo se esperaría que una invocación a una función cree nuevos objetos "

"para valores por defecto. Eso no es lo que realmente sucede. Los valores por "

"defecto se crean exactamente una sola vez, cuando se define la función. Se "

"se cambia el objeto, como el diccionario en este ejemplo, posteriores "

"invocaciones a la función estarán referidas al objeto cambiado."

#: ../Doc/faq/programming.rst:349

msgid ""

"By definition, immutable objects such as numbers, strings, tuples, and "

"``None``, are safe from change. Changes to mutable objects such as "

"dictionaries, lists, and class instances can lead to confusion."

msgstr ""

"Por definición, los objetos inmutables como números, cadenas, tuplas y "

"``None`` están asegurados frente al cambio. Cambios en objetos mutables como "

"diccionarios, listas e instancias de clase pueden llevar a confusión."

#: ../Doc/faq/programming.rst:353

msgid ""

"Because of this feature, it is good programming practice to not use mutable "

"objects as default values. Instead, use ``None`` as the default value and "

"inside the function, check if the parameter is ``None`` and create a new "

"list/dictionary/whatever if it is. For example, don't write::"

msgstr ""

"Debido a esta característica es una buena práctica de programación el no "

"usar valores mutables como valores por defecto. En su lugar usa ``None`` "

"como valor por defecto dentro de la función, comprueba si el parámetro es "

"``None`` y crea una nueva lista/un nuevo diccionario/cualquier otras cosa "

"que necesites. Por ejemplo, no escribas::"

#: ../Doc/faq/programming.rst:361

msgid "but::"

msgstr "pero::"

#: ../Doc/faq/programming.rst:367

msgid ""

"This feature can be useful. When you have a function that's time-consuming "

"to compute, a common technique is to cache the parameters and the resulting "

"value of each call to the function, and return the cached value if the same "

"value is requested again. This is called \"memoizing\", and can be "

"implemented like this::"

msgstr ""

"Esta característica puede ser útil. Cuando tienes una función que es muy "

"costosa de ejecutar, una técnica común es *cachear* sus parámetros y el "

"valor resultante de cada invocación a la función y retornar el valor "

"*cacheado* si se solicita nuevamente el mismo valor. A esto se le llama "

"\"memoizing\" y se puede implementar de la siguiente forma::"

#: ../Doc/faq/programming.rst:382

msgid ""

"You could use a global variable containing a dictionary instead of the "

"default value; it's a matter of taste."

msgstr ""

"Podrías usar una variable global conteniendo un diccionario en lugar de un "

"valor por defecto; es una cuestión de gustos."

#: ../Doc/faq/programming.rst:387

msgid ""

"How can I pass optional or keyword parameters from one function to another?"

msgstr ""

"¿Cómo puedo pasar parámetros por palabra clave u opcionales de una función a "

"otra?"

#: ../Doc/faq/programming.rst:389

msgid ""

"Collect the arguments using the ``*`` and ``**`` specifiers in the "

"function's parameter list; this gives you the positional arguments as a "

"tuple and the keyword arguments as a dictionary. You can then pass these "

"arguments when calling another function by using ``*`` and ``**``::"

msgstr ""

"Recopila los argumentos usando los especificadores ``*`` y ``**`` en la "

"lista de parámetros de la función; esto te proporciona los argumentos "

"posicionales como una tupla y los argumentos con palabras clave como un "

"diccionario. Puedes, entonces, pasar estos argumentos cuando invoques a "

"otra función usando ``*`` y ``**``::"

#: ../Doc/faq/programming.rst:408

msgid "What is the difference between arguments and parameters?"

msgstr "¿Cuál es la diferencia entre argumentos y parámetros?"

#: ../Doc/faq/programming.rst:410

#, fuzzy

msgid ""

":term:`Parameters <parameter>` are defined by the names that appear in a "

"function definition, whereas :term:`arguments <argument>` are the values "

"actually passed to a function when calling it. Parameters define what :term:"

"`kind of arguments <parameter>` a function can accept. For example, given "

"the function definition::"

msgstr ""

":term:`Parámetros <parameter>` se definen mediante los nombres que aparecen "

"en la definición de una función mientras que :term:`argumentos <argument>` "

"son los valores que se pasan a la función cuando la invocamos. Los "

"Parámetros definen qué tipos de argumentos puede aceptar una función. por "

"ejemplo, dada la definición de la función::"

#: ../Doc/faq/programming.rst:419

msgid ""

"*foo*, *bar* and *kwargs* are parameters of ``func``. However, when calling "

"``func``, for example::"

msgstr ""

"*foo*, *bar* y *kwargs* son parámetros de ``func``. Sin embargo, cuando "

"invocamos a ``func``, por ejemplo::"

#: ../Doc/faq/programming.rst:424

msgid "the values ``42``, ``314``, and ``somevar`` are arguments."

msgstr "los valores ``42``, ``314`` y ``somevar`` son argumentos."

#: ../Doc/faq/programming.rst:428

msgid "Why did changing list 'y' also change list 'x'?"

msgstr "¿Por qué cambiando la lista 'y' cambia, también, la lista 'x'?"

#: ../Doc/faq/programming.rst:430

msgid "If you wrote code like::"

msgstr "Si escribes código como::"

#: ../Doc/faq/programming.rst:440

msgid ""

"you might be wondering why appending an element to ``y`` changed ``x`` too."

msgstr ""

"te estarás preguntando porque añadir un elemento a ``y`` ha cambiado también "

"a ``x``."

#: ../Doc/faq/programming.rst:442

msgid "There are two factors that produce this result:"

msgstr "Hay dos factores que provocan este resultado:"

#: ../Doc/faq/programming.rst:444

msgid ""

"Variables are simply names that refer to objects. Doing ``y = x`` doesn't "

"create a copy of the list -- it creates a new variable ``y`` that refers to "

"the same object ``x`` refers to. This means that there is only one object "

"(the list), and both ``x`` and ``y`` refer to it."

msgstr ""

"Las variables son simplemente nombres que referencian a objetos. Haciendo "

"``y = x`` no crea una copia de la lista -- crea una nueva variable ``y`` que "

"referencia al mismo objeto al que referencia ``x`` . Esto significa que "

"solo existe un objeto (la lista) y tanto ``x`` como ``y`` hacen referencia "

"al mismo."

#: ../Doc/faq/programming.rst:448

msgid ""

"Lists are :term:`mutable`, which means that you can change their content."

msgstr ""

"Las listas son :term:`mutable`, lo que significa que puedes cambiar su "

"contenido."

#: ../Doc/faq/programming.rst:450

msgid ""

"After the call to :meth:`~list.append`, the content of the mutable object "

"has changed from ``[]`` to ``[10]``. Since both the variables refer to the "

"same object, using either name accesses the modified value ``[10]``."

msgstr ""

"Después de la invocación a :meth:`~list.append`, el contenido del objeto "

"mutable ha cambiado de ``[]`` a``[10]``. Ya que ambas variables referencian "

"al mismo objeto, el usar cualquiera de los nombres accederá al valor "

"modificado ``[10]``."

#: ../Doc/faq/programming.rst:454

msgid "If we instead assign an immutable object to ``x``::"

msgstr "Si, por otra parte, asignamos un objeto inmutable a ``x``::"

#: ../Doc/faq/programming.rst:464

msgid ""

"we can see that in this case ``x`` and ``y`` are not equal anymore. This is "

"because integers are :term:`immutable`, and when we do ``x = x + 1`` we are "

"not mutating the int ``5`` by incrementing its value; instead, we are "

"creating a new object (the int ``6``) and assigning it to ``x`` (that is, "

"changing which object ``x`` refers to). After this assignment we have two "

"objects (the ints ``6`` and ``5``) and two variables that refer to them "

"(``x`` now refers to ``6`` but ``y`` still refers to ``5``)."

msgstr ""

"podemos ver que ``x`` e ``y`` ya no son iguales. Esto es debido a que los "

"enteros son :term:`immutable`, y cuando hacemos ``x = x + 1`` no estamos "

"mutando el entero ``5`` incrementando su valor; en su lugar, estamos creando "

"un nuevo objeto (el entero ``6``) y se lo asignamos a ``x`` (esto es, "

"cambiando el objeto al cual referencia ``x``). Después de esta asignación "

"tenemos dos objetos (los enteros ``6`` y ``5``) y dos variables que "

"referencian a ellos (``x`` ahora referencia a ``6`` pero ``y`` todavía "

"referencia a ``5``)."

#: ../Doc/faq/programming.rst:472

msgid ""

"Some operations (for example ``y.append(10)`` and ``y.sort()``) mutate the "

"object, whereas superficially similar operations (for example ``y = y + "

"[10]`` and ``sorted(y)``) create a new object. In general in Python (and in "

"all cases in the standard library) a method that mutates an object will "

"return ``None`` to help avoid getting the two types of operations confused. "

"So if you mistakenly write ``y.sort()`` thinking it will give you a sorted "

"copy of ``y``, you'll instead end up with ``None``, which will likely cause "

"your program to generate an easily diagnosed error."

msgstr ""

"Algunas operaciones (por ejemplo ``y.append(10)`` y ``y.sort()``) mutan al "

"objeto mientras que operaciones que podrían parecer similares (por ejemplo "

"``y = y + [10]`` y ``sorted(y)``) crean un nuevo objeto. En general, en "

"Python (y en todo momento en la biblioteca estándar) un método que muta un "

"objeto retornará ``None`` para evitar tener dos tipos de operaciones que "

"puedan ser confusas. Por tanto, si escribes accidentalmente ``y.sort()`` "

"pensando que te retornará una copia ordenada de ``y``, obtendrás, en su "

"lugar, ``None``, lo cual ayudará a que tu programa genera un error que pueda "

"ser diagnosticado fácilmente."

#: ../Doc/faq/programming.rst:481

msgid ""

"However, there is one class of operations where the same operation sometimes "

"has different behaviors with different types: the augmented assignment "

"operators. For example, ``+=`` mutates lists but not tuples or ints "

"(``a_list += [1, 2, 3]`` is equivalent to ``a_list.extend([1, 2, 3])`` and "

"mutates ``a_list``, whereas ``some_tuple += (1, 2, 3)`` and ``some_int += "

"1`` create new objects)."

msgstr ""

"Sin embargo, existe una clase de operaciones en las cuales la misma "

"operación tiene, a veces, distintos comportamientos con diferentes tipos: "

"los operadores de asignación aumentada. Por ejemplo, ``+=`` muta listas "

"pero no tuplas o enteros (``a_list += [1, 2, 3]`` es equivalente a ``a_list."

"extend([1, 2, 3])`` y muta ``a_list``, mientras que ``some_tuple += (1, 2, "

"3)`` y ``some_int += 1`` crea nuevos objetos)."

#: ../Doc/faq/programming.rst:488

msgid "In other words:"

msgstr "En otras palabras:"

#: ../Doc/faq/programming.rst:490

msgid ""

"If we have a mutable object (:class:`list`, :class:`dict`, :class:`set`, "

"etc.), we can use some specific operations to mutate it and all the "

"variables that refer to it will see the change."

msgstr ""

"Si tenemos un objeto mutable (:class:`list`, :class:`dict`, :class:`set`, "

"etc.), podemos usar algunas operaciones específicas para mutarlo y todas las "

"variables que referencian al mismo verán el cambio reflejado."

#: ../Doc/faq/programming.rst:493

msgid ""

"If we have an immutable object (:class:`str`, :class:`int`, :class:`tuple`, "

"etc.), all the variables that refer to it will always see the same value, "

"but operations that transform that value into a new value always return a "

"new object."

msgstr ""

"Si tenemos un objeto inmutable (:class:`str`, :class:`int`, :class:`tuple`, "

"etc.), todas las variables que referencian al mismo verán siempre el mismo "

"valor pero las operaciones que transforman ese valor en un nuevo valor "

"siempre retornan un nuevo objeto."

#: ../Doc/faq/programming.rst:498

msgid ""

"If you want to know if two variables refer to the same object or not, you "

"can use the :keyword:`is` operator, or the built-in function :func:`id`."

msgstr ""

"Si deseas saber si dos variables referencian o no al mismo objeto puedes "

"usar el operador :keyword:`is` o la función incorporada :func:`id`."

#: ../Doc/faq/programming.rst:503

msgid "How do I write a function with output parameters (call by reference)?"

msgstr ""

"¿Cómo puedo escribir una función sin parámetros (invocación mediante "

"referencia)?"

#: ../Doc/faq/programming.rst:505

msgid ""

"Remember that arguments are passed by assignment in Python. Since "

"assignment just creates references to objects, there's no alias between an "

"argument name in the caller and callee, and so no call-by-reference per se. "

"You can achieve the desired effect in a number of ways."

msgstr ""

"Recuerda que los argumentos son pasados mediante asignación en Python. Ya "

"que las asignaciones simplemente crean referencias a objetos, no hay alias "

"entre el nombre de un argumento en el invocador y el invocado y, por tanto, "

"no hay invocación por referencia per se. Puedes obtener el mismo efecto "

"deseado de formas distintas."

#: ../Doc/faq/programming.rst:510

msgid "By returning a tuple of the results::"

msgstr "Mediante el retorno de una tupla de resultados::"

#: ../Doc/faq/programming.rst:521

msgid "This is almost always the clearest solution."

msgstr "Esta es, casi siempre, la solución más clara."

#: ../Doc/faq/programming.rst:523

msgid ""

"By using global variables. This isn't thread-safe, and is not recommended."

msgstr ""

"Mediante el uso de variables globales. No es thread-safe y no se recomienda."

#: ../Doc/faq/programming.rst:525

msgid "By passing a mutable (changeable in-place) object::"

msgstr "Pasando un objeto mutable (intercambiable en el mismo sitio)::"

#: ../Doc/faq/programming.rst:536

msgid "By passing in a dictionary that gets mutated::"

msgstr "Pasando un diccionario que muta::"

#: ../Doc/faq/programming.rst:547

msgid "Or bundle up values in a class instance::"

msgstr "O empaquetar valores en una instancia de clase::"

#: ../Doc/faq/programming.rst:564

msgid "There's almost never a good reason to get this complicated."

msgstr "Casi nunca existe una buena razón para hacer esto tan complicado."

#: ../Doc/faq/programming.rst:566

msgid "Your best choice is to return a tuple containing the multiple results."

msgstr ""

"Tu mejor opción es retornar una tupla que contenga los múltiples resultados."

#: ../Doc/faq/programming.rst:570

msgid "How do you make a higher order function in Python?"

msgstr "¿Cómo se puede hacer una función de orden superior en Python?"

#: ../Doc/faq/programming.rst:572

msgid ""

"You have two choices: you can use nested scopes or you can use callable "

"objects. For example, suppose you wanted to define ``linear(a,b)`` which "

"returns a function ``f(x)`` that computes the value ``a*x+b``. Using nested "

"scopes::"

msgstr ""

"Tienes dos opciones: puedes usar ámbitos de aplicación anidados o puedes "

"usar objetos invocables. Por ejemplo, supón que querías definir ``linear(a,"

"b)`` que devuelve una función ``f(x)`` que calcula el valor ``a*x+b``. Usar "

"ámbitos de aplicación anidados::"

#: ../Doc/faq/programming.rst:581

msgid "Or using a callable object::"

msgstr "O usar un objeto invocable::"

#: ../Doc/faq/programming.rst:591

msgid "In both cases, ::"

msgstr "En ambos casos, ::"

#: ../Doc/faq/programming.rst:595

msgid "gives a callable object where ``taxes(10e6) == 0.3 * 10e6 + 2``."

msgstr "nos da un objeto invocable donde ``taxes(10e6) == 0.3 * 10e6 + 2``."

#: ../Doc/faq/programming.rst:597

msgid ""

"The callable object approach has the disadvantage that it is a bit slower "

"and results in slightly longer code. However, note that a collection of "

"callables can share their signature via inheritance::"