# 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. # [email protected] / # https://mail.python.org/mailman3/lists/docs-es.python.org/ # Check https://github.com/python/python-docs-es/blob/3.8/TRANSLATORS to # get the list of volunteers # msgid "" msgstr "" "Project-Id-Version: Python 3.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-10-12 19:43+0200\n" "PO-Revision-Date: 2024-01-21 16:47+0100\n" "Last-Translator: Juan C. Tello \n" "Language-Team: python-doc-es\n" "Language: es\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=2; plural=(n != 1);\n" "Generated-By: Babel 2.13.0\n" "X-Generator: Poedit 3.0.1\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:58 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 `. 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 `. Puedes " "escribir tu propio depurador usando el código de pdb como ejemplo." #: ../Doc/faq/programming.rst:27 #, fuzzy msgid "" "The IDLE interactive development environment, which is part of the standard " "Python distribution (normally available as `Tools/scripts/idle3 `_), 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:32 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 `_ project and as a part of " "the `ActivePython `_ " "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 `_ y como parte de la distribución `ActivePython `_." #: ../Doc/faq/programming.rst:39 #, fuzzy msgid "" "`Eric `_ is an IDE built on PyQt and " "the Scintilla editing component." msgstr "" "`Eric `_ es un IDE creado usando PyQt " "y el componente de edición Scintilla." #: ../Doc/faq/programming.rst:42 msgid "" "`trepan3k `_ is a gdb-like " "debugger." msgstr "" "`trepan3k `_ es un depurador " "similar a `gdb`." #: ../Doc/faq/programming.rst:44 msgid "" "`Visual Studio Code `_ is an IDE with " "debugging tools that integrates with version-control software." msgstr "" "`Visual Studio Code `_ es un IDE con " "herramientas de depuración que se integra con software de control de " "versiones." #: ../Doc/faq/programming.rst:47 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:50 msgid "`Wing IDE `_" msgstr "`IDE Wing `_" #: ../Doc/faq/programming.rst:51 msgid "`Komodo IDE `_" msgstr "`IDE Komodo `_" #: ../Doc/faq/programming.rst:52 msgid "`PyCharm `_" msgstr "`PyCharm `_" #: ../Doc/faq/programming.rst:56 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:60 #, fuzzy msgid "" "`Pylint `_ and `Pyflakes " "`_ do basic checking that will help you " "catch bugs sooner." msgstr "" "`Pylint `_ y `Pyflakes `_ realizan comprobaciones básicas que le ayudarán a detectar " "errores antes." #: ../Doc/faq/programming.rst:64 #, fuzzy msgid "" "Static type checkers such as `Mypy `_, `Pyre " "`_, and `Pytype `_ can check type hints in Python source code." msgstr "" "Inspectores estáticos de tipos como `Mypy `_, `Pyre " "`_, y `Pytype `_ " "pueden hacer comprobaciones de las anotaciones de tipos en código fuente " "Python." #: ../Doc/faq/programming.rst:73 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:75 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:81 #, 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:87 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:96 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:99 msgid "`Nuitka `_ (Cross-platform)" msgstr "`Nuitka `_ (Multiplataforma)" #: ../Doc/faq/programming.rst:100 #, fuzzy msgid "`PyInstaller `_ (Cross-platform)" msgstr "`PyInstaller `_ (Multiplataforma)" #: ../Doc/faq/programming.rst:101 msgid "" "`PyOxidizer `_ (Cross-platform)" msgstr "" "`PyOxidizer `_ " "(Multiplataforma)" #: ../Doc/faq/programming.rst:102 msgid "" "`cx_Freeze `_ (Cross-platform)" msgstr "" "`cx_Freeze `_ (Multiplataforma)" #: ../Doc/faq/programming.rst:103 msgid "`py2app `_ (macOS only)" msgstr "`py2app `_ (macOS solamente)" #: ../Doc/faq/programming.rst:104 #, fuzzy msgid "`py2exe `_ (Windows only)" msgstr "`py2exe `_ (solo Windows)" #: ../Doc/faq/programming.rst:107 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:109 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:114 msgid "Core Language" msgstr "Núcleo del lenguaje" #: ../Doc/faq/programming.rst:119 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:121 #, fuzzy msgid "" "It can be a surprise to get the :exc:`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:125 msgid "This code:" msgstr "Este código:" #: ../Doc/faq/programming.rst:134 msgid "works, but this code:" msgstr "funciona, pero este código:" #: ../Doc/faq/programming.rst:141 #, fuzzy msgid "results in an :exc:`!UnboundLocalError`:" msgstr "resulta en un UnboundLocalError:" #: ../Doc/faq/programming.rst:148 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:155 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:167 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:174 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:192 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:194 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:198 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:208 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:210 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:217 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:227 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:237 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:244 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:255 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:260 msgid "How do I share global variables across modules?" msgstr "¿Cómo puedo compartir variables globales entre módulos?" #: ../Doc/faq/programming.rst:262 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:268 msgid "config.py::" msgstr "config.py::" #: ../Doc/faq/programming.rst:272 msgid "mod.py::" msgstr "mod.py::" #: ../Doc/faq/programming.rst:277 msgid "main.py::" msgstr "main.py::" #: ../Doc/faq/programming.rst:283 #, fuzzy 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:288 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:290 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:294 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:299 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:301 #, fuzzy msgid "" "standard library modules -- e.g. :mod:`sys`, :mod:`os`, :mod:`argparse`, :" "mod:`re`" msgstr "" "módulos de la biblioteca estándar -- por ejemplo, ``sys``, ``os``, " "``getopt``, ``re``" #: ../Doc/faq/programming.rst:302 #, fuzzy msgid "" "third-party library modules (anything installed in Python's site-packages " "directory) -- e.g. :mod:`!dateutil`, :mod:`!requests`, :mod:`!PIL.Image`" 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:304 #, fuzzy msgid "locally developed modules" msgstr "módulos desarrollados localmente" #: ../Doc/faq/programming.rst:306 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:309 msgid "" "Circular imports are fine where both modules use the \"import \" " "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 \". 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:315 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:320 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:325 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:338 msgid "Why are default values shared between objects?" msgstr "¿Por qué los valores por defecto se comparten entre objetos?" #: ../Doc/faq/programming.rst:340 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:347 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:351 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:356 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:360 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:368 msgid "but::" msgstr "pero::" #: ../Doc/faq/programming.rst:374 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:389 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:394 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:396 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:415 msgid "What is the difference between arguments and parameters?" msgstr "¿Cuál es la diferencia entre argumentos y parámetros?" #: ../Doc/faq/programming.rst:417 #, fuzzy msgid "" ":term:`Parameters ` are defined by the names that appear in a " "function definition, whereas :term:`arguments ` are the values " "actually passed to a function when calling it. Parameters define what :term:" "`kind of arguments ` a function can accept. For example, given " "the function definition::" msgstr "" ":term:`Parámetros ` se definen mediante los nombres que aparecen " "en la definición de una función mientras que :term:`argumentos ` " "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:426 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:431 msgid "the values ``42``, ``314``, and ``somevar`` are arguments." msgstr "los valores ``42``, ``314`` y ``somevar`` son argumentos." #: ../Doc/faq/programming.rst:435 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:437 msgid "If you wrote code like::" msgstr "Si escribes código como::" #: ../Doc/faq/programming.rst:447 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:449 msgid "There are two factors that produce this result:" msgstr "Hay dos factores que provocan este resultado:" #: ../Doc/faq/programming.rst:451 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:455 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:457 #, fuzzy msgid "" "After the call to :meth:`!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:461 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:471 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:479 #, fuzzy msgid "" "Some operations (for example ``y.append(10)`` and ``y.sort()``) mutate the " "object, whereas superficially similar operations (for example ``y = y + " "[10]`` and :func:`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:488 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:495 msgid "In other words:" msgstr "En otras palabras:" #: ../Doc/faq/programming.rst:497 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:500 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:505 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:510 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:512 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:517 msgid "By returning a tuple of the results::" msgstr "Mediante el retorno de una tupla de resultados::" #: ../Doc/faq/programming.rst:528 msgid "This is almost always the clearest solution." msgstr "Esta es, casi siempre, la solución más clara." #: ../Doc/faq/programming.rst:530 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:532 msgid "By passing a mutable (changeable in-place) object::" msgstr "Pasando un objeto mutable (intercambiable en el mismo sitio)::" #: ../Doc/faq/programming.rst:543 msgid "By passing in a dictionary that gets mutated::" msgstr "Pasando un diccionario que muta::" #: ../Doc/faq/programming.rst:554 msgid "Or bundle up values in a class instance::" msgstr "O empaquetar valores en una instancia de clase::" #: ../Doc/faq/programming.rst:571 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:573 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:577 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:579 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:588 msgid "Or using a callable object::" msgstr "O usar un objeto invocable::" #: ../Doc/faq/programming.rst:598 msgid "In both cases, ::" msgstr "En ambos casos, ::" #: ../Doc/faq/programming.rst:602 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:604 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::" msgstr "" "El enfoque del objeto invocable tiene la desventaja que es un ligeramente " "más lento y el resultado es un código levemente más largo. Sin embargo, " "destacar que una colección de invocables pueden compartir su firma vía " "herencia::" #: ../Doc/faq/programming.rst:613 msgid "Object can encapsulate state for several methods::" msgstr "Los objetos pueden encapsular el estado de varios métodos::" #: ../Doc/faq/programming.rst:631 msgid "" "Here ``inc()``, ``dec()`` and ``reset()`` act like functions which share the " "same counting variable." msgstr "" "Aquí ``inc()``, ``dec()`` y ``reset()`` se comportan como funciones las " "cuales comparten la misma variable de conteo." #: ../Doc/faq/programming.rst:636 msgid "How do I copy an object in Python?" msgstr "¿Cómo copio un objeto en Python?" #: ../Doc/faq/programming.rst:638 msgid "" "In general, try :func:`copy.copy` or :func:`copy.deepcopy` for the general " "case. Not all objects can be copied, but most can." msgstr "" "En general, prueba :func:`copy.copy` o :func:`copy.deepcopy` para el caso " "general. No todos los objetos se pueden copiar pero la mayoría sí que pueden " "copiarse." #: ../Doc/faq/programming.rst:641 msgid "" "Some objects can be copied more easily. Dictionaries have a :meth:`~dict." "copy` method::" msgstr "" "Algunas objetos se pueden copiar de forma más sencilla. Los diccionarios " "disponen de un método :meth:`~dict.copy`::" #: ../Doc/faq/programming.rst:646 msgid "Sequences can be copied by slicing::" msgstr "Las secuencias se pueden copiar usando un rebanado::" #: ../Doc/faq/programming.rst:652 msgid "How can I find the methods or attributes of an object?" msgstr "¿Cómo puedo encontrar los métodos o atributos de un objeto?" #: ../Doc/faq/programming.rst:654 #, fuzzy msgid "" "For an instance ``x`` of a user-defined class, :func:`dir(x)