IDLE
****

**Código fuente:** Lib/idlelib/

======================================================================

IDLE es el entorno de desarrollo integrado de Python.

IDLE tiene las siguientes características:

* escrito 100% en Python puro, usando el kit de herramientas GUI
  "tkinter"

* multiplataforma: funciona en su mayoría igual en Windows, Unix y
  macOS

* La ventana del shell de Python (interprete interactivo) con
  coloreado de código de entrada, salida y mensajes de error

* editor de texto multiventana con deshacer múltiple, coloreación
  Python, indentado inteligente, sugerencias de llamadas a funciones,
  autocompletado y otras características

* búsqueda dentro de cualquier ventana, reemplazo dentro de las
  ventanas del editor, y búsqueda a través de múltiples archivos
  (grep)

* depurador con breakpoints persistentes, por pasos y visualización de
  espacios de nombres globales y locales

* configuración, navegadores y otros cuadros de diálogo


Menús
=====

IDLE tiene dos tipos de ventana principales, la ventana del shell y la
ventana del editor.  Es posible tener múltiples ventanas de edición
simultáneamente.  En Windows y Linux, cada una tiene su propio menú
principal.  Cada menú documentado abajo indica con cuál tipo de
ventana está asociada esta.

Las ventanas de salida, como las que se usan para Editar => Encontrar
en archivos, son un subtipo de la ventana de edición.  Actualmente
tienen el mismo menú principal pero un título predeterminado y un menú
contextual diferente.

En macOS, hay un menú de aplicación.  Este cambia dinámicamente de
acuerdo la ventana actualmente seleccionada.  Tiene un menú IDLE y
algunas de las entradas descritas a continuación se mueven de acuerdo
con las pautas de Apple.


Menú de archivo (Shell y Editor)
--------------------------------

Nuevo archivo
   Crea una nueva ventana de edición de archivos.

Abrir...
   Abre un archivo existente con un cuadro de dialogo para abrir.

Archivos recientes
   Abre una lista de archivos recientes.  Haga click en alguno para
   abrirlo.

Abrir módulo...
   Abre un módulo existente (buscar en sys.path).

Navegador de clases
   Muestra las funciones, clases y métodos en estructura de árbol en
   el archivo actual del Editor.  En el shell, primero abra un módulo.

Navegador de ruta
   Muestra directorios, módulos, funciones, clases y métodos de
   sys.path en una estructura de árbol.

Guardar
   Guarda la ventana actual en el archivo asociado, si existe alguno.
   Las ventanas que han sido modificadas desde que se abrieron o se
   guardaron por última vez tienen un * antes y después del título de
   la ventana.  Si no hay un archivo asociado, ejecute Guardar como en
   su lugar.

Guardar Como...
   Guarda la ventana actual con un cuadro de diálogo Guardar como.  El
   archivo guardado se convierte en el nuevo archivo asociado para
   esta ventana.

Guardar copia como...
   Guarda la ventana actual en un archivo diferente sin cambiar el
   archivo asociado.

Imprimir ventana
   Imprime la ventana actual en la impresora predeterminada.

Cerrar
   Cierra la ventana actual (solicita guardar si no está guardado).

Salir
   Cierra todas las ventanas y sale de IDLE (solicita guardar ventanas
   no guardadas).


Menú editar (Shell y Editor)
----------------------------

Deshacer
   Deshace el último cambio a la ventana actual.  Se puede deshacer un
   máximo de 1000 cambios.

Rehacer
   Vuelve a aplicar el último cambio deshecho a la ventana actual.

Cortar
   Copia la selección en el portapapeles global; después elimina la
   selección.

Copiar
   Copia la selección en el portapapeles global.

Pegar
   Inserta el contenido del portapapeles global en la ventana actual.

Las funciones del portapapeles también están disponibles en los menús
contextuales.

Seleccionar todo
   Selecciona el contenido completo de la ventana actual.

Encontrar...
   Abre un cuadro de diálogo de búsqueda con muchas opciones

Buscar de nuevo
   Repite la última búsqueda, si hay alguna.

Encontrar selección
   Busca la cadena de caracteres seleccionada actualmente, si hay
   alguna.

Encontrar en Archivos...
   Abre un cuadro de diálogo de búsqueda de archivos.  Presenta los
   resultados en una nueva ventana de salida.

Reemplazar...
   Abre un cuadro de diálogo de búsqueda y reemplazo.

Ir a la línea
   Mueve el cursor al inicio de la línea solicitada y hace que esa
   línea sea visible.  Una solicitud a partir del final del archivo lo
   lleva al final. Borra cualquier selección y actualiza el estado de
   la línea y la columna.

Mostrar complementos
   Open a scrollable list allowing selection of existing names. See
   Completions in the Editing and navigation section below.

Expandir palabra
   Completa un prefijo que se ha escrito para que coincida con una
   palabra completa en la misma ventana; intente nuevamente para
   obtener un complemento diferente.

Mostrar sugerencias de llamada
   Después de un paréntesis abierto para una función, abre una pequeña
   ventana con sugerencias sobre parámetros de función. Consultar
   Sugerencias de llamada en la sección Edición y navegación a
   continuación.

