# Copyright (C) 2001-2020, Python Software Foundation

# This file is distributed under the same license as the Python package.

# Maintained by the python-doc-es workteam.

# docs-es@python.org /

# https://mail.python.org/mailman3/lists/docs-es.python.org/

# Check https://github.com/python/python-docs-es/blob/3.8/TRANSLATORS to get

# the list of volunteers

#

msgid ""

msgstr ""

"Project-Id-Version: Python 3.8\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2024-11-21 16:38-0300\n"

"PO-Revision-Date: 2023-11-06 23:03+0100\n"

"Last-Translator: Marcos Medrano <marcosmedrano0@gmail.com>\n"

"Language: es\n"

"Language-Team: python-doc-es\n"

"Plural-Forms: nplurals=2; plural=(n != 1);\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=utf-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Generated-By: Babel 2.16.0\n"

#: ../Doc/library/__main__.rst:2

#, fuzzy

msgid ":mod:`!__main__` --- Top-level code environment"

msgstr ":mod:`__main__` --- Entorno de código de nivel máximo"

#: ../Doc/library/__main__.rst:10

msgid ""

"In Python, the special name ``__main__`` is used for two important "

"constructs:"

msgstr ""

"En Python, el nombre especial ``__main__`` es utilizado para dos constructos "

"importantes:"

#: ../Doc/library/__main__.rst:12

msgid ""

"the name of the top-level environment of the program, which can be checked "

"using the ``__name__ == '__main__'`` expression; and"

msgstr ""

"el nombre del entorno de máximo nivel del programa, que puede ser verificado "

"usando la expresión ``__name__=='__main__'``; y"

#: ../Doc/library/__main__.rst:14

msgid "the ``__main__.py`` file in Python packages."

msgstr "el archivo ``__main__.py`` en paquetes de Python."

#: ../Doc/library/__main__.rst:16

msgid ""

"Both of these mechanisms are related to Python modules; how users interact "

"with them and how they interact with each other. They are explained in "

"detail below. If you're new to Python modules, see the tutorial section :"

"ref:`tut-modules` for an introduction."

msgstr ""

"Ambos de estos mecanismos están relacionados con módulos de Python; como los "

"usuarios interactúan con ellos y como ellos interactúan entre sí. Están "

"explicados en detalle más abajo. Si estás empezando con los módulos de "

"Python, mira la sección tutorial :ref:`tut-modules` para una introducción."

#: ../Doc/library/__main__.rst:25

msgid "``__name__ == '__main__'``"

msgstr "``__name__ == '__main__'``"

#: ../Doc/library/__main__.rst:27

msgid ""

"When a Python module or package is imported, ``__name__`` is set to the "

"module's name. Usually, this is the name of the Python file itself without "

"the ``.py`` extension::"

msgstr ""

"Cuando un módulo o paquete de Python es importado, ``__name__`` es asignado "

"al nombre del módulo. Normalmente, este es el nombre del archivo de Python "

"sin la extensión ``.py``::"

#: ../Doc/library/__main__.rst:31

msgid ""

">>> import configparser\n"

">>> configparser.__name__\n"

"'configparser'"

msgstr ""

#: ../Doc/library/__main__.rst:35

msgid ""

"If the file is part of a package, ``__name__`` will also include the parent "

"package's path::"

msgstr ""

"Si el archivo es parte de un paquete, ``__name__`` también incluirá la ruta "

"del paquete padre::"

#: ../Doc/library/__main__.rst:38

msgid ""

">>> from concurrent.futures import process\n"

">>> process.__name__\n"

"'concurrent.futures.process'"

msgstr ""

#: ../Doc/library/__main__.rst:42

msgid ""

"However, if the module is executed in the top-level code environment, its "

"``__name__`` is set to the string ``'__main__'``."

msgstr ""

"Sin embargo, si el módulo es ejecutado en el entorno de código de máximo "

"nivel, su ``__name__`` se le asigna el valor del string ``'__main__'``."

#: ../Doc/library/__main__.rst:46

msgid "What is the \"top-level code environment\"?"

msgstr "¿Qué es el \"entorno de código de máximo nivel\"?"

