# 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: 2024-11-21 16:38-0300\n" "PO-Revision-Date: 2023-10-23 10:45-0300\n" "Last-Translator: Carlos A. Crespo \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.16.0\n" #: ../Doc/tutorial/modules.rst:5 msgid "Modules" msgstr "Módulos" #: ../Doc/tutorial/modules.rst:7 msgid "" "If you quit from the Python interpreter and enter it again, the definitions " "you have made (functions and variables) are lost. Therefore, if you want to " "write a somewhat longer program, you are better off using a text editor to " "prepare the input for the interpreter and running it with that file as input " "instead. This is known as creating a *script*. As your program gets " "longer, you may want to split it into several files for easier maintenance. " "You may also want to use a handy function that you've written in several " "programs without copying its definition into each program." msgstr "" "Si sales del intérprete de Python y vuelves a entrar, las definiciones que " "habías hecho (funciones y variables) se pierden. Por lo tanto, si quieres " "escribir un programa más o menos largo, es mejor que utilices un editor de " "texto para preparar la entrada para el intérprete y ejecutarlo con ese " "archivo como entrada. Esto se conoce como crear un *script*. A medida que tu " "programa crezca, quizás quieras separarlo en varios archivos para que el " "mantenimiento sea más sencillo. Quizás también quieras usar una función útil " "que has escrito en distintos programas sin copiar su definición en cada " "programa." #: ../Doc/tutorial/modules.rst:16 msgid "" "To support this, Python has a way to put definitions in a file and use them " "in a script or in an interactive instance of the interpreter. Such a file is " "called a *module*; definitions from a module can be *imported* into other " "modules or into the *main* module (the collection of variables that you have " "access to in a script executed at the top level and in calculator mode)." msgstr "" "Para soportar esto, Python tiene una manera de poner definiciones en un " "archivo y usarlos en un script o en una instancia del intérprete. Este tipo " "de ficheros se llama *módulo*; las definiciones de un módulo pueden ser " "*importadas* a otros módulos o al módulo *principal* (la colección de " "variables a las que tienes acceso en un script ejecutado en el nivel " "superior y en el modo calculadora)." #: ../Doc/tutorial/modules.rst:22 msgid "" "A module is a file containing Python definitions and statements. The file " "name is the module name with the suffix :file:`.py` appended. Within a " "module, the module's name (as a string) is available as the value of the " "global variable ``__name__``. For instance, use your favorite text editor " "to create a file called :file:`fibo.py` in the current directory with the " "following contents::" msgstr "" "Un módulo es un fichero conteniendo definiciones y declaraciones de Python. " "El nombre de archivo es el nombre del módulo con el sufijo :file:`.py` " "agregado. Dentro de un módulo, el nombre del mismo módulo (como cadena) está " "disponible en el valor de la variable global ``__name__``. Por ejemplo, " "utiliza tu editor de texto favorito para crear un archivo llamado :file:" "`fibo.py` en el directorio actual, con el siguiente contenido::" #: ../Doc/tutorial/modules.rst:28 msgid "" "# Fibonacci numbers module\n" "\n" "def fib(n): # write Fibonacci series up to n\n" " a, b = 0, 1\n" " while a < n:\n" " print(a, end=' ')\n" " a, b = b, a+b\n" " print()\n" "\n" "def fib2(n): # return Fibonacci series up to n\n" " result = []\n" " a, b = 0, 1\n" " while a < n:\n" " result.append(a)\n" " a, b = b, a+b\n" " return result" msgstr "" #: ../Doc/tutorial/modules.rst:45 msgid "" "Now enter the Python interpreter and import this module with the following " "command::" msgstr "" "Ahora entra en el intérprete de Python e importa este modulo con el " "siguiente comando::" #: ../Doc/tutorial/modules.rst:48 msgid ">>> import fibo" msgstr "" #: ../Doc/tutorial/modules.rst:50 msgid "" "This does not add the names of the functions defined in ``fibo`` directly " "to the current :term:`namespace` (see :ref:`tut-scopes` for more details); " "it only adds the module name ``fibo`` there. Using the module name you can " "access the functions::" msgstr "" "Esto no añade los nombres de las funciones definidas en ``fibo`` " "directamente al actual :term:`namespace` (ver :ref:`tut-scopes` para más " "detalles); sólo añade el nombre del módulo ``fibo`` allí. Usando el nombre " "del módulo puedes acceder a las funciones::" #: ../Doc/tutorial/modules.rst:55 msgid "" ">>> fibo.fib(1000)\n" "0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987\n" ">>> fibo.fib2(100)\n" "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]\n" ">>> fibo.__name__\n" "'fibo'" msgstr "" #: ../Doc/tutorial/modules.rst:62 msgid "" "If you intend to use a function often you can assign it to a local name::" msgstr "" "Si pretendes utilizar una función frecuentemente puedes asignarla a un " "nombre local::" #: ../Doc/tutorial/modules.rst:64 msgid "" ">>> fib = fibo.fib\n" ">>> fib(500)\n" "0 1 1 2 3 5 8 13 21 34 55 89 144 233 377" msgstr "" #: ../Doc/tutorial/modules.rst:72 msgid "More on Modules" msgstr "Más sobre los módulos" #: ../Doc/tutorial/modules.rst:74 msgid "" "A module can contain executable statements as well as function definitions. " "These statements are intended to initialize the module. They are executed " "only the *first* time the module name is encountered in an import statement. " "[#]_ (They are also run if the file is executed as a script.)" msgstr "" "Un módulo puede contener tanto declaraciones ejecutables como definiciones " "de funciones. Estas declaraciones están pensadas para inicializar el módulo. " "Se ejecutan únicamente la *primera* vez que el módulo se encuentra en una " "declaración import. [#]_ (También se ejecutan si el archivo se ejecuta como " "script.)" #: ../Doc/tutorial/modules.rst:79 msgid "" "Each module has its own private namespace, which is used as the global " "namespace by all functions defined in the module. Thus, the author of a " "module can use global variables in the module without worrying about " "accidental clashes with a user's global variables. On the other hand, if you " "know what you are doing you can touch a module's global variables with the " "same notation used to refer to its functions, ``modname.itemname``." msgstr "" "Cada módulo tiene su propio espacio de nombres privado, que es utilizado " "como espacio de nombres global por todas las funciones definidas en el " "módulo. De este modo, el autor de un módulo puede utilizar variables " "globales en el módulo sin preocuparse por choques accidentales con las " "variables globales de un usuario. Por otro lado, si sabes lo que estás " "haciendo puedes tocar las variables globales de un módulo con la misma " "notación que se utiliza para referirse a sus funciones, ``modname.itemname``." #: ../Doc/tutorial/modules.rst:86 msgid "" "Modules can import other modules. It is customary but not required to place " "all :keyword:`import` statements at the beginning of a module (or script, " "for that matter). The imported module names, if placed at the top level of " "a module (outside any functions or classes), are added to the module's " "global namespace." msgstr "" "Los módulos pueden importar otros módulos. Es costumbre pero no obligatorio " "ubicar todas las declaraciones :keyword:`import` al principio del módulo (o " "script, para el caso). Los nombres de los módulos importados, si se colocan " "en el nivel superior de un módulo (fuera de cualquier función o clase), se " "añaden al espacio de nombres global del módulo." #: ../Doc/tutorial/modules.rst:91 msgid "" "There is a variant of the :keyword:`import` statement that imports names " "from a module directly into the importing module's namespace. For example::" msgstr "" "Hay una variante de la declaración :keyword:`import` que importa los nombres " "de un módulo directamente al espacio de nombres del módulo que hace la " "importación. Por ejemplo::" #: ../Doc/tutorial/modules.rst:94 msgid "" ">>> from fibo import fib, fib2\n" ">>> fib(500)\n" "0 1 1 2 3 5 8 13 21 34 55 89 144 233 377" msgstr "" #: ../Doc/tutorial/modules.rst:98 msgid "" "This does not introduce the module name from which the imports are taken in " "the local namespace (so in the example, ``fibo`` is not defined)." msgstr "" "Esto no introduce en el espacio de nombres local el nombre del módulo desde " "el cual se está importando (por lo tanto, en el ejemplo, ``fibo`` no esta " "definido)." #: ../Doc/tutorial/modules.rst:101 msgid "There is even a variant to import all names that a module defines::" msgstr "" "Hay incluso una variante para importar todos los nombres que un módulo " "define::" #: ../Doc/tutorial/modules.rst:103 msgid "" ">>> from fibo import *\n" ">>> fib(500)\n" "0 1 1 2 3 5 8 13 21 34 55 89 144 233 377" msgstr "" #: ../Doc/tutorial/modules.rst:107 msgid "" "This imports all names except those beginning with an underscore (``_``). In " "most cases Python programmers do not use this facility since it introduces " "an unknown set of names into the interpreter, possibly hiding some things " "you have already defined." msgstr "" "Esto importa todos los nombres excepto los que inician con un guión bajo " "(``_``). La mayoría de las veces los programadores de Python no usan esto ya " "que introduce en el intérprete un conjunto de nombres desconocido, " "posiblemente escondiendo algunas de las definiciones previas." #: ../Doc/tutorial/modules.rst:112 msgid "" "Note that in general the practice of importing ``*`` from a module or " "package is frowned upon, since it often causes poorly readable code. " "However, it is okay to use it to save typing in interactive sessions." msgstr "" "Nótese que en general la práctica de importar ``*`` de un módulo o paquete " "está muy mal vista, ya que frecuentemente genera código poco legible. Sin " "embargo, está bien usarlo para ahorrar tecleo en sesiones interactivas." #: ../Doc/tutorial/modules.rst:116 msgid "" "If the module name is followed by :keyword:`!as`, then the name following :" "keyword:`!as` is bound directly to the imported module." msgstr "" "Si el nombre del módulo es seguido por :keyword:`!as`, el nombre siguiendo :" "keyword:`!as` queda ligado directamente al módulo importado." #: ../Doc/tutorial/modules.rst:121 msgid "" ">>> import fibo as fib\n" ">>> fib.fib(500)\n" "0 1 1 2 3 5 8 13 21 34 55 89 144 233 377" msgstr "" #: ../Doc/tutorial/modules.rst:125 msgid "" "This is effectively importing the module in the same way that ``import " "fibo`` will do, with the only difference of it being available as ``fib``." msgstr "" "Esto es básicamente importar el módulo de la misma forma que se haría con " "``import fibo``, con la única diferencia en que se encuentra accesible como " "``fib``." #: ../Doc/tutorial/modules.rst:128 msgid "" "It can also be used when utilising :keyword:`from` with similar effects::" msgstr "" "También se puede utilizar cuando se utiliza :keyword:`from` con efectos " "similares::" #: ../Doc/tutorial/modules.rst:130 msgid "" ">>> from fibo import fib as fibonacci\n" ">>> fibonacci(500)\n" "0 1 1 2 3 5 8 13 21 34 55 89 144 233 377" msgstr "" #: ../Doc/tutorial/modules.rst:137 msgid "" "For efficiency reasons, each module is only imported once per interpreter " "session. Therefore, if you change your modules, you must restart the " "interpreter -- or, if it's just one module you want to test interactively, " "use :func:`importlib.reload`, e.g. ``import importlib; importlib." "reload(modulename)``." msgstr "" "Por razones de eficiencia, cada módulo es importado solo una vez por sesión " "del intérprete. Por lo tanto, si cambias tus módulos, debes reiniciar el " "interprete -- ó, si es un solo módulo que quieres probar de forma " "interactiva, usa :func:`importlib.reload`, por ejemplo: ``import importlib; " "importlib.reload(modulename)``." #: ../Doc/tutorial/modules.rst:147 msgid "Executing modules as scripts" msgstr "Ejecutar módulos como scripts" #: ../Doc/tutorial/modules.rst:149 msgid "When you run a Python module with ::" msgstr "Cuando ejecutes un módulo de Python con ::" #: ../Doc/tutorial/modules.rst:151 msgid "python fibo.py " msgstr "" #: ../Doc/tutorial/modules.rst:153 msgid "" "the code in the module will be executed, just as if you imported it, but " "with the ``__name__`` set to ``\"__main__\"``. That means that by adding " "this code at the end of your module::" msgstr "" "el código en el módulo será ejecutado, tal como si lo hubieses importado, " "pero con ``__name__`` con el valor de ``\"__main__\"``. Eso significa que " "agregando este código al final de tu módulo::" #: ../Doc/tutorial/modules.rst:157 msgid "" "if __name__ == \"__main__\":\n" " import sys\n" " fib(int(sys.argv[1]))" msgstr "" #: ../Doc/tutorial/modules.rst:161 msgid "" "you can make the file usable as a script as well as an importable module, " "because the code that parses the command line only runs if the module is " "executed as the \"main\" file:" msgstr "" "puedes hacer que el archivo sea utilizable tanto como script, como módulo " "importable, porque el código que analiza la línea de órdenes sólo se ejecuta " "si el módulo es ejecutado como archivo principal:" #: ../Doc/tutorial/modules.rst:165 msgid "" "$ python fibo.py 50\n" "0 1 1 2 3 5 8 13 21 34" msgstr "" #: ../Doc/tutorial/modules.rst:170 msgid "If the module is imported, the code is not run::" msgstr "Si el módulo se importa, ese código no se ejecuta::" #: ../Doc/tutorial/modules.rst:172 msgid "" ">>> import fibo\n" ">>>" msgstr "" #: ../Doc/tutorial/modules.rst:175 msgid "" "This is often used either to provide a convenient user interface to a " "module, or for testing purposes (running the module as a script executes a " "test suite)." msgstr "" "Esto es frecuentemente usado para proveer al módulo una interfaz de usuario " "conveniente, o para fines de prueba (ejecutar el módulo como un script que " "ejecuta un conjunto de pruebas)." #: ../Doc/tutorial/modules.rst:182 msgid "The Module Search Path" msgstr "El camino de búsqueda de los módulos" #: ../Doc/tutorial/modules.rst:186 msgid "" "When a module named :mod:`!spam` is imported, the interpreter first searches " "for a built-in module with that name. These module names are listed in :data:" "`sys.builtin_module_names`. If not found, it then searches for a file named :" "file:`spam.py` in a list of directories given by the variable :data:`sys." "path`. :data:`sys.path` is initialized from these locations:" msgstr "" "Cuando se importa un módulo llamado :mod:`!spam`, el intérprete busca " "primero por un módulo con ese nombre que esté integrado en el intérprete. " "Estos nombres de módulos están listados en :data:`sys.builtin_module_names`. " "Si no lo encuentra, entonces busca un archivo llamado :file:`spam.py` en una " "lista de directorios especificada por la variable :data:`sys.path`. :data:" "`sys.path` se inicializa con las siguientes ubicaciones:" #: ../Doc/tutorial/modules.rst:192 msgid "" "The directory containing the input script (or the current directory when no " "file is specified)." msgstr "" "El directorio que contiene el script de entrada (o el directorio actual " "cuando no se especifica archivo)." #: ../Doc/tutorial/modules.rst:194 msgid "" ":envvar:`PYTHONPATH` (a list of directory names, with the same syntax as the " "shell variable :envvar:`PATH`)." msgstr "" ":envvar:`PYTHONPATH` (una lista de nombres de directorios, con la misma " "sintaxis que la variable de la terminal :envvar:`PATH`)." #: ../Doc/tutorial/modules.rst:196 msgid "" "The installation-dependent default (by convention including a ``site-" "packages`` directory, handled by the :mod:`site` module)." msgstr "" "El valor predeterminado dependiente de la instalación (por convención " "incluye un directorio ``site-packages``, manejado por el módulo :mod:`site`)." #: ../Doc/tutorial/modules.rst:199 msgid "More details are at :ref:`sys-path-init`." msgstr "Más detalles en :ref:`sys-path-init`." #: ../Doc/tutorial/modules.rst:202 msgid "" "On file systems which support symlinks, the directory containing the input " "script is calculated after the symlink is followed. In other words the " "directory containing the symlink is **not** added to the module search path." msgstr "" "En los sistemas de archivo que soportan enlaces simbólicos, el directorio " "que contiene el script de entrada es calculado luego de seguir el enlace " "simbólico. En otras palabras, el directorio que contiene el enlace simbólico " "**no** es agregado al camino de búsqueda del módulo." #: ../Doc/tutorial/modules.rst:206 msgid "" "After initialization, Python programs can modify :data:`sys.path`. The " "directory containing the script being run is placed at the beginning of the " "search path, ahead of the standard library path. This means that scripts in " "that directory will be loaded instead of modules of the same name in the " "library directory. This is an error unless the replacement is intended. See " "section :ref:`tut-standardmodules` for more information." msgstr "" "Luego de la inicialización, los programas Python pueden modificar :data:`sys." "path`. El directorio que contiene el script que se está ejecutando se ubica " "al principio de la búsqueda, adelante de la biblioteca estándar. Esto " "significa que se cargarán scripts en ese directorio en lugar de módulos de " "la biblioteca estándar con el mismo nombre. Esto es un error a menos que se " "esté reemplazando intencionalmente. Mirá la sección :ref:`tut-" "standardmodules` para más información." #: ../Doc/tutorial/modules.rst:219 msgid "\"Compiled\" Python files" msgstr "Archivos \"compilados\" de Python" #: ../Doc/tutorial/modules.rst:221 msgid "" "To speed up loading modules, Python caches the compiled version of each " "module in the ``__pycache__`` directory under the name :file:`module." "{version}.pyc`, where the version encodes the format of the compiled file; " "it generally contains the Python version number. For example, in CPython " "release 3.3 the compiled version of spam.py would be cached as ``__pycache__/" "spam.cpython-33.pyc``. This naming convention allows compiled modules from " "different releases and different versions of Python to coexist." msgstr "" "Para acelerar la carga de módulos, Python cachea las versiones compiladas de " "cada módulo en el directorio ``__pycache__`` bajo el nombre :file:`module." "{version}.pyc`, dónde la versión codifica el formato del archivo compilado; " "generalmente contiene el número de versión de Python. Por ejemplo, en " "CPython *release* 3.3 la versión compilada de spam.py sería cacheada como " "``__pycache__/spam.cpython-33.pyc``. Este convención de nombre permite " "compilar módulos desde diferentes *releases* y versiones de Python para " "coexistir." #: ../Doc/tutorial/modules.rst:229 msgid "" "Python checks the modification date of the source against the compiled " "version to see if it's out of date and needs to be recompiled. This is a " "completely automatic process. Also, the compiled modules are platform-" "independent, so the same library can be shared among systems with different " "architectures." msgstr "" "Python chequea la fecha de modificación de la fuente contra la versión " "compilada para ver si esta es obsoleta y necesita ser recompilada. Esto es " "un proceso completamente automático. También, los módulos compilados son " "independientes de la plataforma, así que la misma biblioteca puede ser " "compartida a través de sistemas con diferentes arquitecturas." #: ../Doc/tutorial/modules.rst:234 msgid "" "Python does not check the cache in two circumstances. First, it always " "recompiles and does not store the result for the module that's loaded " "directly from the command line. Second, it does not check the cache if " "there is no source module. To support a non-source (compiled only) " "distribution, the compiled module must be in the source directory, and there " "must not be a source module." msgstr "" "Python no chequea el caché en dos circunstancias. Primero, siempre recompila " "y no graba el resultado del módulo que es cargado directamente desde la " "línea de comando. Segundo, no chequea el caché si no hay módulo fuente. Para " "soportar una distribución sin fuente (solo compilada), el módulo compilado " "debe estar en el directorio origen, y no debe haber un módulo fuente." #: ../Doc/tutorial/modules.rst:241 msgid "Some tips for experts:" msgstr "Algunos consejos para expertos:" #: ../Doc/tutorial/modules.rst:243 msgid "" "You can use the :option:`-O` or :option:`-OO` switches on the Python command " "to reduce the size of a compiled module. The ``-O`` switch removes assert " "statements, the ``-OO`` switch removes both assert statements and __doc__ " "strings. Since some programs may rely on having these available, you should " "only use this option if you know what you're doing. \"Optimized\" modules " "have an ``opt-`` tag and are usually smaller. Future releases may change " "the effects of optimization." msgstr "" "Puedes usar los modificadores :option:`-O` o :option:`-OO` en el comando de " "Python para reducir el tamaño del módulo compilado. El modificador ``-O`` " "remueve las declaraciones *assert*, el modificador ``-OO`` remueve " "declaraciones *assert* y cadenas *__doc__*. Dado que algunos programas " "pueden confiar en tenerlos disponibles, solo deberías usar esta opción si " "conoces lo que estás haciendo. Los módulos \"optimizados\" tienen una " "etiqueta ``opt-`` y generalmente son mas pequeños. *Releases* futuras pueden " "cambiar los efectos de la optimización." #: ../Doc/tutorial/modules.rst:251 msgid "" "A program doesn't run any faster when it is read from a ``.pyc`` file than " "when it is read from a ``.py`` file; the only thing that's faster about ``." "pyc`` files is the speed with which they are loaded." msgstr "" "Un programa no se ejecuta mas rápido cuando es leído de un archivo ``.pyc`` " "que cuando es leído de un archivo ``.py``; la única cosa que es mas rápida " "en los archivos ``.pyc`` es la velocidad con la cual son cargados." #: ../Doc/tutorial/modules.rst:255 msgid "" "The module :mod:`compileall` can create .pyc files for all modules in a " "directory." msgstr "" "El módulo :mod:`compileall` puede crear archivos .pyc para todos los módulos " "en un directorio." #: ../Doc/tutorial/modules.rst:258 msgid "" "There is more detail on this process, including a flow chart of the " "decisions, in :pep:`3147`." msgstr "" "Hay mas detalle de este proceso, incluyendo un diagrama de flujo de " "decisiones, en :pep:`3147`." #: ../Doc/tutorial/modules.rst:265 msgid "Standard Modules" msgstr "Módulos estándar" #: ../Doc/tutorial/modules.rst:269 msgid "" "Python comes with a library of standard modules, described in a separate " "document, the Python Library Reference (\"Library Reference\" hereafter). " "Some modules are built into the interpreter; these provide access to " "operations that are not part of the core of the language but are " "nevertheless built in, either for efficiency or to provide access to " "operating system primitives such as system calls. The set of such modules " "is a configuration option which also depends on the underlying platform. " "For example, the :mod:`winreg` module is only provided on Windows systems. " "One particular module deserves some attention: :mod:`sys`, which is built " "into every Python interpreter. The variables ``sys.ps1`` and ``sys.ps2`` " "define the strings used as primary and secondary prompts::" msgstr "" "Python viene con una biblioteca de módulos estándar, descrita en un " "documento separado, la Referencia de la Biblioteca de Python (de aquí en " "más, \"Referencia de la Biblioteca\"). Algunos módulos se integran en el " "intérprete; estos proveen acceso a operaciones que no son parte del núcleo " "del lenguaje pero que sin embargo están integrados, tanto por eficiencia " "como para proveer acceso a primitivas del sistema operativo, como llamadas " "al sistema. El conjunto de tales módulos es una opción de configuración que " "también depende de la plataforma subyacente. Por ejemplo, el módulo :mod:" "`winreg` sólo se provee en sistemas Windows. Un módulo en particular merece " "algo de atención: :mod:`sys`, el que está integrado en todos los intérpretes " "de Python. Las variables ``sys.ps1`` y ``sys.ps2`` definen las cadenas " "usadas como cursores primarios y secundarios::" #: ../Doc/tutorial/modules.rst:281 msgid "" ">>> import sys\n" ">>> sys.ps1\n" "'>>> '\n" ">>> sys.ps2\n" "'... '\n" ">>> sys.ps1 = 'C> '\n" "C> print('Yuck!')\n" "Yuck!\n" "C>" msgstr "" #: ../Doc/tutorial/modules.rst:292 msgid "" "These two variables are only defined if the interpreter is in interactive " "mode." msgstr "" "Estas dos variables están solamente definidas si el intérprete está en modo " "interactivo." #: ../Doc/tutorial/modules.rst:294 msgid "" "The variable ``sys.path`` is a list of strings that determines the " "interpreter's search path for modules. It is initialized to a default path " "taken from the environment variable :envvar:`PYTHONPATH`, or from a built-in " "default if :envvar:`PYTHONPATH` is not set. You can modify it using " "standard list operations::" msgstr "" "La variable ``sys.path`` es una lista de cadenas que determinan el camino de " "búsqueda del intérprete para los módulos. Se inicializa por omisión a un " "camino tomado de la variable de entorno :envvar:`PYTHONPATH`, o a un valor " "predefinido en el intérprete si :envvar:`PYTHONPATH` no está configurada. Lo " "puedes modificar usando las operaciones estándar de listas::" #: ../Doc/tutorial/modules.rst:300 msgid "" ">>> import sys\n" ">>> sys.path.append('/ufs/guido/lib/python')" msgstr "" #: ../Doc/tutorial/modules.rst:307 msgid "The :func:`dir` Function" msgstr "La función :func:`dir`" #: ../Doc/tutorial/modules.rst:309 msgid "" "The built-in function :func:`dir` is used to find out which names a module " "defines. It returns a sorted list of strings::" msgstr "" "La función integrada :func:`dir` se usa para encontrar qué nombres define un " "módulo. Retorna una lista ordenada de cadenas::" #: ../Doc/tutorial/modules.rst:312 msgid "" ">>> import fibo, sys\n" ">>> dir(fibo)\n" "['__name__', 'fib', 'fib2']\n" ">>> dir(sys) \n" "['__breakpointhook__', '__displayhook__', '__doc__', '__excepthook__',\n" " '__interactivehook__', '__loader__', '__name__', '__package__', " "'__spec__',\n" " '__stderr__', '__stdin__', '__stdout__', '__unraisablehook__',\n" " '_clear_type_cache', '_current_frames', '_debugmallocstats', '_framework',\n" " '_getframe', '_git', '_home', '_xoptions', 'abiflags', 'addaudithook',\n" " 'api_version', 'argv', 'audit', 'base_exec_prefix', 'base_prefix',\n" " 'breakpointhook', 'builtin_module_names', 'byteorder', 'call_tracing',\n" " 'callstats', 'copyright', 'displayhook', 'dont_write_bytecode', " "'exc_info',\n" " 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info',\n" " 'float_repr_style', 'get_asyncgen_hooks', " "'get_coroutine_origin_tracking_depth',\n" " 'getallocatedblocks', 'getdefaultencoding', 'getdlopenflags',\n" " 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile',\n" " 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval',\n" " 'gettrace', 'hash_info', 'hexversion', 'implementation', 'int_info',\n" " 'intern', 'is_finalizing', 'last_traceback', 'last_type', 'last_value',\n" " 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks',\n" " 'path_importer_cache', 'platform', 'prefix', 'ps1', 'ps2', " "'pycache_prefix',\n" " 'set_asyncgen_hooks', 'set_coroutine_origin_tracking_depth', " "'setdlopenflags',\n" " 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', " "'stderr',\n" " 'stdin', 'stdout', 'thread_info', 'unraisablehook', 'version', " "'version_info',\n" " 'warnoptions']" msgstr "" #: ../Doc/tutorial/modules.rst:338 msgid "" "Without arguments, :func:`dir` lists the names you have defined currently::" msgstr "" "Sin argumentos, :func:`dir` lista los nombres que tienes actualmente " "definidos::" #: ../Doc/tutorial/modules.rst:340 msgid "" ">>> a = [1, 2, 3, 4, 5]\n" ">>> import fibo\n" ">>> fib = fibo.fib\n" ">>> dir()\n" "['__builtins__', '__name__', 'a', 'fib', 'fibo', 'sys']" msgstr "" #: ../Doc/tutorial/modules.rst:346 msgid "" "Note that it lists all types of names: variables, modules, functions, etc." msgstr "" "Nótese que lista todos los tipos de nombres: variables, módulos, funciones, " "etc." #: ../Doc/tutorial/modules.rst:350 msgid "" ":func:`dir` does not list the names of built-in functions and variables. If " "you want a list of those, they are defined in the standard module :mod:" "`builtins`::" msgstr "" ":func:`dir` no lista los nombres de las funciones y variables integradas. Si " "quieres una lista de esos, están definidos en el módulo estándar :mod:" "`builtins`::" #: ../Doc/tutorial/modules.rst:354 msgid "" ">>> import builtins\n" ">>> dir(builtins) \n" "['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException',\n" " 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning',\n" " 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError',\n" " 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning',\n" " 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False',\n" " 'FileExistsError', 'FileNotFoundError', 'FloatingPointError',\n" " 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError',\n" " 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError',\n" " 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError',\n" " 'MemoryError', 'NameError', 'None', 'NotADirectoryError', " "'NotImplemented',\n" " 'NotImplementedError', 'OSError', 'OverflowError',\n" " 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError',\n" " 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning',\n" " 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError',\n" " 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError',\n" " 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError',\n" " 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning',\n" " 'ValueError', 'Warning', 'ZeroDivisionError', '_', '__build_class__',\n" " '__debug__', '__doc__', '__import__', '__name__', '__package__', 'abs',\n" " 'all', 'any', 'ascii', 'bin', 'bool', 'bytearray', 'bytes', 'callable',\n" " 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits',\n" " 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit',\n" " 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr',\n" " 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass',\n" " 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview',\n" " 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property',\n" " 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice',\n" " 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars',\n" " 'zip']" msgstr "" #: ../Doc/tutorial/modules.rst:389 msgid "Packages" msgstr "Paquetes" #: ../Doc/tutorial/modules.rst:391 msgid "" "Packages are a way of structuring Python's module namespace by using " "\"dotted module names\". For example, the module name :mod:`!A.B` " "designates a submodule named ``B`` in a package named ``A``. Just like the " "use of modules saves the authors of different modules from having to worry " "about each other's global variable names, the use of dotted module names " "saves the authors of multi-module packages like NumPy or Pillow from having " "to worry about each other's module names." msgstr "" "Los Paquetes son una forma de estructurar el espacio de nombres de módulos " "de Python usando \"nombres de módulo con puntos\". Por ejemplo, el nombre " "del módulo :mod:`!A.B` designa un submódulo ``B`` en un paquete llamado " "``A``. Así como el uso de módulos salva a los autores de diferentes módulos " "de tener que preocuparse por los nombres de las variables globales de los " "demás, el uso de nombres de módulo con puntos evita que los autores de " "paquetes multimódulos, como NumPy o Pillow, tengan que preocuparse por los " "nombres de los módulos de los demás." #: ../Doc/tutorial/modules.rst:399 msgid "" "Suppose you want to design a collection of modules (a \"package\") for the " "uniform handling of sound files and sound data. There are many different " "sound file formats (usually recognized by their extension, for example: :" "file:`.wav`, :file:`.aiff`, :file:`.au`), so you may need to create and " "maintain a growing collection of modules for the conversion between the " "various file formats. There are also many different operations you might " "want to perform on sound data (such as mixing, adding echo, applying an " "equalizer function, creating an artificial stereo effect), so in addition " "you will be writing a never-ending stream of modules to perform these " "operations. Here's a possible structure for your package (expressed in " "terms of a hierarchical filesystem):" msgstr "" "Supongamos que quieres designar una colección de módulos (un \"paquete\") " "para el manejo uniforme de archivos y datos de sonidos. Hay diferentes " "formatos de archivos de sonido (normalmente reconocidos por su extensión, " "por ejemplo: :file:`.wav`, :file:`.aiff`, :file:`.au`), por lo que tienes " "que crear y mantener una colección siempre creciente de módulos para la " "conversión entre los distintos formatos de archivos. Hay muchas operaciones " "diferentes que quizás quieras ejecutar en los datos de sonido (como " "mezclarlos, añadir eco, aplicar una función ecualizadora, crear un efecto " "estéreo artificial), por lo que además estarás escribiendo una lista sin fin " "de módulos para realizar estas operaciones. Aquí hay una posible estructura " "para tu paquete (expresados en términos de un sistema jerárquico de " "archivos):" #: ../Doc/tutorial/modules.rst:410 msgid "" "sound/ Top-level package\n" " __init__.py Initialize the sound package\n" " formats/ Subpackage for file format conversions\n" " __init__.py\n" " wavread.py\n" " wavwrite.py\n" " aiffread.py\n" " aiffwrite.py\n" " auread.py\n" " auwrite.py\n" " ...\n" " effects/ Subpackage for sound effects\n" " __init__.py\n" " echo.py\n" " surround.py\n" " reverse.py\n" " ...\n" " filters/ Subpackage for filters\n" " __init__.py\n" " equalizer.py\n" " vocoder.py\n" " karaoke.py\n" " ..." msgstr "" #: ../Doc/tutorial/modules.rst:436 msgid "" "When importing the package, Python searches through the directories on ``sys." "path`` looking for the package subdirectory." msgstr "" "Al importar el paquete, Python busca a través de los directorios en ``sys." "path``, buscando el sub-directorio del paquete." #: ../Doc/tutorial/modules.rst:439 #, fuzzy msgid "" "The :file:`__init__.py` files are required to make Python treat directories " "containing the file as packages (unless using a :term:`namespace package`, a " "relatively advanced feature). This prevents directories with a common name, " "such as ``string``, from unintentionally hiding valid modules that occur " "later on the module search path. In the simplest case, :file:`__init__.py` " "can just be an empty file, but it can also execute initialization code for " "the package or set the ``__all__`` variable, described later." msgstr "" "Los archivos :file:`__init__.py` son obligatorios para que Python trate los " "directorios que contienen los archivos como paquetes. Esto evita que los " "directorios con un nombre común, como ``string``, oculten involuntariamente " "módulos válidos que se producen luego en el camino de búsqueda del módulo. " "En el caso mas simple, :file:`__init__.py` puede ser solo un archivo vacío, " "pero también puede ejecutar código de inicialización para el paquete o el " "conjunto de variables ``__all__``, descriptas luego." #: ../Doc/tutorial/modules.rst:447 msgid "" "Users of the package can import individual modules from the package, for " "example::" msgstr "" "Los usuarios del paquete pueden importar módulos individuales del mismo, por " "ejemplo::" #: ../Doc/tutorial/modules.rst:450 msgid "import sound.effects.echo" msgstr "" #: ../Doc/tutorial/modules.rst:452 msgid "" "This loads the submodule :mod:`!sound.effects.echo`. It must be referenced " "with its full name. ::" msgstr "" "Esto carga el submódulo :mod:`!sound.effects.echo`. Debe hacerse referencia " "al mismo con el nombre completo. ::" #: ../Doc/tutorial/modules.rst:455 msgid "sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)" msgstr "" #: ../Doc/tutorial/modules.rst:457 msgid "An alternative way of importing the submodule is::" msgstr "Otra alternativa para importar el submódulo es::" #: ../Doc/tutorial/modules.rst:459 msgid "from sound.effects import echo" msgstr "" #: ../Doc/tutorial/modules.rst:461 msgid "" "This also loads the submodule :mod:`!echo`, and makes it available without " "its package prefix, so it can be used as follows::" msgstr "" "Esto también carga el submódulo :mod:`!echo`, y lo deja disponible sin su " "prefijo de paquete, por lo que puede usarse así::" #: ../Doc/tutorial/modules.rst:464 msgid "echo.echofilter(input, output, delay=0.7, atten=4)" msgstr "" #: ../Doc/tutorial/modules.rst:466 msgid "" "Yet another variation is to import the desired function or variable " "directly::" msgstr "" "Otra variación más es importar la función o variable deseadas directamente::" #: ../Doc/tutorial/modules.rst:468 msgid "from sound.effects.echo import echofilter" msgstr "" #: ../Doc/tutorial/modules.rst:470 msgid "" "Again, this loads the submodule :mod:`!echo`, but this makes its function :" "func:`!echofilter` directly available::" msgstr "" "De nuevo, esto carga el submódulo :mod:`!echo`, pero deja directamente " "disponible a la función :func:`!echofilter`::" #: ../Doc/tutorial/modules.rst:473 msgid "echofilter(input, output, delay=0.7, atten=4)" msgstr "" #: ../Doc/tutorial/modules.rst:475 msgid "" "Note that when using ``from package import item``, the item can be either a " "submodule (or subpackage) of the package, or some other name defined in the " "package, like a function, class or variable. The ``import`` statement first " "tests whether the item is defined in the package; if not, it assumes it is a " "module and attempts to load it. If it fails to find it, an :exc:" "`ImportError` exception is raised." msgstr "" "Nótese que al usar ``from package import item``, el ítem puede ser tanto un " "submódulo (o subpaquete) del paquete, o algún otro nombre definido en el " "paquete, como una función, clase, o variable. La declaración ``import`` " "primero verifica si el ítem está definido en el paquete; si no, asume que es " "un módulo y trata de cargarlo. Si no lo puede encontrar, se genera una " "excepción :exc:`ImportError`." #: ../Doc/tutorial/modules.rst:482 msgid "" "Contrarily, when using syntax like ``import item.subitem.subsubitem``, each " "item except for the last must be a package; the last item can be a module or " "a package but can't be a class or function or variable defined in the " "previous item." msgstr "" "Por otro lado, cuando se usa la sintaxis como ``import item.subitem." "subsubitem``, cada ítem excepto el último debe ser un paquete; el mismo " "puede ser un módulo o un paquete pero no puede ser una clase, función o " "variable definida en el ítem previo." #: ../Doc/tutorial/modules.rst:491 msgid "Importing \\* From a Package" msgstr "Importar \\* desde un paquete" #: ../Doc/tutorial/modules.rst:495 msgid "" "Now what happens when the user writes ``from sound.effects import *``? " "Ideally, one would hope that this somehow goes out to the filesystem, finds " "which submodules are present in the package, and imports them all. This " "could take a long time and importing sub-modules might have unwanted side-" "effects that should only happen when the sub-module is explicitly imported." msgstr "" "Ahora, ¿qué sucede cuando el usuario escribe ``from sound.effects import " "*``? Idealmente, uno esperaría que esto de alguna manera vaya al sistema de " "archivos, encuentre cuales submódulos están presentes en el paquete, y los " "importe a todos. Esto puede tardar mucho y el importar sub-módulos puede " "tener efectos secundarios no deseados que sólo deberían ocurrir cuando se " "importe explícitamente el sub-módulo." #: ../Doc/tutorial/modules.rst:501 msgid "" "The only solution is for the package author to provide an explicit index of " "the package. The :keyword:`import` statement uses the following convention: " "if a package's :file:`__init__.py` code defines a list named ``__all__``, it " "is taken to be the list of module names that should be imported when ``from " "package import *`` is encountered. It is up to the package author to keep " "this list up-to-date when a new version of the package is released. Package " "authors may also decide not to support it, if they don't see a use for " "importing \\* from their package. For example, the file :file:`sound/" "effects/__init__.py` could contain the following code::" msgstr "" "La única solución es que el autor del paquete provea un índice explícito del " "paquete. La declaración :keyword:`import` usa la siguiente convención: si " "el código del :file:`__init__.py` de un paquete define una lista llamada " "``__all__``, se toma como la lista de los nombres de módulos que deberían " "ser importados cuando se hace ``from package import *``. Es tarea del autor " "del paquete mantener actualizada esta lista cuando se libera una nueva " "versión del paquete. Los autores de paquetes podrían decidir no soportarlo, " "si no ven un uso para importar \\* en sus paquetes. Por ejemplo, el " "archivo :file:`sound/effects/__init__.py` podría contener el siguiente " "código::" #: ../Doc/tutorial/modules.rst:511 msgid "__all__ = [\"echo\", \"surround\", \"reverse\"]" msgstr "" #: ../Doc/tutorial/modules.rst:513 msgid "" "This would mean that ``from sound.effects import *`` would import the three " "named submodules of the :mod:`!sound.effects` package." msgstr "" "Esto significaría que ``from sound.effects import *`` importaría esos tres " "submódulos del paquete :mod:`!sound.effects`." #: ../Doc/tutorial/modules.rst:516 msgid "" "Be aware that submodules might become shadowed by locally defined names. For " "example, if you added a ``reverse`` function to the :file:`sound/effects/" "__init__.py` file, the ``from sound.effects import *`` would only import the " "two submodules ``echo`` and ``surround``, but *not* the ``reverse`` " "submodule, because it is shadowed by the locally defined ``reverse`` " "function::" msgstr "" "Ten en cuenta que los submódulos pueden quedar ocultos por nombres definidos " "localmente. Por ejemplo, si agregaste una función llamada ``reverse`` al " "archivo :file:`sound/effects/__init__.py`, ``from sound.effects import *`` " "solo importaría los dos submódulos ``echo`` y ``surround``, pero *no* el " "submódulo ``reverse`` porque queda oculto por la función ``reverse`` " "definida localmente::" #: ../Doc/tutorial/modules.rst:523 msgid "" "__all__ = [\n" " \"echo\", # refers to the 'echo.py' file\n" " \"surround\", # refers to the 'surround.py' file\n" " \"reverse\", # !!! refers to the 'reverse' function now !!!\n" "]\n" "\n" "def reverse(msg: str): # <-- this name shadows the 'reverse.py' submodule\n" " return msg[::-1] # in the case of a 'from sound.effects import *'" msgstr "" #: ../Doc/tutorial/modules.rst:532 msgid "" "If ``__all__`` is not defined, the statement ``from sound.effects import *`` " "does *not* import all submodules from the package :mod:`!sound.effects` into " "the current namespace; it only ensures that the package :mod:`!sound." "effects` has been imported (possibly running any initialization code in :" "file:`__init__.py`) and then imports whatever names are defined in the " "package. This includes any names defined (and submodules explicitly loaded) " "by :file:`__init__.py`. It also includes any submodules of the package that " "were explicitly loaded by previous :keyword:`import` statements. Consider " "this code::" msgstr "" "Si no se define ``__all__``, la declaración ``from sound.effects import *`` " "*no* importa todos los submódulos del paquete :mod:`!sound.effects` al " "espacio de nombres actual; sólo se asegura que se haya importado el paquete :" "mod:`!sound.effects` (posiblemente ejecutando algún código de inicialización " "que haya en :file:`__init__.py`) y luego importa aquellos nombres que estén " "definidos en el paquete. Esto incluye cualquier nombre definido (y " "submódulos explícitamente cargados) por :file:`__init__.py`. También incluye " "cualquier submódulo del paquete que pudiera haber sido explícitamente " "cargado por declaraciones :keyword:`import` previas. Considere este código::" #: ../Doc/tutorial/modules.rst:541 msgid "" "import sound.effects.echo\n" "import sound.effects.surround\n" "from sound.effects import *" msgstr "" #: ../Doc/tutorial/modules.rst:545 msgid "" "In this example, the :mod:`!echo` and :mod:`!surround` modules are imported " "in the current namespace because they are defined in the :mod:`!sound." "effects` package when the ``from...import`` statement is executed. (This " "also works when ``__all__`` is defined.)" msgstr "" "En este ejemplo, los módulos :mod:`!echo` y :mod:`!surround` se importan en " "el espacio de nombre actual porque están definidos en el paquete :mod:`!" "sound.effects` cuando se ejecuta la declaración ``from...import``. (Esto " "también funciona cuando se define ``__all__``)." #: ../Doc/tutorial/modules.rst:550 msgid "" "Although certain modules are designed to export only names that follow " "certain patterns when you use ``import *``, it is still considered bad " "practice in production code." msgstr "" "A pesar de que ciertos módulos están diseñados para exportar solo nombres " "que siguen ciertos patrones cuando uses ``import *``, también se considera " "una mala práctica en código de producción." #: ../Doc/tutorial/modules.rst:554 msgid "" "Remember, there is nothing wrong with using ``from package import " "specific_submodule``! In fact, this is the recommended notation unless the " "importing module needs to use submodules with the same name from different " "packages." msgstr "" "Recuerda, ¡no hay nada malo al usar ``from package import " "specific_submodule``! De hecho, esta es la notación recomendada a menos que " "el módulo que importamos necesite usar submódulos con el mismo nombre desde " "un paquete diferente." #: ../Doc/tutorial/modules.rst:563 msgid "Intra-package References" msgstr "Referencias internas en paquetes" #: ../Doc/tutorial/modules.rst:565 msgid "" "When packages are structured into subpackages (as with the :mod:`!sound` " "package in the example), you can use absolute imports to refer to submodules " "of siblings packages. For example, if the module :mod:`!sound.filters." "vocoder` needs to use the :mod:`!echo` module in the :mod:`!sound.effects` " "package, it can use ``from sound.effects import echo``." msgstr "" "Cuando se estructuran los paquetes en sub-paquetes (como en el ejemplo :mod:" "`!sound`), puedes usar imports absolutos para referirte a submódulos de " "paquetes hermanos. Por ejemplo, si el módulo :mod:`!sound.filters.vocoder` " "necesita usar el módulo :mod:`!echo` en el paquete :mod:`!sound.effects`, " "puede hacer ``from sound.effects import echo``." #: ../Doc/tutorial/modules.rst:571 msgid "" "You can also write relative imports, with the ``from module import name`` " "form of import statement. These imports use leading dots to indicate the " "current and parent packages involved in the relative import. From the :mod:" "`!surround` module for example, you might use::" msgstr "" "También puedes escribir imports relativos con la forma ``from module import " "name``. Estos imports usan puntos adelante para indicar los paquetes " "actuales o paquetes padres involucrados en el import relativo. En el " "ejemplo :mod:`!surround`, podrías hacer::" #: ../Doc/tutorial/modules.rst:576 msgid "" "from . import echo\n" "from .. import formats\n" "from ..filters import equalizer" msgstr "" #: ../Doc/tutorial/modules.rst:580 msgid "" "Note that relative imports are based on the name of the current module. " "Since the name of the main module is always ``\"__main__\"``, modules " "intended for use as the main module of a Python application must always use " "absolute imports." msgstr "" "Nótese que los imports relativos se basan en el nombre del módulo actual. Ya " "que el nombre del módulo principal es siempre ``\"__main__\"``, los módulos " "pensados para usarse como módulo principal de una aplicación Python siempre " "deberían usar ``import`` absolutos." #: ../Doc/tutorial/modules.rst:586 msgid "Packages in Multiple Directories" msgstr "Paquetes en múltiples directorios" #: ../Doc/tutorial/modules.rst:588 msgid "" "Packages support one more special attribute, :attr:`__path__`. This is " "initialized to be a list containing the name of the directory holding the " "package's :file:`__init__.py` before the code in that file is executed. " "This variable can be modified; doing so affects future searches for modules " "and subpackages contained in the package." msgstr "" "Los paquetes soportan un atributo especial más, :attr:`__path__`. Este se " "inicializa a una lista que contiene el nombre del directorio donde está el " "archivo :file:`__init__.py` del paquete, antes de que el código en ese " "archivo se ejecute. Esta variable puede modificarse, afectando búsquedas " "futuras de módulos y subpaquetes contenidos en el paquete." #: ../Doc/tutorial/modules.rst:594 msgid "" "While this feature is not often needed, it can be used to extend the set of " "modules found in a package." msgstr "" "Aunque esta característica no se necesita frecuentemente, puede usarse para " "extender el conjunto de módulos que se encuentran en el paquete." #: ../Doc/tutorial/modules.rst:599 msgid "Footnotes" msgstr "Notas al pie" #: ../Doc/tutorial/modules.rst:600 msgid "" "In fact function definitions are also 'statements' that are 'executed'; the " "execution of a module-level function definition adds the function name to " "the module's global namespace." msgstr "" "De hecho, las definiciones de funciones también son \"declaraciones\" que se " "\"ejecutan\"; la ejecución de una definición de función a nivel de módulo, " "añade el nombre de la función en el espacio de nombres global del módulo." #: ../Doc/tutorial/modules.rst:184 ../Doc/tutorial/modules.rst:267 #: ../Doc/tutorial/modules.rst:348 msgid "module" msgstr "module" #: ../Doc/tutorial/modules.rst:184 msgid "search" msgstr "search" #: ../Doc/tutorial/modules.rst:184 msgid "path" msgstr "path" #: ../Doc/tutorial/modules.rst:267 msgid "sys" msgstr "sys" #: ../Doc/tutorial/modules.rst:348 msgid "builtins" msgstr "builtins" #: ../Doc/tutorial/modules.rst:493 msgid "__all__" msgstr "__all__"