Mostrar los paréntesis alrededor
   Resalta los paréntesis.


Menú de formato (solo ventana del Editor)
-----------------------------------------

Zona de indentación
   Desplaza las líneas seleccionadas a la derecha en un nivel de
   indentación (por defecto 4 espacios).

Zona de deindentación
   Desplaza las líneas seleccionadas hacia la izquierda en un nivel de
   indentación (por defecto 4 espacios).

Zona comentada
   Inserta ## delante de las líneas seleccionadas.

Zona descomentada
   Elimina los # o ## al inicio de las líneas seleccionadas.

Zona tabulada
   Transforma los tramos de espacios *iniciales* en tabs. (Nota:
   Recomendamos usar 4 bloques de espacio para indentar el código de
   Python).

Zona destabulada
   Transforma *todos* los tabs en el número correcto de espacios.

Alternar tabs
   Abre un cuadro de diálogo para cambiar entre indentado con espacios
   y tabs.

Nuevo tamaño de indentación
   Abre un cuadro de diálogo para cambiar el tamaño de indentación. El
   valor predeterminado aceptado por la comunidad de Python es de 4
   espacios.

Formatear párrafo
   Reformatea el párrafo actual delimitado por líneas en blanco en un
   bloque de comentarios o una cadena de caracteres multilínea o una
   línea seleccionada en una cadena de caracteres.  Todas las líneas
   en el párrafo estarán formateadas con menos de N columnas, donde N
   por defecto es 72.

Remover espacios en blanco al final
   Elimina el espacio final en la línea y otros caracteres de espacio
   en blanco después del último carácter que no sea un espacio en
   blanco aplicando str.rstrip a cada línea, incluyendo las líneas
   dentro de cadenas de caracteres multilíneas.  Excepto para las
   ventanas de consola, elimina nuevas líneas adicionales al final del
   archivo.


Menú ejecutar (solo ventana Editor)
-----------------------------------

Módulo ejecutar
   Hace lo que dice en Verificar módulo.  Si no hay errores, reinicia
   el shell para limpiar el entorno, luego ejecuta el módulo.  La
   salida es mostrada en la ventana de shell.  Tener en cuenta que la
   visualización requiere el uso de "print" o "write". Cuando finaliza
   la ejecución, el shell permanece activo y muestra un mensaje. En
   este punto, se puede explorar interactivamente el resultado de la
   ejecución. Esto es similar a ejecutar un archivo con "python -i
   file" en una línea de comando.

Ejecutar... Personalizado
   Igual que Módulo ejecutar, pero ejecuta el módulo con parámetros
   personalizados.  *Los argumentos de la línea de comandos* extienden
   "sys.argv" como si se pasaran por una línea de comando. El módulo
   se puede ejecutar en el shell sin reiniciar.

Verificar módulo
   Comprueba la sintaxis del módulo actualmente abierto en la ventana
   de edición. Si el módulo no ha sido guardado IDLE solicitará al
   usuario que guarde o guarde automáticamente, como se seleccionó en
   la pestaña General del cuadro de diálogo Configuración de
   inactividad.  Si hay algún error de sintaxis, la ubicación
   aproximada será indicada en la ventana del Editor.

Shell de Python
   Abrir o activar la ventana del shell de Python.


Menú de shell (solo ventana de shell)
-------------------------------------

Ver el último reinicio
   Navega la ventana del shell hasta el último reinicio del mismo.

Reiniciar shell
   Restart the shell to clean the environment and reset display and
   exception handling.

Historial anterior
   Recorre los comandos anteriores en el historial que coinciden con
   la entrada actual.

Historial siguiente
   Recorre los comandos posteriores en el historial que coinciden con
   la entrada actual.

Ejecución de interrupción
   Detiene un programa en ejecución.


Menú de depuración (solo ventana de shell)
------------------------------------------

Ir al Archivo/Línea
   Busca en la línea actual, con el cursor y la línea de arriba para
   un nombre de archivo y número de línea.  Si lo encuentra, abre el
   archivo si aún no está abierto y muestra la línea.  Usa esto para
   ver las líneas de origen referenciadas en un rastreo de excepción y
   las líneas encontradas por Buscar en archivos. También disponible
   en el menú contextual de la ventana del shell y las ventanas de
   salida.

Depurador (alternar)
   Cuando esta función está habilitada, el código ingresado en el
   shell o ejecutado desde el editor se ejecutará con el depurador.
   En el editor, los breakpoints se pueden establecer con el menú
   contextual.  Esta funcionalidad aún está incompleta y es en cierto
   modo experimental.

Visualizador de pila
   Muestra el seguimiento de la pila de la última excepción en un
   complemento de árbol, con acceso a locales y globales.

Auto-abrir visualizador de pila
   Activa/desactiva automáticamente el visualizador de pila en una
   excepción no controlada.


Menú de opciones (Shell y editor)
---------------------------------

Configurar IDLE
   Abre un cuadro de diálogo de configuración y cambia las
   preferencias por lo siguiente: fuentes, indentación, combinaciones
   de teclas, temas de color de texto, ventanas y tamaño de inicio,
   fuentes de ayuda adicionales y extensiones.  En macOS, abre el
   cuadro de diálogo de configuración seleccionando Preferencias en el
   menú de la aplicación. Para obtener más detalles, consultar
   Configurar preferencias en Ayuda y preferencias.