#: ../Doc/library/__main__.rst:48

msgid ""

"``__main__`` is the name of the environment where top-level code is run. "

"\"Top-level code\" is the first user-specified Python module that starts "

"running. It's \"top-level\" because it imports all other modules that the "

"program needs. Sometimes \"top-level code\" is called an *entry point* to "

"the application."

msgstr ""

"``__main__`` es el nombre del entorno en el cual se ejecuta el código de "

"máximo nivel. \"Código de máximo nivel\" es el primer módulo de Python "

"especificado por el usuario que empieza a ejecutarse. Es \"de máximo nivel\" "

"porque importa todos los demás módulos que necesita el programa. A veces "

"\"código de máximo nivel\" es llamado un *punto de entrada* a la aplicación."

#: ../Doc/library/__main__.rst:53

msgid "The top-level code environment can be:"

msgstr "El entorno de código de máximo nivel puede ser:"

#: ../Doc/library/__main__.rst:55

msgid "the scope of an interactive prompt::"

msgstr "el ámbito de un intérprete interactivo::"

#: ../Doc/library/__main__.rst:57

#, fuzzy

msgid ""

">>> __name__\n"

"'__main__'"

msgstr "``__name__ == '__main__'``"

#: ../Doc/library/__main__.rst:60

msgid "the Python module passed to the Python interpreter as a file argument:"

msgstr ""

"el módulo de Python pasado al intérprete de Python como un argumento de "

"archivo:"

#: ../Doc/library/__main__.rst:62

msgid ""

"$ python helloworld.py\n"

"Hello, world!"

msgstr ""

#: ../Doc/library/__main__.rst:67

msgid ""

"the Python module or package passed to the Python interpreter with the :"

"option:`-m` argument:"

msgstr ""

"el módulo o paquete de Python pasado al interprete de Python con el "

"argumento :option:`-m`:"

#: ../Doc/library/__main__.rst:70

msgid ""

"$ python -m tarfile\n"

"usage: tarfile.py [-h] [-v] (...)"

msgstr ""

#: ../Doc/library/__main__.rst:75

msgid "Python code read by the Python interpreter from standard input:"

msgstr "Código de Python leído por el interprete desde input estándar:"

#: ../Doc/library/__main__.rst:77

msgid ""

"$ echo \"import this\" | python\n"

"The Zen of Python, by Tim Peters\n"

"\n"

"Beautiful is better than ugly.\n"

"Explicit is better than implicit.\n"

"..."

msgstr ""

#: ../Doc/library/__main__.rst:86

msgid ""

"Python code passed to the Python interpreter with the :option:`-c` argument:"

msgstr ""

"Código de Python pasado al intérprete Python con el argumento :option:`-c`:"

#: ../Doc/library/__main__.rst:88

msgid ""

"$ python -c \"import this\"\n"

"The Zen of Python, by Tim Peters\n"

"\n"

"Beautiful is better than ugly.\n"

"Explicit is better than implicit.\n"

"..."

msgstr ""

#: ../Doc/library/__main__.rst:97

msgid ""

"In each of these situations, the top-level module's ``__name__`` is set to "

"``'__main__'``."

msgstr ""

"En cada una de estas situaciones, al ``__name__`` del módulo de máximo nivel "

"se le asigna el valor ``'__main__'``."

#: ../Doc/library/__main__.rst:100

msgid ""

"As a result, a module can discover whether or not it is running in the top-"

"level environment by checking its own ``__name__``, which allows a common "

"idiom for conditionally executing code when the module is not initialized "

"from an import statement::"

msgstr ""

"En consecuencia, un módulo puede descubrir si se está ejecutando o no en el "

"ámbito principal al verificar su propio ``__name__``, lo cual permite un "

"vocablo común para ejecutar código condicionalmente cuando el módulo no es "

"inicializado desde una declaración de importado::"

#: ../Doc/library/__main__.rst:105

msgid ""

"if __name__ == '__main__':\n"

" # Execute when the module is not initialized from an import statement.\n"

" ..."

msgstr ""

#: ../Doc/library/__main__.rst:111

msgid ""

