Repository navigation
Expand file tree
/
Copy path__main__.po
More file actions
514 lines (460 loc) · 22.7 KB
/
Copy path__main__.po
File metadata and controls
514 lines (460 loc) · 22.7 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
# Copyright (C) 2001-2020, Python Software Foundation
# This file is distributed under the same license as the Python package.
# Maintained by the python-doc-es workteam.
# docs-es@python.org /
# https://mail.python.org/mailman3/lists/docs-es.python.org/
# Check https://github.com/python/python-docs-es/blob/3.8/TRANSLATORS to get
# the list of volunteers
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.8\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2022-10-25 19:47+0200\n"
"PO-Revision-Date: 2021-10-28 21:47+0200\n"
"Last-Translator: Juan C. Tello <juanctello@gmail.com>\n"
"Language: es\n"
"Language-Team: python-doc-es\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.10.3\n"
#: ../Doc/library/__main__.rst:2
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: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: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: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: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: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: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: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: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
#, fuzzy
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: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: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. ``python3 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, "
"``python3 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: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: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:233
#, fuzzy
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 contents of ``__main__.py`` typically isn't fenced with ``if __name__ == "
"'__main__'`` blocks. Instead, those files are kept short, 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, 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:254
#, fuzzy
msgid ""
"This won't work for ``__main__.py`` files in the root directory of a .zip "
"file though. Hence, for consistency, minimal ``__main__.py`` like the :mod:"
"`venv` one mentioned below are preferred."
msgstr ""
"Sin embargo, 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 "
"arriba."
#: ../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 ``python3 -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 ``python3 -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: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: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: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: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 :attr:`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 :attr:`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 :attr:`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 :attr:`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: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`."