La mayoría de los ajustes de configuración se aplican a todas las
ventanas, abiertas o no. Los siguientes elementos de opción se aplican
solo a la ventana activa.

Mostrar/Ocultar el contexto del código (solo ventana del Editor)
   Abre un panel en la parte superior de la ventana de edición el cual
   muestra el contexto de bloque de código que se ha desplazado sobre
   la parte superior de la ventana.  Consultar Contexto de código en
   la sección Edición y Navegación a continuación.

Mostrar/Ocultar números de línea (solo ventana del Editor)
   Abre una columna a la izquierda de la ventana de edición que
   muestra el número de cada línea de texto.  El valor por defecto de
   esta característica es desactivado, este puede modificarse en las
   preferencias (consultar Configuración de preferencias).

Ampliar/Restaurar altura
   Alterna la ventana entre el tamaño normal y la altura máxima. El
   tamaño inicial predeterminado es 40 líneas por 80 caracteres a
   menos que se cambie en la pestaña General del cuadro de diálogo
   Configurar IDLE.  La altura máxima para una pantalla es determinada
   maximizando momentáneamente una ventana la primera vez que se
   acerca la pantalla. Cambiar la configuración de la pantalla puede
   invalidar la altura guardada.  Este alternado no tiene efecto
   cuando se maximiza una ventana.


Menú de ventana (shell y editor)
--------------------------------

Enumera los nombres de todas las ventanas abiertas; seleccione uno
para ponerlo en primer plano (deiconificándolo si es necesario).


Menú de ayuda (shell y editor)
------------------------------

Acerca de IDLE
   Muestra la versión, derechos de autor, licencia, créditos y más.

Ayuda de IDLE
   Muestra este documento IDLE, que detalla las opciones del menú,
   edición y navegación básica y otros consejos.

Documentación de Python
   Accede a la documentación local de Python, si está instalada, o
   inicia un navegador web y abre docs.python.org mostrando la última
   documentación de Python.

Demostración Turtle
   Ejecuta el módulo turtledemo con ejemplos de código Python y
   dibujos de tortugas.

Se pueden agregar fuentes de ayuda adicionales aquí con el cuadro de
diálogo Configurar IDLE en la pestaña General. Consultar la subsección
Fuentes de ayuda a continuación para obtener más información sobre las
opciones del menú Ayuda.


Menús contextuales
------------------

Se abre un menú contextual haciendo click derecho en una ventana
(Control-click en macOS). Los menús contextuales tienen las funciones
estándar del portapapeles también en el menú Editar.

Cortar
   Copia la selección en el portapapeles global; después elimina la
   selección.

Copiar
   Copia la selección en el portapapeles global.

Pegar
   Inserta el contenido del portapapeles global en la ventana actual.

Las ventanas del editor también tienen funciones de breakpoint.  Las
líneas con un conjunto de breakpoints están especialmente marcadas.
Los breakpoints solo tienen efecto cuando se ejecutan bajo el
depurador.  Los breakpoints para un archivo se guardan en el
directorio ".idlerc" del usuario.

Establecer breakpoint
   Establecer un breakpoint en la línea actual.

Eliminar breakpoint
   Eliminar el breakpoint en esa línea.

Las ventanas de shell y de salida también tienen los siguientes
elementos.

Ir a archivo/línea
   Hace lo mismo que el menú depurar.

La ventana de shell también tiene una función de *squeezing* de salida
explicada en la subsección *ventana de shell de Python* a
continuación.

Exprimir
   Si el cursor está sobre una línea de salida, comprime toda la
   salida entre el código de arriba y el mensaje de abajo hasta la
   etiqueta 'Texto *squeezed*'.


Edición y navegación
====================


Ventana del editor
------------------

IDLE puede abrir ventanas del editor cuando se inicia, dependiendo de
la configuración y de cómo inicies el IDLE.  A partir de ahí, usar el
menú Archivo.  Solo puede haber una ventana de editor abierta para un
archivo determinado.

La barra de título contiene el nombre del archivo, la ruta completa y
la versión de Python e IDLE que ejecuta la ventana.  La barra de
estado contiene el número de línea ('Ln') y el número de columna
('Col').  Los números de línea comienzan con 1; los números de columna
con 0.

El IDLE supone que los archivos con una extensión .py* conocida
contienen código Python y que los otros archivos no. Ejecuta el código
Python con el menú Ejecutar.


Atajos de teclado
-----------------

En esta sección, 'C' hace referencia a la tecla "Control" en Windows y
Unix y la tecla "Command" en macOS.

* "Backspace" borra hacia la izquierda; "Del" borra hacia la derecha

* "C-Backspace" borra la palabra a la izquierda; "C-Del" borra la
  palabra a la derecha

* Las teclas con flechas y "Page Up"/"Page Down" para moverse
  alrededor

* "C-LeftArrow" y "C-RightArrow" para moverse por palabras

* "Home"/"End" para ir al inicio/fin de la línea

* "C-Home"/"C-End" para ir al inicio/fin del archivo

