# IDLE

Code source : Lib/idlelib/

IDLE est l'environnement de développement et d'apprentissage intégré de Python (Integrated Development and Learning Environment).

IDLE a les fonctionnalités suivantes :

- multiplateformes : fonctionne de la même manière sous Windows, Unix et macOS

- Console Python (interpréteur interactif) avec coloration du code entré, des sorties et des messages d'erreur

- éditeur de texte multi-fenêtres avec annulations multiples, coloration Python, indentation automatique, aide pour les appels de fonction, autocomplétion, parmi d'autres fonctionnalités

- recherche dans n'importe quelle fenêtre, remplacement dans une fenêtre d'édition et recherche dans des fichiers multiples (grep)

- débogueur avec points d'arrêt persistants, pas-à-pas et visualisation des espaces de nommage locaux et globaux

- configuration, navigateur et d'autres fenêtres de dialogue

## Menus

IDLE a deux principaux types de fenêtre, la fenêtre de console et la fenêtre d'édition. Il est possible d'avoir de multiples fenêtres d'édition ouvertes simultanément. Sous Windows et Linux, chacune a son propre menu. Chaque menu documenté ci-dessous indique à quel type de fenêtre il est associé.

Les fenêtre d'affichage, comme celles qui sont utilisées pour Edit => Find in Files, sont un sous-type de fenêtre d'édition. Elles possèdent actuellement le même menu principal mais un titre par défaut et un menu contextuel différents.

Sous macOS, il y a un menu d'application. Il change dynamiquement en fonction de la fenêtre active. Il a un menu IDLE et certaines entrées décrites ci-dessous sont déplacées conformément aux directives d'Apple.

### Menu File (Console et Éditeur)

New File

  Crée une nouvelle fenêtre d'édition.

Open...

  Ouvre un fichier existant avec une fenêtre de dialogue pour l'ouverture.

Open Module...

  Ouvre un module existant (cherche dans sys.path).

Recent Files

  Ouvre une liste des fichiers récents. Cliquez sur l'un d'eux pour l'ouvrir.

Module Browser

  Montre les fonctions, classes et méthodes dans une arborescence pour le fichier en cours d'édition. Dans la console, ouvre d'abord un module.

Path Browser

  Affiche les dossiers de sys.path, les modules, fonctions, classes et méthodes dans une arborescence.

Save

  Enregistre la fenêtre active sous le fichier associé, s'il existe. Les fenêtres qui ont été modifiées depuis leur ouverture ou leur dernier enregistrement ont un * avant et après le titre de la fenêtre. S'il n'y a aucun fichier associé, exécute Save As à la place.

Save As...

  Save the current window with a Save As dialog. The file saved becomes the new associated file for the window. (If your file namager is set to hide extensions, the current extension will be omitted in the file name box. If the new filename has no '.', '.py' and '.txt' will be added for Python and text files, except that on macOS Aqua,'.py' is added for all files.)

Save Copy As...

  Save the current window to different file without changing the associated file. (See Save As note above about filename extensions.)

Print Window

  Imprime la fenêtre active avec l'imprimante par défaut.

Close Window

  Close the current window (if an unsaved editor, ask to save; if an unsaved Shell, ask to quit execution). Calling `exit()` or `close()` in the Shell window also closes Shell. If this is the only window, also exit IDLE.

Exit IDLE

  Close all windows and quit IDLE (ask to save unsaved edit windows).

### Menu Edit (console et éditeur)

Undo

  Annule le dernier changement dans la fenêtre active. Un maximum de 1000 changements peut être annulé.

Redo

  Ré-applique le dernier changement annulé dans la fenêtre active.

Select All

  Sélectionne la totalité du contenu de la fenêtre active.

Cut

  Copie la sélection dans le presse-papier global ; puis supprime la sélection.

Copy

  Copie la sélection dans le presse-papier global.

Paste

  Insère le contenu du presse-papier global dans la fenêtre active.

Les fonctions du presse-papier sont aussi disponibles dans les menus contextuels.

Find...

  Ouvre une fenêtre de recherche avec de nombreuses options

Find Again

  Répète la dernière recherche, s'il y en a une.

Find Selection

  Cherche la chaîne sélectionnée, s'il y en a une.

Find in Files...

  Ouvre une fenêtre de recherche de fichiers. Présente les résultats dans une nouvelle fenêtre d'affichage.

Replace...

  Ouvre une fenêtre de recherche et remplacement.