"For a more detailed look at how ``__name__`` is set in all situations, see "

"the tutorial section :ref:`tut-modules`."

msgstr ""

"Para una vista más detallada de como ``__name__`` es asignado en todas las "

"situaciones, ver la sección tutorial :ref:`tut-modules`."

#: ../Doc/library/__main__.rst:116 ../Doc/library/__main__.rst:239

msgid "Idiomatic Usage"

msgstr "Uso idiomático"

#: ../Doc/library/__main__.rst:118

msgid ""

"Some modules contain code that is intended for script use only, like parsing "

"command-line arguments or fetching data from standard input. If a module "

"like this was imported from a different module, for example to unit test it, "

"the script code would unintentionally execute as well."

msgstr ""

"Algunos módulos contienen código que está pensado para uso de script "

"solamente, como para interpretar argumentos de línea de comando u obtener "

"datos de la entrada estándar. Cuando un módulo como este fuese importado "

"desde un módulo distinto, por ejemplo para realizar una prueba unitaria, el "

"código del script se ejecutaría involuntariamente."

#: ../Doc/library/__main__.rst:123

msgid ""

"This is where using the ``if __name__ == '__main__'`` code block comes in "

"handy. Code within this block won't run unless the module is executed in the "

"top-level environment."

msgstr ""

"Aquí es donde es útil usar el código de bloque ``if __name__=='__main__'``. "

"El código dentro desde bloque no se ejecutará a menos que el módulo se "

"ejecute en el entorno de máximo nivel."

#: ../Doc/library/__main__.rst:127

msgid ""

"Putting as few statements as possible in the block below ``if __name__ == "

"'__main__'`` can improve code clarity and correctness. Most often, a "

"function named ``main`` encapsulates the program's primary behavior::"

msgstr ""

"Poner cuantas menos declaraciones posible en el bloque debajo de ``if "

"__name__=='__main__'`` puede mejorar la claridad y validez del código. Mas a "

"menudo, la función llamada ``main`` encapsula el comportamiento principal "

"del programa::"

#: ../Doc/library/__main__.rst:131

msgid ""

"# echo.py\n"

"\n"

"import shlex\n"

"import sys\n"

"\n"

"def echo(phrase: str) -> None:\n"

" \"\"\"A dummy wrapper around print.\"\"\"\n"

" # for demonstration purposes, you can imagine that there is some\n"

" # valuable and reusable logic inside this function\n"

" print(phrase)\n"

"\n"

"def main() -> int:\n"

" \"\"\"Echo the input arguments to standard output\"\"\"\n"

" phrase = shlex.join(sys.argv)\n"

" echo(phrase)\n"

" return 0\n"

"\n"

"if __name__ == '__main__':\n"

" sys.exit(main()) # next section explains the use of sys.exit"

msgstr ""

#: ../Doc/library/__main__.rst:151

msgid ""

"Note that if the module didn't encapsulate code inside the ``main`` function "

"but instead put it directly within the ``if __name__ == '__main__'`` block, "

"the ``phrase`` variable would be global to the entire module. This is error-"

"prone as other functions within the module could be unintentionally using "

"the global variable instead of a local name. A ``main`` function solves "

"this problem."

msgstr ""

"Note que si el módulo no encapsulase el código dentro de la función ``main`` "

"pero en vez lo pusiese directo dentro del bloque ``if "

"__name__=='__main__'``, la variable ``phrase`` sería global al módulo "

"entero. Esto está propenso a generar errores ya que otras funciones dentro "

"del módulo pudiesen estar usando involuntariamente la variable global en "

"lugar de un nombre local. Una función ``main`` resuelve este problema."

#: ../Doc/library/__main__.rst:158

msgid ""

"Using a ``main`` function has the added benefit of the ``echo`` function "

"itself being isolated and importable elsewhere. When ``echo.py`` is "

"imported, the ``echo`` and ``main`` functions will be defined, but neither "

"of them will be called, because ``__name__ != '__main__'``."

msgstr ""

"Usar una función ``main`` tiene el beneficio añadido de que la función "

"``echo`` está aislada y es importable en otros sitios. Cuando ``echo.py`` es "