* Algunos atajos útiles de Emacs son heredados de Tcl / Tk:

     * "C-a" al inicio de la línea

     * "C-e" al final de la línea

     * "C-k" corta la línea (pero no la pone en el portapapeles)

     * "C-l" centra la ventana alrededor del punto de inserción

     * "C-b" retrocede un carácter sin eliminarlo (generalmente
       también se puede usar la tecla de cursor para esto)

     * "C-f" avanza un carácter sin eliminarlo (generalmente también
       se puede usar la tecla de cursor para esto)

     * "C-p" sube una línea (generalmente también se puede usar la
       tecla del cursor para esto)

     * "C-d" borra el siguiente carácter

Las combinaciones de teclas estándar (como "C-c" para copiar y "C-v"
para pegar) pueden funcionar. Las combinaciones de teclas se
seleccionan en el cuadro de diálogo Configurar IDLE.


Indentación automática
----------------------

Después de una declaración de apertura de bloque, la siguiente línea
está indentada por 4 espacios (en la ventana del shell de Python por
un tab).  Después de ciertas palabras clave (saltar, retornar, etc.),
la siguiente línea se deindenta.  En la indentación principal,
"Backspace" elimina hasta 4 espacios si están allí. "Tab" inserta
espacios (en la ventana del shell de Python un tab), el número depende
del tamaño de la indentación. Actualmente, los tabs están restringidos
a cuatro espacios debido a las limitaciones de Tcl/Tk.

Consulte también los comandos de zona de indexación/deindentación en
Menú de formato.


Terminaciones
-------------

Completions are supplied, when requested and available, for module
names, attributes of classes or functions, or filenames.  Each request
method displays a completion box with existing names.  (See tab
completions below for an exception.) For any box, change the name
being completed and the item highlighted in the box by typing and
deleting characters; by hitting "Up", "Down", "PageUp", "PageDown",
"Home", and "End" keys; and by a single click within the box.  Close
the box with "Escape", "Enter", and double "Tab" keys or clicks
outside the box. A double click within the box selects and closes.

One way to open a box is to type a key character and wait for a
predefined interval.  This defaults to 2 seconds; customize it in the
settings dialog.  (To prevent auto popups, set the delay to a large
number of milliseconds, such as 100000000.) For imported module names
or class or function attributes, type '.'. For filenames in the root
directory, type "os.sep" or "os.altsep" immediately after an opening
quote.  (On Windows, one can specify a drive first.)  Move into
subdirectories by typing a directory name and a separator.

Instead of waiting, or after a box is closed, open a completion box
immediately with Show Completions on the Edit menu.  The default hot
key is "C-space".  If one types a prefix for the desired name before
opening the box, the first match or near miss is made visible. The
result is the same as if one enters a prefix after the box is
displayed.  Show Completions after a quote completes filenames in the
current directory instead of a root directory.

Hitting "Tab" after a prefix usually has the same effect as Show
Completions.  (With no prefix, it indents.)  However, if there is only
one match to the prefix, that match is immediately added to the editor
text without opening a box.

Invoking 'Show Completions', or hitting "Tab" after a prefix, outside
of a string and without a preceding '.' opens a box with keywords,
builtin names, and available module-level names.

When editing code in an editor (as oppose to Shell), increase the
available module-level names by running your code and not restarting
the Shell thereafter.  This is especially useful after adding imports
at the top of a file.  This also increases possible attribute
completions.

Completion boxes intially exclude names beginning with '_' or, for
modules, not included in '__all__'.  The hidden names can be accessed
by typing '_' after '.', either before or after the box is opened.


Sugerencias de llamada
----------------------

A calltip is shown automatically when one types "(" after the name of
an *accessible* function.  A function name expression may include dots
and subscripts.  A calltip remains until it is clicked, the cursor is
moved out of the argument area, or ")" is typed.  Whenever the cursor
is in the argument part of a definition, select Edit and "Show Call
Tip" on the menu or enter its shortcut to display a calltip.

The calltip consists of the function's signature and docstring up to
the latter's first blank line or the fifth non-blank line.  (Some
builtin functions lack an accessible signature.)  A '/' or '*' in the
signature indicates that the preceding or following arguments are
passed by position or name (keyword) only.  Details are subject to
change.

In Shell, the accessible functions depends on what modules have been
imported into the user process, including those imported by Idle
itself, and which definitions have been run, all since the last
restart.

For example, restart the Shell and enter "itertools.count(".  A
calltip appears because Idle imports itertools into the user process
for its own use.  (This could change.)  Enter "turtle.write(" and
nothing appears. Idle does not itself import turtle.  The menu entry
and shortcut also do nothing.  Enter "import turtle".  Thereafter,
"turtle.write(" will display a calltip.

In an editor, import statements have no effect until one runs the
file. One might want to run a file after writing import statements,
after adding function definitions, or after opening an existing file.


Contexto del código
-------------------