Go to Line

  Move the cursor to the beginning of the line requested and make that line visible. A request past the end of the file goes to the end. Clear any selection and update the line and column status.

Show Completions

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

Expand Word

  Complète un préfixe que vous avez saisi pour correspondre à un mot complet de la même fenêtre ; recommencez pour obtenir un autre complément.

Show Call Tip

  Après une parenthèse ouverte pour une fonction, ouvre une petite fenêtre avec des indications sur les paramètres de la fonction. Reportez-vous à Aides aux appels dans la section Édition et navigation ci-dessous.

Show Surrounding Parens

  Surligne les parenthèses encadrantes.

### Menu Format (fenêtre d'édition uniquement)

Format Paragraph

  Reformate le paragraphe actif, délimité par des lignes vides, en un bloc de commentaires, ou la chaîne de caractères multi-lignes ou ligne sélectionnée en chaîne de caractères. Toutes les lignes du paragraphe seront formatées à moins de N colonnes, avec N valant 72 par défaut.

Indent Region

  Décale les lignes sélectionnées vers la droite d'un niveau d'indentation (4 espaces par défaut).

Dedent Region

  Décale les lignes sélectionnées vers la gauche d'un niveau d'indentation (4 espaces par défaut).

Comment Out Region

  Insère ## devant les lignes sélectionnées.

Uncomment Region

  Enlève les # ou ## au début des lignes sélectionnées.

Tabify Region

  Transforme les blocs d'espaces au début des lignes en tabulations. (Note : Nous recommandons d'utiliser des blocs de 4 espaces pour indenter du code Python.)

Untabify Region

  Transforme toutes les tabulations en le bon nombre d'espaces.

Toggle Tabs

  Ouvre une boîte de dialogue permettant de passer des espaces aux tabulations (et inversement) pour l'indentation.

New Indent Width

  Ouvre une boîte de dialogue pour changer la taille de l'indentation. La valeur par défaut acceptée par la communauté Python est de 4 espaces.

Strip Trailing Chitespace

  Enlève les espaces après le dernier caractère non blanc d'une ligne en appliquant str.rstrip à chaque ligne, y compris les lignes avec des chaînes de caractères multi-lignes. À l'exception des fenêtres de terminal, supprime les lignes supplémentaires à la fin du fichier.

### Menu Run (fenêtre d'édition uniquement)

Run Module

  Applique Check Module (ci-dessus). S'il n'y a pas d'erreur, redémarre la console pour nettoyer l'environnement, puis exécute le module. Les sorties sont affichées dans la fenêtre de console. Notez qu'une sortie requiert l'utilisation de `print` ou `write`. Quand l'exécution est terminée, la console reste active et affiche une invite de commande. À ce moment, vous pouvez explorer interactivement le résultat de l'exécution. Ceci est similaire à l'exécution d'un fichier avec `python -i fichier` sur un terminal.

Run... Customized

  Similaire à Run Module, mais lance le module avec des paramètres personnalisés. Les Command Line Arguments se rajoutent à `sys.argv` comme s'ils étaient passés par la ligne de commande. Le module peut être lancé dans le terminal sans avoir à le redémarrer.

Check Module

  Vérifie la syntaxe du module actuellement ouvert dans la fenêtre d'édition. Si le module n'a pas été enregistré, IDLE va soit demander à enregistrer à l'utilisateur, soit enregistrer automatiquement, selon l'option sélectionnée dans l'onglet General de la fenêtre de configuration d'IDLE. S'il y a une erreur de syntaxe, l'emplacement approximatif est indiqué dans la fenêtre d'édition.

Console Python

  Ouvre ou active la fenêtre de console Python.

### Menu Shell (fenêtre de console uniquement)

View Last Restart

  Fait défiler la fenêtre de console jusqu'au dernier redémarrage de la console.

Restart Shell

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

Previous History

  Parcours les commandes précédentes dans l'historique qui correspondent à l'entrée actuelle.

Next History

  Parcours les commandes suivantes dans l'historique qui correspondent à l'entrée actuelle.

Interrupt Execution

  Arrête un programme en cours d'exécution.

### Menu Debug (fenêtre de console uniquement)

Go to File/Line

  Cherche, sur la ligne active et la ligne en-dessous, un nom de fichier et un numéro de ligne. Le cas échéant, ouvre le fichier s'il n'est pas encore ouvert et montre la ligne. Utilisez ceci pour visualiser les lignes de code source référencées dans un traceback d'exception et les lignes trouvées par Find in Files. Également disponible dans le menu contextuel des fenêtres de console et d'affichage.