"importado, las funciones ``echo`` y ``main`` serán definidas, pero ninguna "

"de ellas será llamada porque ``__name!='__main__'``."

#: ../Doc/library/__main__.rst:165

msgid "Packaging Considerations"

msgstr "Consideraciones de empaquetado"

#: ../Doc/library/__main__.rst:167

msgid ""

"``main`` functions are often used to create command-line tools by specifying "

"them as entry points for console scripts. When this is done, `pip <https://"

"pip.pypa.io/>`_ inserts the function call into a template script, where the "

"return value of ``main`` is passed into :func:`sys.exit`. For example::"

msgstr ""

"Las funciones ``main`` se utilizan a menudo para crear líneas de comando al "

"especificarlas como puntos de entrada para scripts de terminal. Cuando esto "

"se hace, `pip <https://pip.pypa.io/>`_ inserta la llamada de la función a un "

"script plantilla, donde el valor retornado de ``main`` se pasa a :func:`sys."

"exit`. Por ejemplo::"

#: ../Doc/library/__main__.rst:173

msgid "sys.exit(main())"

msgstr ""

#: ../Doc/library/__main__.rst:175

msgid ""

"Since the call to ``main`` is wrapped in :func:`sys.exit`, the expectation "

"is that your function will return some value acceptable as an input to :func:"

"`sys.exit`; typically, an integer or ``None`` (which is implicitly returned "

"if your function does not have a return statement)."

msgstr ""

"Dado que la llamada a ``main`` está dentro de :func:`sys.exit`, la "

"expectativa es que tu función devolverá un valor aceptable como una entrada "

"a :func:`sys.exit`; típicamente, un int o ``None`` (que se retorna "

"implícitamente si tu función no tiene una declaración de retorno)."

#: ../Doc/library/__main__.rst:180

msgid ""

"By proactively following this convention ourselves, our module will have the "

"same behavior when run directly (i.e. ``python echo.py``) as it will have if "

"we later package it as a console script entry-point in a pip-installable "

"package."

msgstr ""

"Al seguir pro-activamente esta convención nosotros mismo, nuestro módulo "

"tendrá el mismo comportamiento cuando se ejecuta directamente (es decir, "

"``python echo.py``) que si luego lo empaquetamos como un punto de entrada de "

"script de terminal en un paquete instalable mediante pip."

#: ../Doc/library/__main__.rst:185

msgid ""

"In particular, be careful about returning strings from your ``main`` "

"function. :func:`sys.exit` will interpret a string argument as a failure "

"message, so your program will have an exit code of ``1``, indicating "

"failure, and the string will be written to :data:`sys.stderr`. The ``echo."

"py`` example from earlier exemplifies using the ``sys.exit(main())`` "

"convention."

msgstr ""

"En particular, ten cuidado al devolver cadenas de texto con tu función "

"``main``. :func:`sys.exit` interpretará un argumento de cadena de texto como "

"un mensaje de fallo, entonces tu programa tendrá un código de salida de "

"``1``, indicando fallo, y la cadena de texto será escrita a :data:`sys."

"stderr`. El ejemplo ``echo.py`` de antes muestra como usar la convención "

"``sys.exit(main())``."

#: ../Doc/library/__main__.rst:193

msgid ""

"`Python Packaging User Guide <https://packaging.python.org/>`_ contains a "

"collection of tutorials and references on how to distribute and install "

"Python packages with modern tools."

msgstr ""

"`Python Packaging User Guide <https://packaging.python.org/>`_ contiene una "

"colección de tutoriales y referencias sobre como distribuir e instalar "

"paquetes de Python con herramientas modernas."

#: ../Doc/library/__main__.rst:199

msgid "``__main__.py`` in Python Packages"

msgstr "``__main__.py`` en paquetes de Python"

#: ../Doc/library/__main__.rst:201

msgid ""

"If you are not familiar with Python packages, see section :ref:`tut-"

"packages` of the tutorial. Most commonly, the ``__main__.py`` file is used "

"to provide a command-line interface for a package. Consider the following "

"hypothetical package, \"bandclass\":"

msgstr ""

"Si no estás familiarizado con paquetes de Python, ver la sección :ref:`tut-"