Dentro de una ventana del editor que contiene código Python, el
contexto del código se puede alternar para mostrar u ocultar un panel
en la parte superior de la ventana.  Cuando se muestra, este panel
congela las líneas de apertura por bloques de código, como aquellos
que comienzan con las palabras clave "class", "def", o "if", que de
otro modo se habrían desplazado fuera de la vista.  El tamaño del
panel se expandirá y contraerá según sea necesario para mostrar todos
los niveles actuales de contexto, hasta el número máximo de líneas
definidas en el cuadro de diálogo Configurar IDLE (que por defecto es
15).  Si no hay líneas de contexto actuales y la función está
activada, se visualizará una sola línea en blanco.  Al hacer click en
una línea en el panel de contexto, esa línea se moverá a la parte
superior del editor.

El texto y los colores de fondo para el panel de contexto se pueden
configurar en la pestaña destacados en el cuadro de diálogo Configurar
IDLE.


Shell de Python
---------------

Con el shell del IDLE, se ingresa, edita y hace recae declaraciones
completas. La mayoría de consolas y terminales solo funcionan con una
sola línea física a la vez.

Cuando se pega código en el shell, este no es compilado y posiblemente
ejecutado hasta que se teclea "Return".  Se puede editar el código
pegado primero. Si se pega más de una declaración en el shell, el
resultado será un "SyntaxError" cuando se compilan varias
declaraciones como si fueran una sola.

Las funciones de edición descritas en subsecciones anteriores
funcionan cuando se ingresa código de forma interactiva.  La ventana
de shell del IDLE también responde a las siguientes combinaciones de
teclas.

* "C-c" interrumpe la ejecución del comando

* "C-d" lo envía el final del archivo; la ventana se cierra si se
  escribe en un mensaje ">>>"

* "Alt-/" (Expandir palabra) también es útil para reducir la escritura

  Historial de comandos

  * "Alt-p" recupera el comando anterior que coincide con lo que ha
    escrito. En macOS use "C-p".

  * "Alt-n" recupera el siguiente. En macOS use "C-n".

  * "Return" ingresando en un comando anterior, recupera ese comando


Colores del texto
-----------------

El idle por defecto es negro sobre texto blanco, pero colorea el texto
con significados especiales. Para el shell, estos son: la salida del
shell, error del shell, salida del usuario y error del usuario.  Para
el código Python, en el indicador de comandos de shell o en un editor,
estos son: palabras clave, nombres de funciones y clases incorporadas,
los siguientes nombres "class" and "def", cadenas de caracteres y
comentarios. Para cualquier ventana de texto, estos son: el cursor
(cuando está presente), el texto encontrado (cuando sea posible) y el
texto seleccionado.

La coloración del texto se realiza en segundo plano, por lo que
ocasionalmente se puede ver el texto sin colorear.  Para cambiar la
combinación de colores, use la pestaña Resaltar en el cuadro de
diálogo Configurar IDLE.  El marcado de líneas de breakpoint del
depurador en el editor y el texto en ventanas emergentes y cuadros de
diálogo no es configurable por el usuario.


Inicio y ejecución de código
============================

Al iniciar con la opción "-s", el IDLE ejecutará el archivo al que
hacen referencia las variables de entorno  "IDLESTARTUP" o
"PYTHONSTARTUP". El IDLE primero verifica "IDLESTARTUP"; si
"IDLESTARTUP" está presente, se ejecuta el archivo al que se hace
referencia.  Si "IDLESTARTUP" no está presente, IDLE verifica
"PYTHONSTARTUP".  Los archivos referenciados por estas variables de
entorno son lugares convenientes para almacenar funciones que son
usadas con frecuencia desde el shell del IDLE o para ejecutar
declaraciones importadas para importar módulos comunes.

Además, "Tk" también carga un archivo de inicio si este está presente.
Tenga en cuenta que el archivo Tk se carga incondicionalmente.  Este
archivo adicional es ".Idle.py" y es buscado en el directorio de
inicio del usuario.  Las declaraciones en este archivo se ejecutarán
en el espacio de nombres Tk, por lo que este archivo no es útil para
importar funciones que se utilizarán desde el shell de Python del
IDLE.


Uso de línea de comando
-----------------------

   idle.py [-c command] [-d] [-e] [-h] [-i] [-r file] [-s] [-t title] [-] [arg] ...

   -c command  run command in the shell window
   -d          enable debugger and open shell window
   -e          open editor window
   -h          print help message with legal combinations and exit
   -i          open shell window
   -r file     run file in shell window
   -s          run $IDLESTARTUP or $PYTHONSTARTUP first, in shell window
   -t title    set title of shell window
   -           run stdin in shell (- must be last option before args)

Si están los argumentos:

* Si se usa "-", "-c" o "r", todos los argumentos se colocan en
  "sys.argv [1:...] `` y ``sys.argv[0]" se establece en "''", "'-c'" o
  "'-r'".  No se abre ninguna ventana del editor, incluso si ese es el
  conjunto predeterminado en el cuadro de diálogo opciones.

* De lo contrario, los argumentos son archivos abiertos para edición y
  "sys.argv" refleja los argumentos pasados al IDLE.


Error de inicio
---------------

IDLE uses a socket to communicate between the IDLE GUI process and the
user code execution process.  A connection must be established
whenever the Shell starts or restarts.  (The latter is indicated by a
divider line that says 'RESTART'). If the user process fails to
connect to the GUI process, it usually displays a "Tk" error box with
a 'cannot connect' message that directs the user here.  It then exits.

