25.5. *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 :

* codé à 100% en pur Python, en utilisant l'outil d'interfaçage
  graphique "tkinter"

* cross-platform: works mostly the same on Windows, Unix, and 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


25.5.1. Menus
=============

IDLE has two main window types, the Shell window and the Editor
window.  It is possible to have multiple editor windows
simultaneously.  On Windows and Linux, each has its own top menu.
Each menu documented below indicates which window type it is
associated with.

Output windows, such as used for Edit => Find in Files, are a subtype
of editor window.  They currently have the same top menu but a
different default title and context menu.

On macOS, there is one application menu.  It dynamically changes
according to the window currently selected.  It has an IDLE menu, and
some entries described below are moved around to conform to Apple
guidlines.


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

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

*Open Module...*
   Ouvre un module existant (cherche dans *sys.path*).

*Class 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...*
   Enregistre la fenêtre active avec une fenêtre de dialogue
   d'enregistrement. Le fichier enregistré devient le nouveau fichier
   associé pour cette fenêtre.

*Save Copy As...*
   Enregistre la fenêtre active sous un fichier différent sans changer
   le fichier associé.

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

*Close*
   Ferme la fenêtre active (demande à enregistrer si besoin).

*Exit*
   Ferme toutes les fenêtres et quitte *IDLE* (demande à enregistrer
   les fenêtres non sauvegardées).


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

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

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

*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*
   Déplace le curseur sur la ligne de numéro demandé et rend cette
   ligne visible.

*Show Completions*
   Open a scrollable list allowing selection of keywords and
   attributes. See Completions in the Tips sections 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*
   After an unclosed parenthesis for a function, open a small window
   with function parameter hints.

*Show surrounding parens*
   Surligne les parenthèses encadrantes.


25.5.1.3. Menu *Format* (fenêtre d'édition uniquement)
------------------------------------------------------

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

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

*Strip trailing whitespace*
   Enlève les espaces et autres caractères blancs 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ère multi-
   lignes.


25.5.1.4. Menu *Run* (fenêtre d'édition uniquement)
---------------------------------------------------

Console Python
   Ouvre ou active la fenêtre de console Python.

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

*Run Module*
   Do Check Module (above).  If no error, restart the shell to clean
   the environment, then execute the module.  Output is displayed in
   the Shell window.  Note that output requires use of "print" or
   "write". When execution is complete, the Shell retains focus and
   displays a prompt. At this point, one may interactively explore the
   result of execution. This is similar to executing a file with
   "python -i file" at a command line.


25.5.1.5. 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*
   Redémarre la console pour nettoyer l'environnement.

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


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


25.5.1.7. Menu *Options* (console et éditeur)
---------------------------------------------

*Configure IDLE*
   Open a configuration dialog and change preferences for the
   following: fonts, indentation, keybindings, text color themes,
   startup windows and size, additional help sources, and extensions
   (see below).  On macOS, open the configuration dialog by selecting
   Preferences in the application menu.  To use a new built-in color
   theme (IDLE Dark) with older IDLEs, save it as a new custom theme.

   Non-default user settings are saved in a .idlerc directory in the
   user's home directory.  Problems caused by bad user configuration
   files are solved by editing or deleting one or more of the files in
   .idlerc.

Code Context (toggle)(Editor Window only)
   Open a pane at the top of the edit window which shows the block
   context of the code which has scrolled above the top of the window.
   Clicking a line in this pane exposes that line at the top of the
   editor.


25.5.1.8. Menu *Windows* (console et éditeur)
---------------------------------------------

Zoom Height
   Toggles the window between normal size and maximum height. The
   initial size defaults to 40 lines by 80 chars unless changed on the
   General tab of the Configure IDLE dialog.

The rest of this menu lists the names of all open windows; select one
to bring it to the foreground (deiconifying it if necessary).


25.5.1.9. Menu *Help* (console et éditeur)
------------------------------------------

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

*IDLE Help*
   Display this IDLE document, detailing the menu options, basic
   editing and navigation, and other tips.

*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*
   Run the turtledemo module with example python code and turtle
   drawings.

Additional help sources may be added here with the Configure IDLE
dialog under the General tab. See the "Help sources" subsection below
for more on Help menu choices.


25.5.1.10. Menus Contextuels
----------------------------

Open a context menu by right-clicking in a window (Control-click on
macOS). Context menus have the standard clipboard functions also on
the Edit menu.

*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 avec un point d'arrêt activé sont marquées. 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.

Shell and Output windows also have the following.

*Go to file/line*
   Même effet que dans le menu *Debug*.

The Shell window also has an output squeezing facility explained in
the the *Python Shell window* subsection below.

Squeeze
   If the cursor is over an output line, squeeze all the output
   between the code above and the prompt below down to a 'Squeezed
   text' label.


25.5.2. Édition et navigation
=============================


25.5.2.1. Editor windows
------------------------

IDLE may open editor windows when it starts, depending on settings and
how you start IDLE.  Thereafter, use the File menu.  There can be only
one open editor window for a given file.

The title bar contains the name of the file, the full path, and the
version of Python and IDLE running the window.  The status bar
contains the line number ('Ln') and column number ('Col').  Line
numbers start with 1; column numbers with 0.

IDLE assumes that files with a known .py* extension contain Python
code and that other files do not.  Run Python code with the Run menu.


25.5.2.2. Key bindings
----------------------

In this section, 'C' refers to the "Control" key on Windows and Unix
and the "Command" key on macOS.

* "Retour arrière" supprime à gauche ; "Suppr" supprime à droite

* "C-Retour arrière" supprime le mot à gauche ; "C-Suppr" supprime le
  mot à droite

* Utilisez les touches flèche et "Page Haut" / "Page Bas" pour vous
  déplacer

* "C-Flèche Gauche" et "C-Flèche Droite" déplacent de mot en mot

* "Début"/"Fin" vont au début / à la fin de la ligne

* "C-Début" / "C-Fin" vont au début / à la fin du fichier

* Quelques raccourcis *Emacs* utiles sont hérités de *Tcl/Tk* :

     * "C-a" début de ligne

     * "C-e" fin de ligne

     * "C-k" supprime la ligne (mais ne la met pas dans le presse-
       papier)

     * "C-l" centre la fenêtre autour du point d’insertion

     * "C-b" recule d'un caractère sans le supprimer (habituellement
       vous pouvez également utiliser les touches flèches pour faire
       cela)

     * "C-f" avance d'un caractère sans le supprimer (habituellement
       vous pouvez également utiliser les touches flèches pour faire
       cela)

     * "C-p" remonte d'une ligne (habituellement vous pouvez également
       utiliser les touches flèches pour faire cela)

     * "C-d" supprime le caractère suivant

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