"packages` del tutorial. Comúnmente, el archivo ``__main__.py`` es utilizado "

"para proveer una interfaz de línea de comando para un paquete. Considera el "

"siguiente paquete hipotético, \"*bandclass*\":"

#: ../Doc/library/__main__.rst:206

msgid ""

"bandclass\n"

" ├── __init__.py\n"

" ├── __main__.py\n"

" └── student.py"

msgstr ""

#: ../Doc/library/__main__.rst:213

msgid ""

"``__main__.py`` will be executed when the package itself is invoked directly "

"from the command line using the :option:`-m` flag. For example:"

msgstr ""

"``__main__.py`` será ejecutado cuando el paquete sea invocado directamente "

"desde la línea de comandos usando el indicador :option:`-m`. Por ejemplo:"

#: ../Doc/library/__main__.rst:216

msgid "$ python -m bandclass"

msgstr ""

#: ../Doc/library/__main__.rst:220

msgid ""

"This command will cause ``__main__.py`` to run. How you utilize this "

"mechanism will depend on the nature of the package you are writing, but in "

"this hypothetical case, it might make sense to allow the teacher to search "

"for students::"

msgstr ""

"Este comando causará que ``__main__.py`` se ejecute. El como se use este "

"mecanismo dependerá de la naturaleza del paquete que estás escribiendo, pero "

"en este caso hipotético, puede tener sentido permitir que el profesor busque "

"estudiantes::"

#: ../Doc/library/__main__.rst:225

msgid ""

"# bandclass/__main__.py\n"

"\n"

"import sys\n"

"from .student import search_students\n"

"\n"

"student_name = sys.argv[1] if len(sys.argv) >= 2 else ''\n"

"print(f'Found student: {search_students(student_name)}')"

msgstr ""

#: ../Doc/library/__main__.rst:233

msgid ""

"Note that ``from .student import search_students`` is an example of a "

"relative import. This import style can be used when referencing modules "

"within a package. For more details, see :ref:`intra-package-references` in "

"the :ref:`tut-modules` section of the tutorial."

msgstr ""

"Note que ``from .student import search_students`` es un ejemplo de una "

"importación relativa. Este estilo de importación debe ser utilizado cuando "

"se hace referencia a módulos dentro de un paquete. Para más detalles, ver :"

"ref:`intra-package-references` en la sección :ref:`tut-modules` del tutorial."

#: ../Doc/library/__main__.rst:241

msgid ""

"The content of ``__main__.py`` typically isn't fenced with an ``if __name__ "

"== '__main__'`` block. Instead, those files are kept short and import "

"functions to execute from other modules. Those other modules can then be "

"easily unit-tested and are properly reusable."

msgstr ""

"Los contenidos de ``__main__.py`` no están típicamente acotados dentro de "

"bloques ``if __name__=='__main__'``. En cambio, esos archivos se mantienen "

"cortos e importan funciones para ejecutar desde otros módulos. A esos otros "

"módulos se les puede fácilmente realizar pruebas unitarias y son "

"apropiadamente re-utilizables."

#: ../Doc/library/__main__.rst:246

msgid ""

"If used, an ``if __name__ == '__main__'`` block will still work as expected "

"for a ``__main__.py`` file within a package, because its ``__name__`` "

"attribute will include the package's path if imported::"

msgstr ""

"Si se usa, un bloque ``if __name__=='__main__'`` seguirá funcionando como se "

"espera para un archivo ``__main__.py`` dentro de un paquete, porque su "

"atributo ``__name__`` incluirá la ruta del paquete si es importado::"

#: ../Doc/library/__main__.rst:250

msgid ""

">>> import asyncio.__main__\n"

">>> asyncio.__main__.__name__\n"

"'asyncio.__main__'"

msgstr ""

#: ../Doc/library/__main__.rst:254

#, fuzzy

msgid ""

"This won't work for ``__main__.py`` files in the root directory of a ``."

"zip`` file though. Hence, for consistency, a minimal ``__main__.py`` "

"without a ``__name__`` check is preferred."

msgstr ""

"Esto no funcionará para archivos ``__main__.py`` en el directorio base de un "