Debugger ([dés]activer)

  Quand cette fonctionnalité est activée, le code saisi dans la console ou exécuté depuis un Éditeur s'exécutera avec le débogueur. Dans l'Éditeur, des points d'arrêt peuvent être placés avec le menu contextuel. Cette fonctionnalité est encore incomplète et plus ou moins expérimentale.

Stack Viewer

  Montre l'état de la pile au moment de la dernière erreur dans une arborescence, avec accès aux variables locales et globales.

Auto-open Stack Viewer

  Active ou désactive l'ouverture automatique de l'afficheur de pile après une erreur non gérée.

### Menu Options (console et éditeur)

Configure IDLE

  Ouvre une fenêtre de configuration et change les préférences pour les éléments suivants : police, indentation, raccourcis clavier, thème de coloration du texte, taille et nature de la fenêtre au lancement, sources d'aide additionnelles et extensions. Sous macOS, ouvrez la fenêtre de configuration en sélectionnant Preferences dans le menu de l'application. Pour plus de détails, référez-vous à Modifier les préférences dans Aide et paramètres.

La plupart des paramètres de configuration s'appliquent à toutes les fenêtres, ouvertes ou non. Les éléments d'option ci-dessous s'appliquent uniquement à la fenêtre active.

Show/Hide Code Context (fenêtres d'édition uniquement)

  Fais passer la fenêtre de taille normale à maximale. La taille de départ par défaut est de 40 lignes par 80 caractères, sauf changement dans l'onglet General de la fenêtre de configuration d'IDLE. Consultez Code Context dans la section « Édition et navigation » ci-dessous.

Show/Hide Line Numbers (fenêtre de l'éditeur uniquement)

  Ajoute une colonne à gauche de la fenêtre d'édition qui indique le numéro de chaque ligne de texte. Cette colonne est désactivée par défaut, ce qui peut être modifié dans les préférences (voir Modifier les préférences).

Zoom/Restore Height

  Bascule la fenêtre entre la taille normale et la hauteur maximale. La taille initiale par défaut est de 40 lignes par 80 caractères, sauf si elle est modifiée dans l'onglet « General » de la boîte de dialogue « Configure IDLE ». La hauteur maximale d'un écran est déterminée en maximisant momentanément une fenêtre lors du premier zoom sur l'écran. La modification des paramètres d'écran peut invalider la hauteur enregistrée. Cette bascule n'a aucun effet lorsqu'une fenêtre est agrandie.

### Menu Windows (console et éditeur)

Liste les noms de toutes les fenêtres ouvertes ; sélectionnez-en une pour l'amener au premier plan (en l'ouvrant si nécessaire).

### Menu Help (console et éditeur)

About IDLE

  Affiche la version, les copyrights, la licence, les crédits, entre autres.

IDLE Help

  Affiche ce document IDLE, qui détaille les options des menus, les bases de l'édition et de la navigation ainsi que d'autres astuces.

Python Docs

  Accède à la documentation Python locale, si installée, ou ouvre docs.python.org dans un navigateur pour afficher la documentation Python la plus récente.

Turtle Demo

  Exécute le module turtledemo avec des exemples de code Python et de dessins turtle.

Des sources d'aide supplémentaires peuvent être ajoutées ici avec la fenêtre de configuration d'IDLE dans l'onglet General. Référez-vous à la sous-section Sources d'aide ci-dessous pour plus de détails sur les choix du menu d'aide.

### Context menus

Vous pouvez ouvrir un menu contextuel par un clic droit dans une fenêtre (Contrôle-clic sous macOS). Les menus contextuels ont les fonctions de presse-papier standard, également disponibles dans le menu Edit.

Cut

  Copie la sélection dans le presse-papier global ; puis supprime la sélection.

Copy

  Copie la sélection dans le presse-papier global.

Paste

  Insère le contenu du presse-papier global dans la fenêtre active.

Les fenêtres d'édition ont aussi des fonctions de points d'arrêt. Les lignes sur lesquelles est défini un point d'arrêt sont marquées de manière spéciale. Les points d'arrêt n'ont d'effet que lorsque l'exécution se déroule sous débogueur. Les points d'arrêt pour un fichier sont enregistrés dans le dossier `.idlerc` de l'utilisateur.

Set Breakpoint

  Place un point d'arrêt sur la ligne active.

Clear Breakpoint

  Enlève le point d'arrêt sur cette ligne.

Les fenêtres de console et d'affichage disposent en plus des éléments suivants.

Go to file/line

  Même effet que dans le menu Debug.

Les fenêtres de console ont également une fonction de réduction des sorties détaillée dans la sous-section fenêtre de console de Python ci-dessous.

Squeeze

  Si le curseur est sur une ligne d'affichage, compacte toute la sortie entre le code au-dessus et l'invite en-dessous en un bouton "Squeezed text".

## Editing and Navigation

### Fenêtre d'édition

IDLE peut ouvrir une fenêtre d'édition quand il démarre, selon les paramètres et la manière dont vous démarrez IDLE. Ensuite, utilisez le menu File. Il ne peut y avoir qu'une fenêtre d'édition pour un fichier donné.

La barre de titre contient le nom du fichier, le chemin absolu et la version de Python et d'IDLE s'exécutant dans la fenêtre. La barre de statut contient le numéro de ligne ("Ln") et le numéro de la colonne ("Col"). Les numéros de ligne commencent à 1 ; les numéros de colonne commencent à 0.

IDLE suppose que les fichiers avec une extension en .py* reconnue contiennent du code Python, mais pas les autres fichiers. Exécutez du code Python avec le menu Run.

### Raccourcis clavier

The IDLE insertion cursor is a thin vertical bar between character positions. When characters are entered, the insertion cursor and everything to its right moves right one character and the new character is entered in the new space.

Several non-character keys move the cursor and possibly delete characters. Deletion does not puts text on the clipboard, but IDLE has an undo list. Wherever this doc discusses keys, 'C' refers to the `Control` key on Windows and Unix and the `Command` key on macOS. (And all such discussions assume that the keys have not been re-bound to something else.)

- Arrow keys move the cursor one character or line.

- ``C`-`LeftArrow`` and ``C`-`RightArrow`` moves left or right one word.

- `Home` and `End` go to the beginning or end of the line.

- `Page Up` and `Page Down` go up or down one screen.

- ``C`-`Home`` and ``C`-`End`` go to beginning or end of the file.

- `Backspace` and `Del` (or ``C`-`d``) delete the previous or next character.

- ``C`-`Backspace`` and ``C`-`Del`` delete one word left or right.

- ``C`-`k`` deletes ('kills') everything to the right.

Les raccourcis clavier standards (comme ``C`-`c`` pour copier et ``C`-`v`` pour coller) peuvent fonctionner. Les raccourcis clavier sont sélectionnés dans la fenêtre de configuration d'IDLE.

### Indentation automatique

Après une structure d'ouverture de bloc, la prochaine ligne est indentée de 4 espaces (dans la console Python d'une tabulation). Après certains mots-clefs (break, return etc) la ligne suivante est dédentée. Dans une indentation au début de la ligne, ``Retour` `arrière`` supprime jusqu'à 4 espaces s'il y en a. `Tab` insère des espaces (dans la console, une tabulation), en nombre dépendant de la configuration. Les tabulations sont actuellement restreintes à quatre espaces à cause de limitations de Tcl/Tk.