One specific connection failure on Unix systems results from
misconfigured masquerading rules somewhere in a system's network
setup. When IDLE is started from a terminal, one will see a message
starting with "** Invalid host:". The valid value is "127.0.0.1
(idlelib.rpc.LOCALHOST)". One can diagnose with "tcpconnect -irv
127.0.0.1 6543" in one terminal window and "tcplisten <same args>" in
another.

Una causa común de falla se da cuando un archivo escrito por el
usuario tiene el mismo nombre de un módulo de biblioteca estándar,
como *random.py* y *tkinter.py*. Cuando dicho archivo se encuentra en
el mismo directorio que un archivo que está por ejecutarse, el IDLE no
puede importar el archivo stdlib.  La solución actual es cambiar el
nombre del archivo del usuario.

Aunque es menos común que en el pasado, un programa de antivirus o
firewall puede detener la conexión.  Si el programa no se puede
configurar para permitir la conexión, debe estar apagado para que
funcione el IDLE.  Es seguro permitir esta conexión interna porque no
hay datos visibles en puertos externos.  Un problema similar es una
configuración incorrecta de la red que bloquea las conexiones.

Los problemas de instalación de Python ocasionalmente detienen el
IDLE: puede darse un conflicto entre versiones o una sola instalación
puede requerir privilegios de administrador.  Si se soluciona el
conflicto o no se puede o quiere ejecutar como administrador, puede
ser más fácil desinstalar completamente Python y comenzar de nuevo.

Un proceso zombie pythonw.exe podría ser un problema.  En Windows, use
el Administrador de tareas para buscar uno y detenerlo si lo hay.  A
veces, un reinicio iniciado por un bloqueo del programa o una
interrupción del teclado (control-C) puede fallar al conectarse.
Descartar el cuadro de error o usar Reiniciar Shell en el menú del
Shell puede solucionar un problema temporal.

Cuando el IDLE se inicia por primera vez, intenta leer los archivos de
configuración de usuario en "~/.idlerc/" (~ este es el directorio
principal).  Si hay un problema, se mostrará un mensaje de error.
Dejando de lado los fallos aleatorios del disco, esto se puede evitar
si nunca se editan los archivos a mano.  En su lugar, utilice el
cuadro de diálogo de configuración, en Opciones.  Una vez que hay un
error en un archivo de configuración de usuario, la mejor solución
puede ser eliminarlo y empezar de nuevo con el cuadro de diálogo de
configuración.

