IDLE --- Python editor and shell
********************************

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

The IDLE application is implemented in the "idlelib" package.

This is an *optional module*. If it is missing from your copy of
CPython, look for documentation from your distributor (that is,
whoever provided Python to you). If you are the distributor, see
Requirements for optional modules.


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
   manager 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
   After an unclosed parenthesis for a function, open a small window
   with function parameter hints.  See Calltips in the Editing and
   Navigation section below.

Show Surrounding Parens
   Surligne les parenthèses encadrantes.


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

*Format Paragraph*
   Rewrap the text block containing the text insert cursor. Avoid code
   lines.  See Format block in the Editing and Navigation section
   below.

*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 Whitespace
   Remove trailing space and other whitespace characters after the
   last non-whitespace character of a line by applying "str.rstrip()"
   to each line, including lines within multiline strings.  Except for
   Shell windows, remove extra newlines at the end of the file.


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


Recherche et substitution
-------------------------

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.


Format block
------------

Reformat Paragraph rewraps a block ('paragraph') of contiguous equally
indented non-blank comments, a similar block of text within a
multiline string, or a selected subset of either. If needed, add a
blank line to separate string from code. Partial lines in a selection
expand to complete lines. The resulting lines have the same indent as
before but have maximum total length of N columns (characters). Change
the default N of 72 on the Window tab of IDLE Settings.


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


Command-line usage
------------------

IDLE can be invoked from the command line with various options. The
general syntax is:

   python -m idlelib [options] [file ...]

The following options are available:

-c <command>

   Run the specified Python command in the shell window. For example,
   pass "-c "print('Hello, World!')"". On Windows, the outer quotes
   must be double quotes as shown.

-d

   Enable the debugger and open the shell window.

-e

   Open an editor window.

-h

   Print a help message with legal combinations of options and exit.

-i

   Open a shell window.

-r <file>

   Run the specified file in the shell window.

-s

   Run the startup file (as defined by the environment variables
   "IDLESTARTUP" or "PYTHONSTARTUP") before opening the shell window.

-t <title>

   Set the title of the shell window.

-

   Read and execute standard input in the shell window. This option
   must be the last one before any arguments.

If arguments are provided:

* If "-", "-c", or "-r" is used, all arguments are placed in
  "sys.argv[1:]", and "sys.argv[0]" is set to "''", "'-c'", or "'-r'"
  respectively. No editor window is opened, even if that is the
  default set in the *Options* dialog.

* Otherwise, arguments are treated as files to be opened for editing,
  and "sys.argv" reflects the arguments passed to IDLE itself.


É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 --- implementation of IDLE application
==============================================

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