Cf. les commandes indent/dedent region dans le menu *Format*.

### Search and Replace

Any selection becomes a search target. However, only selections within a line work because searches are only performed within lines with the terminal newline removed. If `[x] Regular expression` is checked, the target is interpreted according to the Python re module.

### Complétions

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 initially 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.

### Info-bulles

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.

### Contexte du code

Dans une fenêtre d'édition contenant du code Python, le contexte du code peut être activé pour afficher ou cacher une zone en haut de la fenêtre. Quand elle est affichée, cette zone gèle les lignes ouvrant le bloc de code, comme celles qui commencent par les mots-clés `class`, `def` ou `if`, qui auraient autrement été cachées plus haut dans le fichier. La taille de cette zone varie automatiquement selon ce qui est nécessaire pour afficher tous les niveaux de contexte, jusqu'à un nombre maximal de lignes défini dans la fenêtre de configuration d'IDLE (valeur qui vaut 15 par défaut). S'il n'y a pas de lignes de contexte et que cette fonctionnalité est activée, une unique ligne vide est affichée. Un clic sur une ligne dans la zone de contexte déplace cette ligne en haut de l'éditeur.

Les couleurs de texte et du fond pour la zone de contexte peuvent être configurées dans l'onglet Highlights de la fenêtre de configuration d'IDLE.