Si el IDLE se cierra sin mensaje y este no fue iniciado desde una
consola, intente iniciarlo desde una consola o terminal ("python -m
idlelib") y observe si esto genera un mensaje de error.

On Unix-based systems with tcl/tk older than "8.6.11" (see "About
IDLE") certain characters of certain fonts can cause a tk failure with
a message to the terminal.  This can happen either if one starts IDLE
to edit a file with such a character or later when entering such a
character.  If one cannot upgrade tcl/tk, then re-configure IDLE to
use a font that works better.


Ejecutando código del usuario
-----------------------------

With rare exceptions, the result of executing Python code with IDLE is
intended to be the same as executing the same code by the default
method, directly with Python in a text-mode system console or terminal
window. However, the different interface and operation occasionally
affect visible results.  For instance, "sys.modules" starts with more
entries, and "threading.active_count()" returns 2 instead of 1.

De forma predeterminada, el IDLE ejecuta el código de usuario en un
proceso separado del sistema operativo en lugar de hacerlo en el
proceso de la interfaz de usuario que ejecuta el shell y el editor.
En el proceso de ejecución, este reemplaza "sys.stdin", "sys.stdout",
y "sys.stderr" con objetos que recuperan las entradas desde y envían
las salidas hacia la ventana de la consola. Los valores originales
almacenados en "sys.__stdin__", "sys.__stdout__", y "sys.__stderr__"
no se ven afectados, pero pueden ser "None".

Sending print output from one process to a text widget in another is
slower than printing to a system terminal in the same process. This
has the most effect when printing multiple arguments, as the string
for each argument, each separator, the newline are sent separately.
For development, this is usually not a problem, but if one wants to
print faster in IDLE, format and join together everything one wants
displayed together and then print a single string.  Both format
strings and "str.join()" can help combine fields and lines.

Las sustituciones de flujo estándar del IDLE no son heredadas por
subprocesos creados en el proceso de ejecución, siendo directamente
por código de usuario o por módulos como el multiprocesamiento.  Si
tal subproceso usa "input" desde sys.stdin o "print" o "write" hacia
sys.stdout o sys.stderr, el IDLE debe ser iniciado en una ventana de
línea de comando.  El subproceso secundario será adjuntado a esa
ventana para entrada y salida.

Si "sys" es restablecido mediante un código de usuario, tal como
"importlib.reload(sys)", los cambios del IDLE se perderán y la entrada
del teclado y la salida de la pantalla no funcionarán correctamente.

Cuando el shell está en primer plano, controla el teclado y la
pantalla.  Este es transparente normalmente, pero las funciones que
acceden directamente al teclado y la pantalla no funcionarán.  Estas
incluyen funciones específicas del sistema que determinan si se ha
presionado una tecla y de ser así, cuál.

La ejecución de código del IDLE en el proceso de ejecución agrega
marcos a la pila de llamadas que de otro modo no estarían allí.  el
IDLE encapsula "sys.getrecursionlimit" y "sys.setrecursionlimit" para
reducir el efecto de los marcos de pila adicionales.

Cuando el código de usuario genera SystemExit directamente o llamando
a sys.exit, el IDLE regresa al visualizador del Shell en lugar de
salir.


Salida del usuario en consola
-----------------------------

Cuando un programa muestra texto, el resultado está determinado por el
dispositivo de salida correspondiente.  Cuando el IDLE ejecuta el
código de usuario "sys.stdout" y "sys.stderr" se conectan al área de
visualización del Shell del IDLE.  Algunas de estas características
son heredadas de los widgets de texto Tk subyacentes.  Otras son
adiciones programadas.  Donde es importante, el shell está diseñado
para el desarrollo en lugar de la ejecución de producción.

Por ejemplo, el Shell nunca elimina la salida. Un programa que envía
salidas ilimitadas al Shell eventualmente llenará la memoria, lo que
resultará en un error de memoria. Por el contrario, algunas ventanas
de texto del sistema solo conservan las últimas n líneas de salida.
Una consola de Windows, por ejemplo, mantiene una línea configurable
por el usuario de 1 a 9999, con 300 por defecto.

Un widget de texto de Tk, y por lo tanto el Shell de IDLE, muestra
caracteres (puntos de código) en el subconjunto BMP (plano
multilingual básico) de Unicode.  Aquellos caracteres que se muestran
con un glifo adecuado y los cuales con una caja de reemplazo depende
del sistema operativo y las fuentes instaladas.  Los caracteres de
tabulación hacen que el texto siguiente comience después de la
siguiente tabulación. (Ocurre cada 8 'caracteres').  Los caracteres de
nueva línea hacen que el texto siguiente aparezca en una nueva línea.
Otros caracteres de control se omiten o se muestran como un espacio,
cuadro u otra cosa, dependiendo del sistema operativo y la fuente.
(Mover el cursor del texto a través de esa salida con las teclas de
flecha puede mostrar algún comportamiento de espaciado sorpresivo.)

   >>> s = 'a\tb\a<\x02><\r>\bc\nd'  # Enter 22 chars.
   >>> len(s)
   14
   >>> s  # Display repr(s)
   'a\tb\x07<\x02><\r>\x08c\nd'
   >>> print(s, end='')  # Display s as is.
   # Result varies by OS and font.  Try it.

La función "repr" es usada para la visualización interactiva del valor
de las expresiones.  Esta retorna una versión modificada de la cadena
de caracteres de entrada en la que los códigos de control, algunos
puntos de código BMP y todos los puntos de código que no son BMP son
reemplazados con caracteres de escape. Como se demostró anteriormente,
esto permite identificar los caracteres en una cadena de caracteres,
independientemente de cómo sean mostrados.

La salida normal y de error generalmente se mantienen separadas (en
líneas separadas) de la entrada de código y entre sí. Cada una obtiene
diferentes colores de resaltado.

Para el *traceback* de SyntaxError, el marcado normal '^' dónde se
detectó el error se reemplaza coloreando el texto con un resaltado de
error. Cuando el código ejecutado desde un archivo causa otras
excepciones, se puede hacer click derecho en un *traceback* para
saltar a la línea correspondiente en un editor del IDLE. El archivo se
abrirá si es necesario.

El Shell tiene una funcionalidad especial para exprimir las líneas de
salida hasta una etiqueta de 'Texto *Squeezed*'.  Esto se hace
automáticamente para una salida sobre N líneas (N = 50 por defecto). N
se puede cambiar en la sección PyShell de la página General del cuadro
de diálogo Configuración.  La salida con menos líneas puede ser
*squeezed* haciendo click derecho en la salida.  Esto puede ser útil
en líneas suficientemente largas para bajar el tiempo de
desplazamiento.

La salida *squeezed* se expande en su lugar haciendo doble click en la
etiqueta. También se puede enviar al portapapeles o a una ventana de
vista separada haciendo click derecho en la etiqueta.


Desarrollando aplicaciones tkinter
----------------------------------

El IDLE es intencionalmente diferente de Python estándar para
facilitar el desarrollo de programas tkinter.  Ingrese "import tkinter
as tk; root = tk.Tk()" en Python estándar y no aparecerá nada. Ingrese
lo mismo en el IDLE y aparecerá una ventana tk.  En Python estándar,
también se debe ingresar "root.update()" para ver la ventana.  El IDLE
hace el equivalente en segundo plano, aproximadamente 20 veces por
segundo, lo que es aproximadamente cada 50 milisegundos. Luego ingrese
"b = tk.Button(root, text='button'); b.pack()".  Del mismo modo, no
hay cambios visibles en Python estándar hasta que ingrese
"root.update()".

La mayoría de los programas tkinter ejecutan "root.mainloop()", que
generalmente no retorna hasta que se destruye la aplicación tk.  Si el
programa se ejecuta con "python -i" o desde un editor del IDLE, no
aparecerá un mensaje ">>>" del shell hasta que retorne "mainloop()",
momento en el cual no queda nada con lo que interactuar.

Al ejecutar un programa tkinter desde un editor IDLE, se puede
comentar la llamada de bucle principal.  Luego se recibe un aviso del
shell inmediatamente y se puede interactuar con la aplicación en vivo.
Solo se debe recordar reactivar la llamada al bucle principal cuando
se ejecuta en Python estándar.


Ejecutando sin un subproceso
----------------------------

Por defecto, el IDLE ejecuta el código de usuario en un subproceso
separado a través de un socket, el cual utiliza la interfaz de bucle
interno.  Esta conexión no es visible externamente y no son enviados
ni recibidos datos de Internet. Si el software de cortafuego sigue
presentando problemas, puede ignorarlo.

Si el intento de conexión del socket falla, IDLE lo notificará. Este
tipo de falla a veces es temporal, pero si persiste, el problema puede
provenir de un cortafuego que bloquea la conexión o de una mala
configuración en un sistema en particular.  Hasta que se solucione el
problema, se puede ejecutar el Idle con el modificador de línea de
comandos -n.

Si el IDLE se inicia con el modificador de línea de comandos -n, se
ejecutará en un único proceso y no creará el subproceso que ejecuta el
servidor de ejecución de Python RPC.  Esto puede ser útil si Python no
puede crear el subproceso o la interfaz de socket RPC en su
plataforma.  Sin embargo, en este modo el código de usuario no está
aislado en sí del IDLE.  Además, el entorno no se reinicia cuando se
selecciona Ejecutar/Ejecutar módulo (F5).  Si el código se ha
modificado, se debe volver a cargar() los módulos afectados y volver a
importar cualquier elemento específico (por ejemplo, desde *foo*
importar *baz*) para que los cambios surtan efecto.  Por estas
razones, es preferible ejecutar el IDLE con el subproceso
predeterminado si es posible.

Obsoleto desde la versión 3.4.


Ayuda y preferencias
====================


Recursos de ayuda
-----------------

La entrada del menú Ayuda "Ayuda IDLE" muestra una versión HTML
formateada del capítulo IDLE de la Referencia de la biblioteca.  El
resultado, en una ventana de texto tkinter de solo lectura, está cerca
de lo que se ve en un navegador web. Navegue por el texto con la rueda
del ratón, la barra de desplazamiento o presionando las teclas de
flecha arriba y abajo. O haga click en el botón TDC (Tabla de
contenido) y seleccione un encabezado de sección en el cuadro abierto.

La entrada del menú de ayuda "Documentos de Python" abre amplias
fuentes de ayuda, incluyendo tutoriales, disponibles en
"docs.python.org/x.y", donde 'x.y' es la versión de Python actualmente
en ejecución.  Si su sistema tiene una copia fuera de línea de los
documentos (esta puede ser una opción de instalación), esta se abrirá
en su lugar.

Las URL seleccionadas se pueden agregar o eliminar del menú de ayuda
en cualquier momento utilizando la pestaña General del cuadro de
diálogo Configurar IDLE.


Preferencias de configuración
-----------------------------

Las preferencias de fuente, resaltado, teclas y preferencias generales
se pueden cambiar en Configurar IDLE en el menú opción. Las
configuraciones de usuario no predeterminadas se guardan en un
directorio ".idlerc" en el directorio de inicio del usuario.  Los
problemas causados por archivos de configuración de usuario
incorrectos se resuelven editando o eliminando uno o más de los
archivos en ".idlerc".

En la pestaña Fuentes (*Font*), consulte la muestra de texto para ver
el efecto de la fuente y el tamaño de la fuente en varios caracteres
en varios idiomas.  Edite la muestra para agregar otros caracteres de
interés personal.  Use la muestra para seleccionar fuentes
monoespaciadas.  Si determinados caracteres tienen problemas en el
shell o en el editor, agréguelos a la parte inicial de la muestra e
intente cambiar primero el tamaño y luego la fuente.

En la pestaña Resaltado y Teclas (*Highlights and Keys*), seleccione
un tema de color integrado o personalizado y un conjunto de teclas.
Para utilizar un nuevo tema de color integrado o un conjunto de teclas
con IDLE más antiguos, guárdelo como un nuevo tema personalizado o
conjunto de teclas y será accesible para los IDLE más antiguos.


IDLE en macOS
-------------

En Preferencias del sistema: Dock, puede establecer "Preferencias de
pestañas al abrir documentos" en el valor "Siempre".  Este parámetro
no es compatible con la interfaz gráfica de usuario del framework
tk/tkinter utilizado por IDLE y rompe algunas funcionalidades del
IDLE.


Extensiones
-----------

IDLE incluye una herramienta de extensiones.  Las preferencias para
las extensiones se pueden cambiar con la pestaña Extensiones de la
ventana de preferencias. Lea el inicio de config-extensions.def en la
carpeta idlelib para obtener más información.  La única extensión
utilizada actualmente por defecto es zzdummy, un ejemplo que también
se utiliza para realizar pruebas.