25.5.2.3. 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*.

See also the indent/dedent region commands in the edit menu.


25.5.2.4. Complétions
---------------------

Les complétions sont fournies pour les fonctions, classes et attributs
de classes incluses par défaut et celles définies par l'utilisateur.
Les complétions sont aussi fournies pour les noms de fichiers.

La fenêtre d'auto-complétion (*ACW*, *AutoCompleteWindow*) s'ouvre
après un délai prédéfini (deux secondes par défaut) après qu'un
*"*."** ou (dans une chaîne) un os.sep est saisi. Si, après un de ces
caractères (éventuellement suivi d'autres caractères), une tabulation
est saisie, l'**ACW** s'ouvre immédiatement si une complétion
compatible est trouvée.

S'il n'y a qu'une seule complétion possible pour le caractère saisi,
un "Tab" fournit cette complétion sans ouvrir l'*ACW*.

*"Show Completions"* force l'ouverture d'une fenêtre de complétion,
par défaut "C-espace" ouvre une fenêtre de complétion. Dans une chaîne
vide, cette fenêtre contient les fichiers du dossier actif. Sur une
ligne vide, elle contient les fonctions et classes intégrées par
défaut et définies par l'utilisateur de l'espace de nommage actif,
plus tous les modules importés. Si des caractères ont été saisis,
l'*ACW* essaie d'être plus spécifique.

Si une chaîne de caractère est saisie, la sélection de l'*ACW* va à
l'entrée la plus proche de ces caractères. Saisir un "Tab" saisit la
plus longue correspondance non ambiguë dans la console ou l'éditeur.
Deux "Tab" à la suite fournissent la sélection de l'*ACW*, de la même
manière que la touche *"Entrée"* ou un double-clic. Les touches
flèches, Page Haut/Bas, la sélection à la souris et la molette de la
souris fonctionnent tous sur l'*ACW*.

Les attributs *"cachés"* peuvent être atteints en saisissant le début
d'un nom caché après un *"*."**, e.g."**_"**. Ceci permet l'accès aux
modules utilisant "__all__" ou aux attributs privés des classes.

Les complétions et la fonctionnalité *"*Expand Word*"* peuvent vous
faire économiser beaucoup de temps !

Les complétions sont actuellement limitées à ce qui est présent dans
les espaces de nommage. Les noms dans une fenêtre d'édition qui ne
viennent pas de "__main__" et "sys.modules" ne sont pas trouvés.
Exécutez votre module avec vos importations pour corriger cette
situation. Notez qu'*IDLE* lui-même place quelques modules dans
*sys.modules*, qui peuvent être donc accédés par défaut, comme le
module *re*.

Si vous n'aimez pas que l'*ACW* s'affiche spontanément, vous pouvez
simplement augmenter le délai ou désactiver l'extension.


25.5.2.5. Info-bulles
---------------------

Une info-bulle est affichée quand vous saisissez "(" après le nom
d'une fonction *accessible*. Une expression de nom peut inclure des
points et des tirets bas.L'info-bulle reste affichée jusqu'à ce que
vous cliquiez dessus, que le curseur se déplace hors de la zone des
arguments, ou que ")" soit saisi. Quand le curseur est dans la partie
*"arguments"* de la définition, le menu ou raccourci affiche une info-
bulle.

Une info-bulle contient la signature de la fonction et la première
ligne de la *docstring*. Pour les fonctions incluses par défaut sans
signature accessible, l'info-bulle contient toutes les lignes jusqu'à
la cinquième ligne ou la première ligne vide. Ces détails sont sujets
à changement.

L'ensemble des fonctions *accessibles* dépend des modules qui ont été
importés dans le processus utilisateur, y compris ceux importés par
*IDLE* lui-même et quelles définitions ont été exécutées, le tout
depuis le dernier redémarrage.

Par exemple, redémarrez la console et saisissez "itertools.count(".
Une info-bulle s'affiche parce que *IDLE* importe *itertools* dans le
processus utilisateur pour son propre usage (ceci pourrait changer).
Saisissez "turtle.write(" et rien ne s'affiche. *IDLE* n'importe pas
*turtle*. Le menu ou le raccourci ne font rien non plus. Saisir
"import *turtle" puis "turtle.write(" fonctionnera.

Dans l'éditeur, les commandes d'importation n'ont pas d'effet jusqu'à
ce que le fichier soit exécuté. Vous pouvez exécuter un fichier après
avoir écrit les commandes d'importation au début, ou immédiatement
exécuter un fichier existant avant de l'éditer.


25.5.2.6. Fenêtre de console Python
-----------------------------------

With IDLE's Shell, one enters, edits, and recalls complete statements.
Most consoles and terminals only work with a single physical line at a
time.

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

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

* "C-c" interrompt l'exécution de la commande

* "C-d" envoie fin-de-fichier (*EOF*) ; cela ferme la fenêtre s'il est
  saisi à une invite ">>>"

* "Alt-/" (Compléter le mot) est également utile pour réduire la
  quantité de texte saisie

  Historique des commandes

  * "Alt-p" retrieves previous command matching what you have typed.
    On macOS use "C-p".

  * "Alt-n" retrieves next. On macOS use "C-n".

  * "Entrée" sur une des commandes précédentes récupère cette commande


25.5.2.7. 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é.

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.


25.5.3. Démarrage et exécution du code
======================================

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


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


25.5.3.2. Échec au démarrage
----------------------------

*IDLE* utilise un connecteur (*socket* en anglais) pour communiquer
entre le processus d'interface graphique d'*IDLE* et le processus
d'exécution de code de l'utilisateur. Une connexion doit être établie
quand la console démarre ou redémarre (le redémarrage est indiqué par
une ligne de division avec *"RESTART"*). Si le processus utilisateur
échoue à établir une connexion avec le processus graphique, il affiche
une fenêtre d'erreur "Tk" avec un message *"connexion impossible"* qui
redirige l'utilisateur ici. Ensuite, il s'arrête.

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.

Un processus *pythonw.exe* zombie peut être un problème. Sous Windows,
utilisez le Gestionnaire des Tâches pour en détecter puis en arrêter
un. Parfois, un redémarrage causé par un plantage ou une interruption
clavier (Ctrl-C) peut ne pas réussir à se connecter. Fermer la fenêtre
d'erreur ou redémarrer la console dans le menu Shell peut résoudre un
problème temporaire.

Quand *IDLE* démarre pour la première fois, il essaie de lire la
configuration de l'utilisateur dans les fichiers de *~/.idlerc* (~ est
le répertoire personnel de l'utilisateur). S'il y a un problème, un
message d'erreur devrait être affiché. Mis à part les erreurs
aléatoires du disque dur, ceci peut être évité en n'éditant jamais les
fichiers directement, mais en utilisant la fenêtre de configuration,
dans Options. Quand cela arrive, la solution peut être de supprimer un
ou plusieurs des fichiers de configuration.

Si *IDLE* se ferme sans message et qu'il n'a pas été démarré depuis
une console, essayez de le démarrer depuis une console ("python -m
idlelib") et regardez si un message apparaît.


25.5.3.3. Running user code
---------------------------

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.activeCount()" returns 2 instead of 1.

By default, IDLE runs user code in a separate OS process rather than
in the user interface process that runs the shell and editor.  In the
execution process, it replaces "sys.stdin", "sys.stdout", and
"sys.stderr" with objects that get input from and send output to the
Shell window. The original values stored in "sys.__stdin__",
"sys.__stdout__", and "sys.__stderr__" are not touched, but may be
"None".

When Shell has the focus, it controls the keyboard and screen.  This
is normally transparent, but functions that directly access the
keyboard and screen will not work.  These include system-specific
functions that determine whether a key has been pressed and if so,
which.

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.  The secondary subprocess
will then be attached to that window for input and output.

If "sys" is reset by user code, such as with "importlib.reload(sys)",
IDLE's changes are lost and input from the keyboard and output to the
screen will not work correctly.


25.5.3.4. User output in Shell
------------------------------

When a program outputs text, the result is determined by the
corresponding output device.  When IDLE executes user code,
"sys.stdout" and "sys.stderr" are connected to the display area of
IDLE's Shell.  Some of its features are inherited from the underlying
Tk Text widget.  Others are programmed additions.  Where it matters,
Shell is designed for development rather than production runs.

For instance, Shell never throws away output.  A program that sends
unlimited output to Shell will eventually fill memory, resulting in a
memory error. In contrast, some system text windows only keep the last
n lines of output. A Windows console, for instance, keeps a user-
settable 1 to 9999 lines, with 300 the default.

Text widgets display a subset of Unicode, the Basic Multilingual Plane
(BMP). Which characters get a proper glyph instead of a replacement
box depends on the operating system and installed fonts.  Newline
characters cause following text to appear on a new line, but other
control characters are either replaced with a box or deleted.
However, "repr()", which is used for interactive echo of expression
values, replaces control characters, some BMP codepoints, and all non-
BMP characters with escape codes before they are output.

Normal and error output are generally kept separate (on separate
lines) from code input and each other.  They each get different
highlight colors.

For SyntaxError tracebacks, the normal '^' marking where the error was
detected is replaced by coloring the text with an error highlight.
When code run from a file causes other exceptions, one may right click
on a traceback line to jump to the corresponding line in an IDLE
editor. The file will be opened if necessary.

Shell has a special facility for squeezing output lines down to a
'Squeezed text' label.  This is done automatically for output over N
lines (N = 50 by default). N can be changed in the PyShell section of
the General page of the Settings dialog.  Output with fewer lines can
be squeezed by right clicking on the output.  This can be useful lines
long enough to slow down scrolling.

Squeezed output is expanded in place by double-clicking the label. It
can also be sent to the clipboard or a separate view window by right-
clicking the label.


25.5.3.5. Développer des applications *tkinter*
-----------------------------------------------

IDLE is intentionally different from standard Python in order to
facilitate development of tkinter programs.  Enter "import tkinter as
tk; root = tk.Tk()" in standard Python and nothing appears.  Enter the
same in IDLE and a tk window appears.  In standard Python, one must
also enter "root.update()" to see the window.  IDLE does the
equivalent in the background, about 20 times a second, which is about
every 50 milleseconds. Next enter "b = tk.Button(root, text='button');
b.pack()".  Again, nothing visibly changes in standard Python until
one enters "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.


25.5.3.6. Exécution sans sous-processus
---------------------------------------

Par défaut *IDLE* exécute le code de l'utilisateur dans un sous-
processus séparé via un connecteur sur l'interface de la boucle
locale. Cette connexion n'est pas visible de l'extérieur et rien n'est
envoyé ou reçu d'Internet. Si un pare-feu s'en plaint quand même, vous
pouvez l'ignorer.

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.


25.5.4. Aide et préférences
===========================


25.5.4.1. Help sources
----------------------

Help menu entry "IDLE Help" displays a formatted html version of the
IDLE chapter of the Library Reference.  The result, in a read-only
tkinter text window, is close to what one sees in a web browser.
Navigate through the text with a mousewheel, the scrollbar, or up and
down arrow keys held down. Or click the TOC (Table of Contents) button
and select a section header in the opened box.

Help menu entry "Python Docs" opens the extensive sources of help,
including tutorials, available at docs.python.org/x.y, where 'x.y' is
the currently running Python version.  If your system has an off-line
copy of the docs (this may be an installation option), that will be
opened instead.

Selected URLs can be added or removed from the help menu at any time
using the General tab of the Configure IDLE dialog .


25.5.4.2. Modifier les préférences
----------------------------------

The font preferences, highlighting, keys, and general preferences can
be changed via Configure IDLE on the Option menu.  Keys can be user
defined; IDLE ships with four built-in key sets. In addition, a user
can create a custom key set in the Configure IDLE dialog under the
keys tab.


25.5.4.3. IDLE on macOS
-----------------------

Under System Preferences: Dock, one can set "Prefer tabs when opening
documents" to "Always".  This setting is not compatible with the
tk/tkinter GUI framework used by IDLE, and it breaks a few IDLE
features.


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