### Shell window

In IDLE's Shell, enter, edit, and recall complete statements. (Most consoles and terminals only work with a single physical line at a time).

Submit a single-line statement for execution by hitting `Return` with the cursor anywhere on the line. If a line is extended with Backslash (`\`), the cursor must be on the last physical line. Submit a multi-line compound statement by entering a blank line after the statement.

When one pastes code into Shell, it is not compiled and possibly executed until one hits `Return`, as specified above. One may edit pasted code first. If one pastes more than one statement into Shell, the result will be a `SyntaxError` when multiple statements are compiled as if they were one.

Lines containing `RESTART` mean that the user execution process has been re-started. This occurs when the user execution process has crashed, when one requests a restart on the Shell menu, or when one runs code in an editor window.

The editing features described in previous subsections work when entering code interactively. IDLE's Shell window also responds to the following:

- ``C`-`c`` attempts to interrupt statement execution (but may fail).

- ``C`-`d`` closes Shell if typed at a `>>>` prompt.

- ``Alt`-`p`` and ``Alt`-`n`` (``C`-`p`` and ``C`-`n`` on macOS) retrieve to the current prompt the previous or next previously entered statement that matches anything already typed.

- `Return` while the cursor is on any previous statement appends the latter to anything already typed at the prompt.

### Coloration du texte

IDLE affiche par défaut le texte en noir sur blanc mais colore le texte qui possède une signification spéciale. Pour la console, ceci concerne les sorties de la console et de l'utilisateur ainsi que les erreurs de l'utilisateur. Pour le code Python, dans l'invite de commande de la console ou sur un éditeur, ce sont les mots-clefs, noms de fonctions et de classes incluses par défaut, les noms suivant `class` et `def`, les chaînes de caractères et les commentaires. Pour n'importe quelle fenêtre de texte, ce sont le curseur (si présent), le texte trouvé (s'il y en a) et le texte sélectionné.

IDLE also highlights the soft keywords `match`, `case`, and `_` in pattern-matching statements. However, this highlighting is not perfect and will be incorrect in some rare cases, including some `_`-s in `case` patterns.

La coloration du texte est faite en arrière-plan, donc du texte non coloré est parfois visible. Pour changer les couleurs, utilisez l'onglet Highlighting de la fenêtre de configuration d'IDLE. Le marquage des points d'arrêt du débogueur dans l'éditeur et du texte dans les dialogues n'est pas configurable.

## Startup and Code Execution

Quand il est démarré avec l'option `-s`, IDLE exécutera le fichier référencé par la variable d'environnement `IDLE*STARTUP` ou `PYTHONSTARTUP`. IDLE cherche d'abord `IDLESTARTUP` ; si `IDLESTARTUP` est présent, le fichier référencé est exécuté. Si `IDLESTARTUP` n'est pas présent, alors IDLE cherche `PYTHONSTARTUP`. Les fichiers référencés par ces variables d'environnement sont de bons endroits pour stocker des fonctions qui sont utilisées fréquemment depuis la console d'IDLE ou pour exécuter des commandes d'importation des modules communs.

De plus, `Tk` charge lui aussi un fichier de démarrage s'il est présent. Notez que le fichier de Tk est chargé sans condition. Ce fichier additionnel est `.Idle.py` et est recherché dans le dossier personnel de l'utilisateur. Les commandes dans ce fichier sont exécutées dans l'espace de nommage de Tk, donc ce fichier n'est pas utile pour importer des fonctions à utiliser depuis la console Python d'IDLE.

### Utilisation de la ligne de commande

    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)

S'il y a des arguments :

- Si `-`, `-c` ou `-r` sont utilisés, tous les arguments sont placés dans `sys.argv[1:...]` et `sys.argv[0]` est assigné à `''`, `'-c'`, ou `'-r'`. Aucune fenêtre d'édition n'est ouverte, même si c'est le comportement par défaut fixé dans la fenêtre d'options.

- Sinon, les arguments sont des fichiers ouverts pour édition et `sys.argv` reflète les arguments passés à IDLE lui-même.

### Échec au démarrage

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.

Une cause d'échec courant est un fichier écrit par l'utilisateur avec le même nom qu'un module de la bibliothèque standard, comme random.py et tkinter.py. Quand un fichier de ce genre est enregistré dans le même répertoire qu'un fichier à exécuter, IDLE ne peut pas importer le fichier standard. La solution actuelle consiste à renommer le fichier de l'utilisateur.

Même si c'est plus rare qu'avant, un antivirus ou un pare-feu peuvent interrompre la connexion. Si le programme ne peut pas être paramétré pour autoriser la connexion, alors il doit être éteint pour qu'IDLE puisse fonctionner. Cette connexion interne est sûre car aucune donnée n'est visible depuis un port extérieur. Un problème similaire est une mauvaise configuration du réseau qui bloque les connexions.

Des problèmes d'installation de Python stoppent parfois IDLE : il peut y avoir un conflit de versions ou bien l'installation peut nécessiter des privilèges administrateurs. Si on corrige le conflit , ou qu'on ne peut ou ne veut pas accorder de privilège, il peut être plus facile de désinstaller complètement Python et de recommencer.

A zombie pythonw.exe process could be a problem. On Windows, use Task Manager to check for one and stop it if there is. Sometimes a restart initiated by a program crash or Keyboard Interrupt (control-C) may fail to connect. Dismissing the error box or using Restart Shell on the Shell menu may fix a temporary problem.

When IDLE first starts, it attempts to read user configuration files in `~/.idlerc/` (~ is one's home directory). If there is a problem, an error message should be displayed. Leaving aside random disk glitches, this can be prevented by never editing the files by hand. Instead, use the configuration dialog, under Options. Once there is an error in a user configuration file, the best solution may be to delete it and start over with the settings dialog.

If IDLE quits with no message, and it was not started from a console, try starting it from a console or terminal (`python -m idlelib`) and see if this results in an error message.

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.

### Exécuter le code de l'utilisateur

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.

Par défaut, IDLE exécute le code de l'utilisateur dans un processus système séparé plutôt que dans le processus d'interface utilisateur qui exécute la console et l'éditeur. Dans le processus d'exécution, il remplace `sys.stdin`, `sys.stdout` et `sys.stderr` par des objets qui récupèrent les entrées et envoient les sorties à la fenêtre de console. Les valeurs originales stockées dans `sys.__stdin__`, `sys.__stdout__` et `sys.__stderr__` ne sont pas touchées, mais peuvent être `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.

IDLE's standard stream replacements are not inherited by subprocesses created in the execution process, whether directly by user code or by modules such as multiprocessing. If such subprocess use `input` from sys.stdin or `print` or `write` to sys.stdout or sys.stderr, IDLE should be started in a command line window. (On Windows, use `python` or `py` rather than `pythonw` or `pyw`.) The secondary subprocess will then be attached to that window for input and output.

Si `sys` est réinitialisé par le code de l'utilisateur, comme avec `importlib.reload(sys)`, les changements d'IDLE seront perdus et l'entrée du clavier et la sortie à l'écran ne fonctionneront pas correctement.

Quand la console est au premier plan, elle contrôle le clavier et l'écran. Ceci est normalement transparent, mais les fonctions qui accèdent directement au clavier et à l'écran ne fonctionneront pas. Ceci inclut des fonctions spécifiques du système qui déterminent si une touche a été pressée et, le cas échéant, laquelle.

Le code IDLE tournant dans le processus d'exécution ajoute des appels de fonctions à la pile d'appels qui ne seraient pas là autrement. IDLE encapsule `sys.getrecursionlimit` et `sys.setrecursionlimit` pour réduire l'effet des piles de fonctions supplémentaires.

Lorsque l'utilisateur lève `SystemExit` directement ou en appelant `sys.exit`, IDLE revient au terminal IDLE au lieu de quitter.

### Sortie de l'utilisateur sur la console

Quand un programme affiche du texte, le résultat est déterminé par le support d'affichage correspondant. Quand IDLE exécute du code de l'utilisateur, `sys.stdout` et `sys.stderr` sont connectées à la zone d'affichage de la console d'IDLE. Certaines de ces fonctionnalités sont héritées des widgets Tk sous-jacents. D'autres sont des additions programmées. Quand cela importe, la console est conçue pour le développement plutôt que l'exécution en production.

Par exemple, la console ne supprime jamais de sortie. Un programme qui écrit à l'infini dans la console finira par remplir la mémoire, ce qui entraînera un erreur mémoire. Par ailleurs, certains systèmes de fenêtres textuelles ne conservent que les n dernières lignes de sortie. Une console Windows, par exemple, conserve une quantité de lignes configurable entre 1 et 9999, avec une valeur par défaut de 300.

Un widget Text de Tk et donc la console d'IDLE, affiche des caractères (points de code) dans le sous-ensemble BMP (Basic Multilingual Plane) d'Unicode. Quels caractères sont affichés avec le bon glyphe et lesquels sont affichés avec un caractère de remplacement dépend du système d'exploitation et des polices installées. Les caractères de tabulation font que le texte suivant commencera après le prochain taquet de tabulation (ils sont placés tous les 8 "caractères"). Les caractères saut de ligne font apparaître le texte suivant sur une nouvelle ligne. Les autres caractères de contrôle sont ignorés ou affichés sous forme d'espace, de boîte, ou d'autre chose, selon le système d'exploitation et la police (déplacer le curseur de texte sur un affichage de ce genre peut provoquer un comportement surprenant du point de vue de l'espacement).

    >>> 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 fonction `repr` est utilisée pour l'affichage interactif de la valeur des expressions. Elle renvoie une version modifiée de la chaîne en entrée dans laquelle les codes de contrôle, certains points de code BMP et tous les points de code non BMP sont remplacés par des caractères d'échappement. Comme montré ci-dessus, ceci permet d'identifier les caractères dans une chaîne, quelle que soit la façon dont elle est affichée.

Les sorties standard et d'erreur sont généralement séparées (sur des lignes séparées) de l'entrée de code et entre elles. Elles ont chacune une coloration différente.

Pour les traceback de SyntaxError, le "^" habituel marquant l'endroit où l'erreur a été détectée est remplacé par la coloration et le surlignage du texte avec une erreur. Quand du code exécuté depuis un fichier cause d'autres exceptions, un clic droit sur la ligne du traceback permet d'accéder à la ligne correspondante dans un éditeur IDLE. Le fichier est ouvert si nécessaire.

La console a une fonctionnalité spéciale pour réduire les lignes de sorties à une étiquette "Squeezed text". Ceci est fait automatiquement pour un sortie de plus de N lignes (N = 50 par défaut). N peut être changé dans la section PyShell de la page General de la fenêtre de configuration. Les sorties avec moins de lignes peuvent être réduites par un clic droit sur la sortie. Ceci peut être utile sur des lignes si longues qu'elles ralentissent la navigation.

Les sorties réduites sont étendues sur place en double-cliquant sur l'étiquette Elles peuvent aussi être envoyées au presse-papier ou sur un fenêtre séparée par un clic-droit sur l'étiquette.

### Développer des applications tkinter

IDLE est intentionnellement différent de Python standard dans le but de faciliter le développement des programmes tkinter. Saisissez `import *tkinter* as tk; root = tk.Tk()` avec Python standard, rien n'apparaît. Saisissez la même chose dans IDLE et une fenêtre tk apparaît. En Python standard, il faut également saisir `root.update()` pour voir la fenêtre. IDLE fait un équivalent mais en arrière-plan, environ 20 fois par seconde, soit environ toutes les 50 millisecondes. Ensuite, saisissez `b = tk.Button(root, text='button'); b.pack()`. De la même manière, aucun changement n'est visible en Python standard jusqu'à la saisie de `root.update()`.

La plupart des programmes tkinter exécutent `root.mainloop()`, qui d'habitude ne renvoie pas jusqu'à ce que l'application tk soit détruite. Si le programme est exécuté avec `python -i` ou depuis un éditeur IDLE, une invite de commande `>>>` n'apparaît pas tant que `mainloop()` ne termine pas, c'est-à-dire quand il ne reste plus rien avec lequel interagir.

Avec un programme tkinter exécuté depuis un éditeur IDLE, vous pouvez immédiatement commenter l'appel à mainloop. On a alors accès à une invite de commande et on peut interagir en direct avec l'application. Il faut juste se rappeler de réactiver l'appel à mainloop lors de l'exécution en Python standard.

### Exécution sans sous-processus

By default, IDLE executes user code in a separate subprocess via a socket, which uses the internal loopback interface. This connection is not externally visible and no data is sent to or received from the internet. If firewall software complains anyway, you can ignore it.

Si la tentative de connexion par le socket échoue, IDLE vous le notifie. Ce genre d'échec est parfois temporaire, mais s'il persiste, le problème peut soit venir d'un pare-feu qui bloque la connexion ou d'une mauvaise configuration dans un système particulier. Jusqu'à ce que le problème soit résolu, vous pouvez exécuter IDLE avec l'option -n de la ligne de commande.

Si IDLE est démarré avec l'option -n de la ligne de commande, il s'exécute dans un seul processus et ne crée pas de sous-processus pour exécuter le serveur RPC d'exécution de Python. Ceci peut être utile si Python ne peut pas créer de sous-processus ou de connecteur RPC sur votre plateforme. Cependant, dans ce mode, le code de l'utilisateur n'est pas isolé de IDLE lui-même. De plus, l'environnement n'est pas réinitialisé quand Run/Run Module (`F5`) est sélectionné. Si votre code a été modifié, vous devez reload() les modules affectés et ré-importer tous les éléments spécifiques (e.g. from foo import baz) pour que les changements prennent effet. Pour toutes ces raisons, il est préférable d'exécuter IDLE avec le sous-processus par défaut si c'est possible.

Obsolète depuis la version 3.4.

## Help and Preferences

### Sources d'aide

L'entrée du menu d'aide "IDLE Help" affiche une version html formatée du chapitre sur IDLE de la Library Reference. Le résultat, dans une fenêtre de texte tkinter en lecture-seule, est proche de ce qu'on voit dans un navigateur. Naviguez dans le texte avec la molette de la souris, la barre de défilement ou avec les touches directionnelles du clavier enfoncées. Ou cliquez sur le bouton TOC (Table of Contents : sommaire) et sélectionnez un titre de section dans l'espace ouvert.

L'entrée du menu d'aide "Python Docs" ouvre les sources d'aide détaillées, incluant des tutoriels, disponibles sur https://docs.python.org/x.y, avec "x.y" la version de Python en cours d'exécution. Si votre système a une copie locale de la documentation (cela peut être une option d'installation), c'est elle qui est ouverte.

Les URL sélectionnées peuvent être ajoutées ou enlevées du menu d'aide à n'importe quel moment en utilisant l'onglet « General » de la fenêtre « Configure IDLE ».

### Modifier les préférences

Les préférences de polices, surlignage, touches et les préférences générales peuvent être changées via « Configure IDLE » dans le menu « Options ». Les paramètres modifiés par l'utilisateur sont enregistrés dans un dossier `.idlerc` dans le dossier personnel de l'utilisateur. Les problèmes causés par des fichiers de configuration utilisateur corrompus sont résolus en modifiant ou en supprimant un ou plusieurs fichiers dans .idlerc.

Dans l'onglet Fonts, regardez les échantillons de texte pour voir l'effet de la police et de la taille sur de multiples caractères de multiples langues. Éditez les échantillons pour ajouter d'autres caractères qui vous intéressent. Utilisez les échantillons pour sélectionner les polices à largeur constante. Si certains caractères posent des difficultés dans la console ou l'éditeur, ajoutez-les en haut des échantillons et essayez de changer d'abord la taille, puis la fonte.

Dans les onglets Highlights et Keys, sélectionnez un ensemble de couleurs et de raccourcis pré-inclus ou personnalisé. Pour utiliser un ensemble de couleurs et de raccourcis récent avec une version d'IDLE plus ancienne, enregistrez-le en tant que nouveau thème ou ensemble de raccourcis personnalisé ; il sera alors accessible aux IDLE plus anciens.

### IDLE sous macOS

Dans System Preferences: Dock, on peut mettre "Prefer tabs when opening documents" à la valeur "Always". Ce paramètre n'est pas compatible avec le cadriciel tk/tkinter utilisé par IDLE et il casse quelques fonctionnalités d'IDLE.

### Extensions

IDLE inclut un outil d'extensions. Les préférences pour les extensions peuvent être changées avec l'onglet Extensions de la fenêtre de préférences. Lisez le début de config-extensions.def dans le dossier idlelib pour plus d'informations. La seule extension actuellement utilisée par défaut est zzdummy, un exemple également utilisé pour les tests.

## idlelib

Source code: Lib/idlelib

The Lib/idlelib package implements the IDLE application. See the rest of this page for how to use IDLE.

The files in idlelib are described in idlelib/README.txt. Access it either in idlelib or click Help => About IDLE on the IDLE menu. This file also maps IDLE menu items to the code that implements the item. Except for files listed under 'Startup', the idlelib code is 'private' in sense that feature changes can be backported (see PEP 434).