"archivo .zip. Por lo tanto, por consistencia, es preferible un ``__main__."

"py`` minimalista como el :mod:`venv` mencionado abajo."

#: ../Doc/library/__main__.rst:260

msgid ""

"See :mod:`venv` for an example of a package with a minimal ``__main__.py`` "

"in the standard library. It doesn't contain a ``if __name__ == '__main__'`` "

"block. You can invoke it with ``python -m venv [directory]``."

msgstr ""

"En :mod:`venv` puedes conseguir un ejemplo de un paquete con un ``__main__."

"py`` minimalista en la librería estándar. No contiene un bloque ``if "

"__name__=='__main__'``. Lo puedes invocar con ``python -m venv "

"[directorio]``."

#: ../Doc/library/__main__.rst:264

msgid ""

"See :mod:`runpy` for more details on the :option:`-m` flag to the "

"interpreter executable."

msgstr ""

"Ver :mod:`runpy` para más detalles sobre el indicador :option:`-m` para el "

"interprete ejecutable."

#: ../Doc/library/__main__.rst:267

msgid ""

"See :mod:`zipapp` for how to run applications packaged as *.zip* files. In "

"this case Python looks for a ``__main__.py`` file in the root directory of "

"the archive."

msgstr ""

"Ver :mod:`zipapp` para más información sobre como ejecutar aplicaciones "

"empaquetadas como archivos *.zip*. En este caso Python busca un archivo "

"``__main__.py`` en el directorio raíz del archivo comprimido."

#: ../Doc/library/__main__.rst:274

msgid "``import __main__``"

msgstr "``import __main__``"

#: ../Doc/library/__main__.rst:276

msgid ""

"Regardless of which module a Python program was started with, other modules "

"running within that same program can import the top-level environment's "

"scope (:term:`namespace`) by importing the ``__main__`` module. This "

"doesn't import a ``__main__.py`` file but rather whichever module that "

"received the special name ``'__main__'``."

msgstr ""

"Independientemente de con cual módulo se ha iniciado un programa de Python, "

"otros módulos que están siendo ejecutados dentro del mismo programa pueden "

"importar el ámbito del entorno de máximo nivel (:term:`namespace`) al "

"importar el módulo ``__main__``. Esto no importa un archivo ``__main__.py`` "

"pero en su lugar cualquier módulo que recibió el nombre especial "

"``'__main__'``."

#: ../Doc/library/__main__.rst:282

msgid "Here is an example module that consumes the ``__main__`` namespace::"

msgstr ""

"Acá hay un módulo ejemplo que consume el nombre de espacio ``__main__``::"

#: ../Doc/library/__main__.rst:284

msgid ""

"# namely.py\n"

"\n"

"import __main__\n"

"\n"

"def did_user_define_their_name():\n"

" return 'my_name' in dir(__main__)\n"

"\n"

"def print_user_name():\n"

" if not did_user_define_their_name():\n"

" raise ValueError('Define the variable `my_name`!')\n"

"\n"

" if '__file__' in dir(__main__):\n"

" print(__main__.my_name, \"found in file\", __main__.__file__)\n"

" else:\n"

" print(__main__.my_name)"

msgstr ""

#: ../Doc/library/__main__.rst:300

msgid "Example usage of this module could be as follows::"

msgstr "Ejemplo del uso de este módulo puede ser::"

#: ../Doc/library/__main__.rst:302

msgid ""

"# start.py\n"

"\n"

"import sys\n"

"\n"

"from namely import print_user_name\n"

"\n"

"# my_name = \"Dinsdale\"\n"

"\n"

"def main():\n"

" try:\n"

" print_user_name()\n"

" except ValueError as ve:\n"

" return str(ve)\n"

"\n"

"if __name__ == \"__main__\":\n"

" sys.exit(main())"

msgstr ""

#: ../Doc/library/__main__.rst:319

msgid "Now, if we started our program, the result would look like this:"

msgstr "Si ahora iniciamos nuestro programa el resultado sería así::"

#: ../Doc/library/__main__.rst:321

msgid ""

"$ python start.py\n"

"Define the variable `my_name`!"

msgstr ""

#: ../Doc/library/__main__.rst:326

msgid ""

"The exit code of the program would be 1, indicating an error. Uncommenting "

"the line with ``my_name = \"Dinsdale\"`` fixes the program and now it exits "

"with status code 0, indicating success:"

msgstr ""

"El código de salida del programa sería 1, indicando un error. Des-comentando "

"la línea con ``my_name = \"Dinsdale\"`` arregla el programa y ahora sale con "

"un código de estado 0, indicando éxito:"

#: ../Doc/library/__main__.rst:330

msgid ""

"$ python start.py\n"

"Dinsdale found in file /path/to/start.py"

msgstr ""

#: ../Doc/library/__main__.rst:335

msgid ""

"Note that importing ``__main__`` doesn't cause any issues with "

"unintentionally running top-level code meant for script use which is put in "

"the ``if __name__ == \"__main__\"`` block of the ``start`` module. Why does "

"this work?"

msgstr ""

"Note que importar ``__main__`` no causa ningún problema de involuntariamente "

"ejecutar código de máximo nivel que ha sido pensado para uso por scripts que "

"es puesto en el bloque ``if __name__==\"__main__\"`` del módulo ``start``. "

"¿Por qué funciona esto?"

#: ../Doc/library/__main__.rst:339

msgid ""

"Python inserts an empty ``__main__`` module in :data:`sys.modules` at "

"interpreter startup, and populates it by running top-level code. In our "

"example this is the ``start`` module which runs line by line and imports "

"``namely``. In turn, ``namely`` imports ``__main__`` (which is really "

"``start``). That's an import cycle! Fortunately, since the partially "

"populated ``__main__`` module is present in :data:`sys.modules`, Python "

"passes that to ``namely``. See :ref:`Special considerations for __main__ "

"<import-dunder-main>` in the import system's reference for details on how "

"this works."

msgstr ""

"Python inserta un módulo ``__main__`` vacío en :data:`sys.modules` al inicio "

"del intérprete, y lo puebla ejecutando código de máximo nivel. En nuestro "

"ejemplo este es el módulo ``start`` que corre línea a línea e importa "

"``namely``. A su vez, ``namely`` importa ``__main__`` (que es en verdad "

"``start``). ¡Es un ciclo de importado! Afortunadamente, como el módulo "

"parcialmente poblado ``__main__`` está presente en :data:`sys.modules`, "

"Python pasa eso a ``namely``. Ver :ref:`Special considerations for __main__ "

"<import-dunder-main>` en la referencia del sistema para información "

"detallada de como funciona."

#: ../Doc/library/__main__.rst:348

msgid ""

"The Python REPL is another example of a \"top-level environment\", so "

"anything defined in the REPL becomes part of the ``__main__`` scope::"

msgstr ""

"El REPL Python es otro ejemplo de un \"entorno de máximo nivel\", por lo "

"tanto, cualquier cosa definida en el REPL se hace parte del ámbito "

"``__main__``::"

#: ../Doc/library/__main__.rst:351

msgid ""

">>> import namely\n"

">>> namely.did_user_define_their_name()\n"

"False\n"

">>> namely.print_user_name()\n"

"Traceback (most recent call last):\n"

"...\n"

"ValueError: Define the variable `my_name`!\n"

">>> my_name = 'Jabberwocky'\n"

">>> namely.did_user_define_their_name()\n"

"True\n"

">>> namely.print_user_name()\n"

"Jabberwocky"

msgstr ""

#: ../Doc/library/__main__.rst:364

msgid ""

"Note that in this case the ``__main__`` scope doesn't contain a ``__file__`` "

"attribute as it's interactive."

msgstr ""

"Note que en este caso el ámbito ``__main__`` no contiene un atributo "

"``__file__`` ya que es interactivo."

#: ../Doc/library/__main__.rst:367

msgid ""

"The ``__main__`` scope is used in the implementation of :mod:`pdb` and :mod:"

"`rlcompleter`."

msgstr ""

"El ámbito ``__main__`` es utilizado en la implementación de :mod:`pdb` y :"

"mod:`rlcompleter`."