"sys" --- System-specific parameters and functions
**************************************************

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

Ce module fournit un accès à certaines variables utilisées et
maintenues par l'interpréteur, et à des fonctions interagissant
fortement avec ce dernier. Ce module est toujours disponible.

sys.abiflags

   Contient, sur les systèmes POSIX où Python a été compilé avec le
   script "configure", les *ABI flags* tels que définis par la **PEP
   3149**.

   Added in version 3.2.

   Modifié dans la version 3.8: Les options par défaut sont devenues
   des chaines de caractères vides (l'option "m" pour *pymalloc* a été
   enlevée).

   Disponibilité : Unix.

sys.addaudithook(hook)

   Append the callable *hook* to the list of active auditing hooks for
   the current (sub)interpreter.

   Quand un événement d'audit est déclenché par la fonction
   "sys.audit()", chaque point d'entrée est appelé dans l'ordre dans
   lequel il a été ajouté avec le nom de l'événement et le *n*-uplet
   des arguments. Les points d'entrées qui sont ajoutés par
   "PySys_AddAuditHook()" sont appelés les premiers, suivi par les
   fonctions de rappel ajoutées dans l'interpréteur en cours
   d'exécution. Les points d'entrées peuvent *logger* l'événement,
   lever une exception pour stopper l'opération ou terminer le
   processus entièrement.

   Note that audit hooks are primarily for collecting information
   about internal or otherwise unobservable actions, whether by Python
   or libraries written in Python. They are not suitable for
   implementing a "sandbox". In particular, malicious code can
   trivially disable or bypass hooks added using this function. At a
   minimum, any security-sensitive hooks must be added using the C API
   "PySys_AddAuditHook()" before initialising the runtime, and any
   modules allowing arbitrary memory modification (such as "ctypes")
   should be completely removed or closely monitored.

   L'appel de "sys.addaudithook()" lèvera d'elle même un événement
   d'audit appelé "sys.addaudithook" sans arguments. Si n'importe quel
   *hook* lève une exception dérivée de "RuntimeError", le nouveau
   point d'entrée ne sera pas ajouté et l'exception supprimée. Par
   conséquent, les appels ne peuvent pas supposer que leurs points
   d'entrées ont été ajoutés à moins de contrôler tous les points
   d'entrées existants.

   Voir la table d'évenements d'audit pour tous les événements levés
   par CPython et **PEP 578** pour la discussion originale de ce
   design.

   Added in version 3.8.

   Modifié dans la version 3.8.1: Les exceptions dérivées de
   "Exception" mais pas "RuntimeError" ne sont plus supprimées.

   **Particularité de l'implémentation CPython :** Quand le traçage
   est activé (voir "settrace()"), les *hooks* Python ne sont tracés
   que si la fonction a un membre "__cantrace__" dont la valeur est
   vraie. Autrement, les fonctions de traçage ignorent le *hook*.

sys.argv

   La liste des arguments de la ligne de commande passés à un script
   Python. "argv[0]" est le nom du script (chemin complet, ou non, en
   fonction du système d'exploitation). Si la commande a été exécutée
   avec l'option "-c" de l'interpréteur, "argv[0]" vaut la chaîne
   "'-c'". Si aucun nom de script n'a été donné à l'interpréteur
   Python, "argv[0]" sera une chaîne vide.

   Pour boucler sur l'entrée standard, ou la liste des fichiers donnés
   sur la ligne de commande, utilisez le module "fileinput".

   See also "sys.orig_argv".

   Note:

     Sous Unix, les arguments de ligne de commande sont passés par des
     octets depuis le système d'exploitation. Python les décode en
     utilisant l’encodage du système de fichiers et le gestionnaire
     d’erreur *surrogateescape*. Quand vous avez besoin des octets
     originaux, vous pouvez les récupérer avec "[os.fsencode(arg) for
     arg in sys.argv]".

sys.audit(event, *args)

   Déclenche un événement d'audit pour tous les points d'entrées
   d'audit actifs. *event* est une chaîne de caractères identifiant
   l'événement, et *args* peut contenir des arguments optionnels avec
   plus d'informations sur l'événement en question. Le nombre et types
   d'arguments pour un événement donné sont considérés comme une API
   publique et stable, et ne devraient pas être modifiés entre les
   versions.

   Par exemple, un événement d'audit est nommé "os.chdir". Cet
   événement à un argument appelé *path* qui contiendras le nouveau
   répertoire de travail.

   "sys.audit()" appellera les point d'entrées (*hooks* en anglais)
   d'audits existants, en passant le nom de l'événement et ses
   arguments, et lèvera à nouveau la première exception de n'importe
   quel point d'entrée. En général, si une exception est levée, elle
   ne devrais pas être gérée et le processus devrait être terminé
   aussi rapidement que possible. Cela permet que les implémentations
   des points d'entrées décident comment répondre à des événements
   particuliers : Ils peuvent simplement *logger* l'événement ou
   arrêter l'opération en levant une exception.

   Les points d'entrées sont ajoutés en utilisant les fonctions
   "sys.addaudithook()" ou "PySys_AddAuditHook()".

   L'équivalent natif de cette fonction est "PySys_Audit()".
   L'utilisation de la fonction native est encouragée lorsque c'est
   possible.

   Voir le tableau d'événements d'audit pour tous les événements levés
   par CPython.

   Added in version 3.8.

sys.base_exec_prefix

   Défini au démarrage de Python, avant que "site.py" ne soit évalué,
   à la même valeur que "exec_prefix". Hors d'un environnement
   virtuel, les valeurs restent les mêmes ; si "site.py" détecte qu'un
   environnement virtuel est utilisé, les valeurs de "prefix" et
   "exec_prefix" sont modifiées pour pointer vers l'environnement
   virtuel, alors que "base_prefix" et "base_exec_prefix" pointent
   toujours à la racine de l'installation de Python (celui utilisé
   pour créer l'environnement virtuel).

   Added in version 3.3.

sys.base_prefix

   Défini au démarrage de Python, avant que "site.py" ne soit évalué,
   à la même valeur que "prefix". Hors d'un environnement virtuel, les
   valeurs restent les mêmes ; si "site.py" détecte qu'un
   environnement virtuel est utilisé, les valeurs de "prefix" et
   "exec_prefix" sont modifiées pour pointer vers l'environnement
   virtuel, alors que "base_prefix" et "base_exec_prefix" pointent
   toujours à la racine de l'installation de Python (celui utilisé
   pour créer l'environnement virtuel).

   Added in version 3.3.

sys.byteorder

   Un indicateur de l'ordre natif des octets.  Vaudra "'big'" sur les
   plateformes gros-boutistes (octet le plus significatif en premier),
   et "'little'" sur les plateformes petit-boutiste (octet le moins
   significatif en premier).

sys.builtin_module_names

   A tuple of strings containing the names of all modules that are
   compiled into this Python interpreter.  (This information is not
   available in any other way --- "modules.keys()" only lists the
   imported modules.)

   See also the "sys.stdlib_module_names" list.

sys.call_tracing(func, args)

   Call "func(*args)", while tracing is enabled.  The tracing state is
   saved, and restored afterwards.  This is intended to be called from
   a debugger from a checkpoint, to recursively debug or profile some
   other code.

   Tracing is suspended while calling a tracing function set by
   "settrace()" or "setprofile()" to avoid infinite recursion.
   "call_tracing()" enables explicit recursion of the tracing
   function.

sys.copyright

   Une chaîne contenant le copyright relatif à l'interpréteur Python.

sys._clear_type_cache()

   Vide le cache interne de types. Le cache de types est utilisé pour
   accélérer les recherches d'attributs et de méthodes. N'utilisez
   cette fonction *que* pour libérer des références inutiles durant le
   débogage de fuite de référence.

   Cette fonction ne devrait être utilisée que pour un usage interne
   et spécialisé.

sys._current_frames()

   Renvoie un dictionnaire faisant correspondre chaque identifiant de
   fil d'exécution à la *stack frame* actuellement active pour ces
   fils d'exécution au moment où la fonction est appelée. Notez que
   les fonctions du module "traceback" peuvent construire une *call
   stack* à partir d'une telle *frame*.

   N'ayant pas besoin de la coopération des fils d'exécution bloqués,
   cette fonction est très utile pour déboguer un *deadlock*. Aussi,
   les *call stack* de ces fils d'exécution ne changeront pas tant
   qu'ils seront bloqués. La *frame* renvoyée pour un fil d'exécution
   non bloqué peut ne plus être liée à l'activité courante du fil
   d'exécution au moment où le code appelant examine la *frame*.

   Cette fonction ne devrait être utilisée que pour un usage interne
   et spécialisé.

   Lève un événement d'audit "sys._current_frames" sans arguments.

sys._current_exceptions()

   Return a dictionary mapping each thread's identifier to the topmost
   exception currently active in that thread at the time the function
   is called. If a thread is not currently handling an exception, it
   is not included in the result dictionary.

   This is most useful for statistical profiling.

   Cette fonction ne devrait être utilisée que pour un usage interne
   et spécialisé.

   Raises an auditing event "sys._current_exceptions" with no
   arguments.

   Modifié dans la version 3.12: Each value in the dictionary is now a
   single exception instance, rather than a 3-tuple as returned from
   "sys.exc_info()".

sys.breakpointhook()

   Cette fonction auto-déclenchée (*hook function* en anglais) est
   appelée par la fonction native "breakpoint()". Par défaut, elle
   vous place dans le débogueur "pdb", mais elle peut être dirigée
   vers n'importe quelle autre fonction pour que vous puissiez choisir
   le débogueur utilisé.

   La signature de cette fonction dépend de ce qu'elle appelle. Par
   exemple, l'appel par défaut (e.g. "pdb.set_trace()") n'attend pas
   d'argument, mais vous pourriez la lier à une fonction qui attend
   des arguments supplémentaires (positionnels et/ou mots-clés). La
   fonction native "breakpoint()" passe ses "*args" et "**kws"
   directement au travers. Tout ce que renvoie "breakpointhooks()" est
   renvoyé par "breakpoint()".

   L'implémentation par défaut consulte d'abord la variable
   d'environnement "PYTHONBREAKPOINT". Si elle vaut ""0"" alors cette
   fonction s'achève immédiatement (elle ne fait donc rien). Si la
   variable d'environnement n'est pas définie, ou s'il s'agit d'une
   chaîne vide, "pdb.set_trace()" est appelée. Sinon cette variable
   doit nommer une fonction à appeler, en utilisant la syntaxe
   d'importation de Python, par exemple
   "package.subpackage.module.function". Dans ce cas,
   "package.subpackage.module" sera importé et le module devra
   contenir une fonction appelable "function()". Celle-ci est lancée
   en lui passant "*args" et "*kws" et, quoique renvoie "function()",
   "sys.breakpointhook()" retourne à la fonction native
   "breakpoint()".

   Notez que si un problème apparaît au moment de l'importation de la
   fonction nommée dans "PYTHONBREAKPOINT", une alerte
   "RuntimeWarning" est indiquée et le point d'arrêt est ignoré.

   Notez également que si "sys.breakpointhook()" est surchargé de
   manière programmatique, "PYTHONBREAKPOINT" *n'est pas* consulté.

   Added in version 3.7.

sys._debugmallocstats()

   Affiche des informations bas-niveau sur la sortie d'erreur à propos
   de l'état de l'allocateur de mémoire de CPython.

   If Python is built in debug mode ("configure --with-pydebug
   option"), it also performs some expensive internal consistency
   checks.

   Added in version 3.3.

   **Particularité de l'implémentation CPython :** Cette fonction est
   spécifique à CPython.  Le format de sa sortie n'est pas définit ici
   et pourrait changer.

sys.dllhandle

   Nombre entier spécifiant le descripteur de la DLL Python.

   Disponibilité : Windows.

sys.displayhook(value)

   Si *value* n'est pas "None", cette fonction écrit "repr(value)" sur
   "sys.stdout", et sauvegarde *value* dans "builtins._". Si
   "repr(value)" ne peut pas être encodé avec "sys.stdout.encoding" en
   utilisant le gestionnaire d'erreur "sys.stdout.errors" (qui est
   probablement "'strict'"), elle sera encodée avec
   "sys.stdout.encoding" en utilisant le gestionnaire d'erreur
   "'backslashreplace'".

   "sys.displayhook" est appelé avec le résultat de l'évaluation d'une
   *expression* entrée dans une session Python interactive.
   L'affichage de ces valeurs peut être personnalisé en assignant une
   autre fonction d'un argument à "sys.displayhook".

   Pseudo-code :

      def displayhook(value):
          if value is None:
              return
          # Set '_' to None to avoid recursion
          builtins._ = None
          text = repr(value)
          try:
              sys.stdout.write(text)
          except UnicodeEncodeError:
              bytes = text.encode(sys.stdout.encoding, 'backslashreplace')
              if hasattr(sys.stdout, 'buffer'):
                  sys.stdout.buffer.write(bytes)
              else:
                  text = bytes.decode(sys.stdout.encoding, 'strict')
                  sys.stdout.write(text)
          sys.stdout.write("\n")
          builtins._ = value

   Modifié dans la version 3.2: Utiliser le gestionnaire d'erreur
   "'backslashreplace'" en cas d'"UnicodeEncodeError".

sys.dont_write_bytecode

   Si vrai, Python n'essaiera pas d'écrire de fichiers ".pyc" à
   l'importation de modules source. Cette valeur est initialement
   définie à "True" ou "False" en fonction de l'option de la ligne de
   commande "-B" et de la variable d'environnement
   "PYTHONDONDONTWRITEBYTECODE", mais vous pouvez aussi la modifier
   vous-même pour contrôler la génération des fichiers de *bytecode*.

sys._emscripten_info

   A *named tuple* holding information about the environment on the
   *wasm32-emscripten* platform. The named tuple is provisional and
   may change in the future.

   _emscripten_info.emscripten_version

      Emscripten version as tuple of ints (major, minor, micro), e.g.
      "(3, 1, 8)".

   _emscripten_info.runtime

      Runtime string, e.g. browser user agent, "'Node.js v14.18.2'",
      or "'UNKNOWN'".

   _emscripten_info.pthreads

      "True" if Python is compiled with Emscripten pthreads support.

   _emscripten_info.shared_memory

      "True" if Python is compiled with shared memory support.

   Availability: Emscripten.

   Added in version 3.11.

sys.pycache_prefix

   If this is set (not "None"), Python will write bytecode-cache
   ".pyc" files to (and read them from) a parallel directory tree
   rooted at this directory, rather than from "__pycache__"
   directories in the source code tree. Any "__pycache__" directories
   in the source code tree will be ignored and new ".pyc" files
   written within the pycache prefix. Thus if you use "compileall" as
   a pre-build step, you must ensure you run it with the same pycache
   prefix (if any) that you will use at runtime.

   Un chemin relatif est interprété relativement au répertoire
   courant.

   Cette valeur est initialement définie basée sur la valeur de
   l'option de ligne de commande "-X" "pycache_prefix=PATH" ou la
   variable d'environnement "PYTHONPYCACHEPREFIX" (La ligne de
   commande est prioritaire). Si aucune des deux options n'est
   définie, alors la valeur est "None".

   Added in version 3.8.

sys.excepthook(type, value, traceback)

   Cette fonction affiche la *traceback* et l'exception donnée sur
   "sys.stderr".

   When an exception other than "SystemExit" is raised and uncaught,
   the interpreter calls "sys.excepthook" with three arguments, the
   exception class, exception instance, and a traceback object.  In an
   interactive session this happens just before control is returned to
   the prompt; in a Python program this happens just before the
   program exits.  The handling of such top-level exceptions can be
   customized by assigning another three-argument function to
   "sys.excepthook".

   Lève un événement d'audit "sys.excepthook" avec les arguments
   "hook", "type", "value", "traceback".

   Voir aussi:

     La fonction "sys.unraisablehook()" gère les exceptions *non-
     levables* et la fonction "threading.excepthook()" gère les
     exceptions levées par "threading.Thread.run()".

sys.__breakpointhook__
sys.__displayhook__
sys.__excepthook__
sys.__unraisablehook__

   Ces objets contiennent les valeurs originales de "breakpointhook",
   "displayhook", "excepthook" et "unraisablehook" au début du
   programme.Ils sont sauvegardés de façon à ce que "breakpointhook",
   "displayhook", "excepthook" et "unraisablehook" puissent être
   restaurés au cas où ils seraient remplacés par des objets cassés ou
   alternatifs.

   Added in version 3.7: "__breakpointhook__"

   Added in version 3.8: "__unraisablehook__"

sys.exception()

   This function, when called while an exception handler is executing
   (such as an "except" or "except*" clause), returns the exception
   instance that was caught by this handler. When exception handlers
   are nested within one another, only the exception handled by the
   innermost handler is accessible.

   If no exception handler is executing, this function returns "None".

   Added in version 3.11.

sys.exc_info()

   This function returns the old-style representation of the handled
   exception. If an exception "e" is currently handled (so
   "exception()" would return "e"), "exc_info()" returns the tuple
   "(type(e), e, e.__traceback__)". That is, a tuple containing the
   type of the exception (a subclass of "BaseException"), the
   exception itself, and a traceback object which typically
   encapsulates the call stack at the point where the exception last
   occurred.

   If no exception is being handled anywhere on the stack, this
   function return a tuple containing three "None" values.

   Modifié dans la version 3.11: The "type" and "traceback" fields are
   now derived from the "value" (the exception instance), so when an
   exception is modified while it is being handled, the changes are
   reflected in the results of subsequent calls to "exc_info()".

sys.exec_prefix

   Une chaîne donnant le préfixe de dossier spécifique au site où les
   fichiers dépendant de la plateforme sont installés. Par défaut,
   c'est "'/usr/local'". C'est configurable à la compilation avec
   l'option "--exec-prefix" du script **configure**. Tous les fichiers
   de configurations (tel que "pyconfig,h") sont installés dans le
   dossier "*exec_prefix*/lib/python*X.Y*/config", et les modules sous
   forme de bibliothèques partagées sont installés dans
   "*exec_prefix*/lib/python*X.Y*/lib-dynload", où *X.Y* est le numéro
   de version de  Python, par exemple "3.2".

   Note:

     Si un environment virtuel est actif, cette valeur sera modifiée
     par "site.py" pour pointer vers l'environnement virtuel. La
     valeur d'origine sera toujours disponible via "base_exec_prefix".

sys.executable

   Une chaîne donnant le chemin absolu vers l'interpréteur Python, un
   fichier binaire exécutable, sur les système sur lesquels ça à du
   sens. Si Python n'est pas capable de récupérer le chemin réel de
   son exécutable, "sys.executable" sera une chaîne vide ou "None".

sys.exit([arg])

   Raise a "SystemExit" exception, signaling an intention to exit the
   interpreter.

   L'argument optionnel *arg* peut être un nombre entier donnant
   l'état de sortie (zéro par défaut), ou un autre type d'objet.  Pour
   les *shells* (et autres), si c'est un entier, zéro signifie
   "terminé avec succès", et toutes les autres valeurs signifient
   "terminé anormalement". La plupart des systèmes imposent qu'il se
   situe dans la plage 0--127, et leur comportement n'est pas défini
   pour les autres cas. Certains systèmes peu communs ont pour
   convention d'assigner un sens particulier à des valeur spécifiques.
   Les programmes Unix utilisent généralement 2 pour les erreurs de
   syntaxe dans les arguments de la ligne de commande, et 1 pour
   toutes les autres erreurs. Si un autre type est passé, "None" est
   équivalent à zéro, et tout autre objet est écrit sur "stderr" et
   donne un code de sortie 1. Typiquement, "sys.exit("some error
   message")" est un moyen rapide de quitter un programme en cas
   d'erreur.

   Since "exit()" ultimately "only" raises an exception, it will only
   exit the process when called from the main thread, and the
   exception is not intercepted. Cleanup actions specified by finally
   clauses of "try" statements are honored, and it is possible to
   intercept the exit attempt at an outer level.

   Modifié dans la version 3.6: Si une erreur survient lors du
   nettoyage après que l'interpréteur Python ait intercepté un
   "SystemExit" (typiquement une erreur en vidant les tampons des
   sorties standard), le code de sortie est changé à 120.

sys.flags

   La *named tuple* *flags* expose l'état des options de ligne de
   commande. Ces attributs sont en lecture seule.

   +----------------------------------------------------+----------------------------------------------------+
   | flags.debug                                        | "-d"                                               |
   +----------------------------------------------------+----------------------------------------------------+
   | flags.inspect                                      | "-i"                                               |
   +----------------------------------------------------+----------------------------------------------------+
   | flags.interactive                                  | "-i"                                               |
   +----------------------------------------------------+----------------------------------------------------+
   | flags.isolated                                     | "-I"                                               |
   +----------------------------------------------------+----------------------------------------------------+
   | flags.optimize                                     | "-O" or "-OO"                                      |
   +----------------------------------------------------+----------------------------------------------------+
   | flags.dont_write_bytecode                          | "-B"                                               |
   +----------------------------------------------------+----------------------------------------------------+
   | flags.no_user_site                                 | "-s"                                               |
   +----------------------------------------------------+----------------------------------------------------+
   | flags.no_site                                      | "-S"                                               |
   +----------------------------------------------------+----------------------------------------------------+
   | flags.ignore_environment                           | "-E"                                               |
   +----------------------------------------------------+----------------------------------------------------+
   | flags.verbose                                      | "-v"                                               |
   +----------------------------------------------------+----------------------------------------------------+
   | flags.bytes_warning                                | "-b"                                               |
   +----------------------------------------------------+----------------------------------------------------+
   | flags.quiet                                        | "-q"                                               |
   +----------------------------------------------------+----------------------------------------------------+
   | flags.hash_randomization                           | "-R"                                               |
   +----------------------------------------------------+----------------------------------------------------+
   | flags.dev_mode                                     | "-X dev" (Python en mode développement)            |
   +----------------------------------------------------+----------------------------------------------------+
   | flags.utf8_mode                                    | "-X utf8"                                          |
   +----------------------------------------------------+----------------------------------------------------+
   | flags.safe_path                                    | "-P"                                               |
   +----------------------------------------------------+----------------------------------------------------+
   | flags.int_max_str_digits                           | "-X int_max_str_digits" (integer string conversion |
   |                                                    | length limitation)                                 |
   +----------------------------------------------------+----------------------------------------------------+
   | flags.warn_default_encoding                        | "-X warn_default_encoding"                         |
   +----------------------------------------------------+----------------------------------------------------+

   Modifié dans la version 3.2: Ajout de l'attribut "quiet" pour la
   nouvelle option "-q".

   Added in version 3.2.3: L'attribut "hash_randomization".

   Modifié dans la version 3.3: Suppression de l'attribut obsolète
   "division_warning".

   Modifié dans la version 3.4: Ajout de l'attribut "isolated" pour
   l'option "-I" "isolated".

   Modifié dans la version 3.7: Ajout de l'attribut "dev_mode" pour le
   nouveau Mode Développeur Python et l'attribut "utf8_mode" pour la
   nouvelle option "-X" "utf8".

   Modifié dans la version 3.10: Added "warn_default_encoding"
   attribute for "-X" "warn_default_encoding" flag.

   Modifié dans la version 3.11: Added the "safe_path" attribute for
   "-P" option.

   Modifié dans la version 3.11: Added the "int_max_str_digits"
   attribute.

sys.float_info

   Un *named tuple* contenant des informations à propos du type
   *float*. Il contient des informations de bas niveau à propos de la
   précision et de la représentation interne.  Les valeurs
   correspondent aux différentes constantes à propos des nombres à
   virgule flottantes définies dans le fichier d'entête "float.h" pour
   le langage de programmation C. Voir la section  5.2.4.2.2 de *1999
   ISO/IEC C standard* [C99], *Characteristics of floating types*,
   pour plus de détails.


   Attributes of the "float_info" *named tuple*
   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

   +-----------------------------------+-----------------------------------+-----------------------------------+
   | attribut                          | macro *float.h*                   | explication                       |
   |===================================|===================================|===================================|
   | float_info.epsilon                | "DBL_EPSILON"                     | difference between 1.0 and the    |
   |                                   |                                   | least value greater than 1.0 that |
   |                                   |                                   | is representable as a float.      |
   |                                   |                                   | Voir aussi : "math.ulp()".        |
   +-----------------------------------+-----------------------------------+-----------------------------------+
   | float_info.dig                    | "DBL_DIG"                         | The maximum number of decimal     |
   |                                   |                                   | digits that can be faithfully     |
   |                                   |                                   | represented in a float; see       |
   |                                   |                                   | below.                            |
   +-----------------------------------+-----------------------------------+-----------------------------------+
   | float_info.mant_dig               | "DBL_MANT_DIG"                    | Float precision: the number of    |
   |                                   |                                   | base-"radix" digits in the        |
   |                                   |                                   | significand of a float.           |
   +-----------------------------------+-----------------------------------+-----------------------------------+
   | float_info.max                    | "DBL_MAX"                         | The maximum representable         |
   |                                   |                                   | positive finite float.            |
   +-----------------------------------+-----------------------------------+-----------------------------------+
   | float_info.max_exp                | "DBL_MAX_EXP"                     | The maximum integer *e* such that |
   |                                   |                                   | "radix**(e-1)" is a representable |
   |                                   |                                   | finite float.                     |
   +-----------------------------------+-----------------------------------+-----------------------------------+
   | float_info.max_10_exp             | "DBL_MAX_10_EXP"                  | The maximum integer *e* such that |
   |                                   |                                   | "10**e" is in the range of        |
   |                                   |                                   | representable finite floats.      |
   +-----------------------------------+-----------------------------------+-----------------------------------+
   | float_info.min                    | "DBL_MIN"                         | The minimum representable         |
   |                                   |                                   | positive *normalized* float.      |
   |                                   |                                   | Utilisez "math.ulp(0.0)" pour     |
   |                                   |                                   | obtenir le plus petit nombre a    |
   |                                   |                                   | virgule positif *dénormalisé*     |
   |                                   |                                   | représentable.                    |
   +-----------------------------------+-----------------------------------+-----------------------------------+
   | float_info.min_exp                | "DBL_MIN_EXP"                     | The minimum integer *e* such that |
   |                                   |                                   | "radix**(e-1)" is a normalized    |
   |                                   |                                   | float.                            |
   +-----------------------------------+-----------------------------------+-----------------------------------+
   | float_info.min_10_exp             | "DBL_MIN_10_EXP"                  | The minimum integer *e* such that |
   |                                   |                                   | "10**e" is a normalized float.    |
   +-----------------------------------+-----------------------------------+-----------------------------------+
   | float_info.radix                  | "FLT_RADIX"                       | The radix of exponent             |
   |                                   |                                   | representation.                   |
   +-----------------------------------+-----------------------------------+-----------------------------------+
   | float_info.rounds                 | "FLT_ROUNDS"                      | An integer representing the       |
   |                                   |                                   | rounding mode for floating-point  |
   |                                   |                                   | arithmetic. This reflects the     |
   |                                   |                                   | value of the system "FLT_ROUNDS"  |
   |                                   |                                   | macro at interpreter startup      |
   |                                   |                                   | time:  * "-1": indeterminable  *  |
   |                                   |                                   | "0": toward zero  * "1": to       |
   |                                   |                                   | nearest  * "2": toward positive   |
   |                                   |                                   | infinity  * "3": toward negative  |
   |                                   |                                   | infinity  All other values for    |
   |                                   |                                   | "FLT_ROUNDS" characterize         |
   |                                   |                                   | implementation- defined rounding  |
   |                                   |                                   | behavior.                         |
   +-----------------------------------+-----------------------------------+-----------------------------------+

   The attribute "sys.float_info.dig" needs further explanation.  If
   "s" is any string representing a decimal number with at most
   "sys.float_info.dig" significant digits, then converting "s" to a
   float and back again will recover a string representing the same
   decimal value:

      >>> import sys
      >>> sys.float_info.dig
      15
      >>> s = '3.14159265358979'    # decimal string with 15 significant digits
      >>> format(float(s), '.15g')  # convert to float and back -> same value
      '3.14159265358979'

   Cependant, pour les chaînes avec plus de "sys.float_info.dig"
   chiffres significatifs, ce n'est pas toujours vrai :

      >>> s = '9876543211234567'    # 16 significant digits is too many!
      >>> format(float(s), '.16g')  # conversion changes value
      '9876543211234568'

sys.float_repr_style

   Une chaîne indiquant comment la fonction "repr()" se comporte avec
   les nombres à virgule flottante. Si la chaîne a la valeur
   "'short'", alors pour un *float* finit "x", "repr(x)" essaye de
   donner une courte chaîne tel que "float(repr(x)) == x".  C'est le
   comportement typique à partir de Python 3.1.  Autrement,
   "float_repr_style" a la valeur "'legacy'" et "repr(x)" se comporte
   comme les versions antérieures à 3.1.

   Added in version 3.1.

sys.getallocatedblocks()

   Renvoie le nombre de blocs mémoire actuellement alloués par
   l'interpréteur, peu importe leur taille.  Cette fonction est
   principalement utile pour pister les fuites de mémoire. À cause des
   caches internes de l'interpréteur, le résultat peut varier d'un
   appel à l'autre. Appeler "_clear_type_cache()" et "gc.collect()"
   peut permettre d'obtenir des résultats plus prévisibles.

   Si Python n'arrive pas a calculer raisonnablement cette
   information, "getallocatedblocks()" est autorisé à renvoyer 0 à la
   place.

   Added in version 3.4.

sys.getunicodeinternedsize()

   Return the number of unicode objects that have been interned.

   Added in version 3.12.

sys.getandroidapilevel()

   Renvoie la version de l'API Android utilisée pour compiler sous
   forme d'un entier.

   Disponibilité : Android.

   Added in version 3.7.

sys.getdefaultencoding()

   Renvoie le nom du codage par défaut actuellement utilisé par
   l'implémentation *Unicode* pour coder les chaînes.

sys.getdlopenflags()

   Return the current value of the flags that are used for "dlopen()"
   calls.  Symbolic names for the flag values can be found in the "os"
   module ("RTLD_*xxx*" constants, e.g. "os.RTLD_LAZY").

   Disponibilité : Unix.

sys.getfilesystemencoding()

   Get the *filesystem encoding*: the encoding used with the
   *filesystem error handler* to convert between Unicode filenames and
   bytes filenames. The filesystem error handler is returned from
   "getfilesystemencodeerrors()".

   For best compatibility, str should be used for filenames in all
   cases, although representing filenames as bytes is also supported.
   Functions accepting or returning filenames should support either
   str or bytes and internally convert to the system's preferred
   representation.

   Les fonctions "os.fsencode()" et "os.fsdecode()" devraient être
   utilisées pour s'assurer qu'un encodage et un gestionnaire
   d'erreurs correct sont utilisés.

   The *filesystem encoding and error handler* are configured at
   Python startup by the "PyConfig_Read()" function: see
   "filesystem_encoding" and "filesystem_errors" members of
   "PyConfig".

   Modifié dans la version 3.2: "getfilesystemencoding()" ne peut plus
   renvoyer "None".

   Modifié dans la version 3.6: Sur Windows, on est plus assurés
   d'obtenir "'mbcs'". Voir la **PEP 529** et
   "_enablelegacywindowsfsencoding()" pour plus d'informations.

   Modifié dans la version 3.7: Return "'utf-8'" if the Python UTF-8
   Mode is enabled.

sys.getfilesystemencodeerrors()

   Get the *filesystem error handler*: the error handler used with the
   *filesystem encoding* to convert between Unicode filenames and
   bytes filenames. The filesystem encoding is returned from
   "getfilesystemencoding()".

   Les fonctions "os.fsencode()" et "os.fsdecode()" devraient être
   utilisées pour s'assurer qu'un encodage et un gestionnaire
   d'erreurs correct sont utilisés.

   The *filesystem encoding and error handler* are configured at
   Python startup by the "PyConfig_Read()" function: see
   "filesystem_encoding" and "filesystem_errors" members of
   "PyConfig".

   Added in version 3.6.

sys.get_int_max_str_digits()

   Returns the current value for the integer string conversion length
   limitation. See also "set_int_max_str_digits()".

   Added in version 3.11.

sys.getrefcount(object)

   Donne le nombre de référence de l'objet *object*. Le nombre renvoyé
   est généralement d'une référence de plus qu'attendu, puisqu'il
   compte la référence (temporaire) de l'argument à "getrefcount()".

   Note that the returned value may not actually reflect how many
   references to the object are actually held.  For example, some
   objects are "immortal" and have a very high refcount that does not
   reflect the actual number of references.  Consequently, do not rely
   on the returned value to be accurate, other than a value of 0 or 1.

   Modifié dans la version 3.12: Immortal objects have very large
   refcounts that do not match the actual number of references to the
   object.

sys.getrecursionlimit()

   Donne la limite actuelle de la limite de récursion, la profondeur
   maximum de la pile de l'interpréteur.  Cette limite empêche Python
   de planter lors d'une récursion infinie à cause d'un débordement de
   la pile. Elle peut être modifiée par "setrecursionlimit()".

sys.getsizeof(object[, default])

   Donne la taille d'un objet en octets. L'objet peut être de
   n'importe quel type. Le résultat sera correct pour tous les objets
   natifs, mais le résultat peut ne pas être toujours vrai pour les
   extensions, la valeur étant dépendante de l'implémentation.

   Seule la mémoire directement attribuée à l'objet est prise en
   compte, pas la mémoire consommée par les objets vers lesquels il a
   des références.

   S'il est fourni, *default* sera renvoyé si l'objet ne fournit aucun
   moyen de récupérer sa taille.  Sinon, une exception "TypeError"
   sera levée.

   "getsizeof()" appelle la méthode "__sizeof__" de l'objet, et s'il
   est géré par lui, ajoute le surcoût du ramasse-miettes.

   See recursive sizeof recipe for an example of using "getsizeof()"
   recursively to find the size of containers and all their contents.

sys.getswitchinterval()

   Renvoie la valeur du *thread switch interval* de l'interpréteur,
   voir "setswitchinterval()".

   Added in version 3.2.

sys._getframe([depth])

   Renvoie une *frame* de la pile d'appels. Si le nombre entier
   optionnel *depth* est donné, la *frame* donnée sera de *depth*
   appels depuis le haut de la pile. Si c'est plus profond que la
   hauteur de la pile, une exception "ValueError" est levée. La
   profondeur par défaut est zéro, donnant ainsi la *frame* du dessus
   de la pile.

   Raises an auditing event "sys._getframe" with argument "frame".

   **Particularité de l'implémentation CPython :** Cette fonction ne
   devrait être utilisée que pour une utilisation interne et
   spécifique. Il n'est pas garanti qu'elle existe dans toutes les
   implémentations de Python.

sys._getframemodulename([depth])

   Return the name of a module from the call stack.  If optional
   integer *depth* is given, return the module that many calls below
   the top of the stack.  If that is deeper than the call stack, or if
   the module is unidentifiable, "None" is returned.  The default for
   *depth* is zero, returning the module at the top of the call stack.

   Raises an auditing event "sys._getframemodulename" with argument
   "depth".

   **Particularité de l'implémentation CPython :** Cette fonction ne
   devrait être utilisée que pour une utilisation interne et
   spécifique. Il n'est pas garanti qu'elle existe dans toutes les
   implémentations de Python.

sys.getprofile()

   Renvoie la fonction de profilage tel que défini par "setprofile()".

sys.gettrace()

   Renvoie la fonction de traçage tel que définie par "settrace()".

   **Particularité de l'implémentation CPython :** La fonction
   "gettrace()" ne sert que pour implémenter des débogueurs, des
   *profilers*, outils d'analyse de couverture, etc…. Son comportement
   dépend de l'implémentation et non du langage, elle n'est donc pas
   forcément disponible dans toutes les implémentations de Python.

sys.getwindowsversion()

   Renvoie un *n*-uplet nommé décrivant la version de Windows en cours
   d'exécution. Les attributs nommés sont *major*, *minor*, *build*,
   *platform*, *service_pack*, *service_pack_minor*,
   *service_pack_major*, *suite_mask*, *product_type* et
   *platform_version*. *service_pack* contient une string,
   *platform_version* un triplet, et tous les autres sont des nombres
   entiers. Ces attributs sont également accessibles par leur nom,
   donc "sys.getwindowsversion()[0]" est équivalent à
   "sys.getwindowsversion().major". Pour des raisons de compatibilité
   avec les versions antérieures, seuls les 5 premiers éléments sont
   accessibles par leur indice.

   *platform* will be "2" (VER_PLATFORM_WIN32_NT).

   *product_type* peut être une des valeurs suivantes :

   +-----------------------------------------+-----------------------------------+
   | Constante                               | Signification                     |
   |=========================================|===================================|
   | "1" (VER_NT_WORKSTATION)                | Le système une station de         |
   |                                         | travail.                          |
   +-----------------------------------------+-----------------------------------+
   | "2" (VER_NT_DOMAIN_CONTROLLER)          | Le système est un contrôleur de   |
   |                                         | domaine.                          |
   +-----------------------------------------+-----------------------------------+
   | "3" (VER_NT_SERVER)                     | Le système est un serveur, mais   |
   |                                         | pas un contrôleur de domaine.     |
   +-----------------------------------------+-----------------------------------+

   This function wraps the Win32 "GetVersionEx()" function; see the
   Microsoft documentation on "OSVERSIONINFOEX()" for more information
   about these fields.

   *platform_version* returns the major version, minor version and
   build number of the current operating system, rather than the
   version that is being emulated for the process. It is intended for
   use in logging rather than for feature detection.

   Note:

     *platform_version* derives the version from kernel32.dll which
     can be of a different version than the OS version. Please use
     "platform" module for achieving accurate OS version.

   Disponibilité : Windows.

   Modifié dans la version 3.2: Changé en un *n*-uplet nommé, et ajout
   de *service_pack_minor*, *service_pack_major*, *suite_mask*, et
   *product_type*.

   Modifié dans la version 3.6: Ajout de *platform_version*

sys.get_asyncgen_hooks()

   Renvoie un objet *asyncgen_hooks*, qui est semblable à un
   "namedtuple" de la forme "(firstiter, finalizer)", où *firstiter*
   et *finalizer* sont soit "None" ou des fonctions qui prennent un
   *asynchronous generator iterator* comme argument, et sont utilisées
   pour planifier la finalisation d'un générateur asynchrone par un
   *event loop*.

   Added in version 3.6: Voir la **PEP 525** pour plus d'informations.

   Note:

     Cette fonction à été ajoutée à titre provisoire (voir la **PEP
     411** pour plus d'informations.)

sys.get_coroutine_origin_tracking_depth()

   Récupère le nombre de cadres d'exécution conservés par les
   coroutines pour le suivi de leur création, telle que défini par
   "set_coroutine_origin_tracking_depth()".

   Added in version 3.7.

   Note:

     Cette fonction à été ajoutée à titre provisoire (Voir la **PEP
     411** pour plus d'informations.)  Utilisez la uniquement à des
     fins de débogage.

sys.hash_info

   Un *named tuple* donnant les paramètres de l'implémentation de la
   fonction de hachage de nombres.  Pour plus d'informations sur le
   hachage des types numériques, consultez Hachage des types
   numériques.

   hash_info.width

      The width in bits used for hash values

   hash_info.modulus

      The prime modulus P used for numeric hash scheme

   hash_info.inf

      The hash value returned for a positive infinity

   hash_info.nan

      (This attribute is no longer used)

   hash_info.imag

      The multiplier used for the imaginary part of a complex number

   hash_info.algorithm

      The name of the algorithm for hashing of str, bytes, and
      memoryview

   hash_info.hash_bits

      The internal output size of the hash algorithm

   hash_info.seed_bits

      The size of the seed key of the hash algorithm

   Added in version 3.2.

   Modifié dans la version 3.4: Ajout de *algorithm*, *hash_bits* et
   *seed_bits*

sys.hexversion

   Le numéro de version codé sous forme d'un seul nombre entier.  Ce
   numéro augmente avec chaque version, y compris pour les versions
   hors production.  Par exemple, pour vérifier que l'interpréteur
   Python est au moins la version 1.5, utilisez :

      if sys.hexversion >= 0x010502F0:
          # use some advanced feature
          ...
      else:
          # use an alternative implementation or warn the user
          ...

   Cet attribut s'appelle "hexversion" dans le sens où il ne semble
   avoir du sens que s'il est regardé après avoir été passé à la
   fonction native "hex()".  Le *named tuple*  "sys.version_info"
   représente la même information d'une manière plus humaine.

   Consultez Version des API et ABI pour plus d'informations sur
   "hexversion".

sys.implementation

   Un objet contenant des informations sur l'implémentation de la
   version actuelle de l'interpréteur Python.  Les attributs suivants
   existent obligatoirement sur toutes les implémentations Python.

   *name* est l'identifiant de l'implémentation, e.g. "'cpython'".
   Cette chaîne est définie par l'implémentation de Python, mais sera
   toujours en minuscule.

   *version* est un *n*-uplet nommé, du même format que
   "sys.version_info".  Il représente la version de
   l'**implementation** de Python.  C'est une information différente
   de la version du **langage** auquel l'interpréteur actuel se
   conforme (donnée par "sys.version_info"). Par exemple, pour PyPy
   1.8 "sys.implementation.version" peut valoir "sys.version_info(1,
   8, 0, 'final', 0)", alors que "sys.version_info" peut valoir
   "sys.version_info(2, 7, 2, 'final', 0)".  Pour CPython ces deux
   valeurs sont identiques puisque c'est l'implémentation de
   référence.

   *hexversion* est la version de l'implémentation sous forme
   hexadécimale, comme "sys.hexversion".

   *cache_tag* est la balise utilisée par le mécanisme d'importation
   dans les noms de fichiers des modules mis en cache.  Par
   convention, il devrait se composer du nom et de la version de
   l'implémentation, comme "'cpython-33'".  Cependant, une
   implémentation Python peut utiliser une autre valeur si nécessaire.
   "cache_tag" à "None" signifie que la mise en cache des modules doit
   être désactivée.

   "sys.implementation" peut contenir d'autres attributs spécifiques à
   l'implémentation de Python. Ces attributs spécifiques doivent
   commencer par un *underscore*, et ne sont pas documentés ici.
   Indépendamment de son contenu, "sys.implementation" ne change
   jamais durant l'exécution de l'interpréteur, ni entre les versions
   d'une même implémentation.  (Il peut cependant changer entre les
   versions du langage Python.)  Voir la **PEP 421** pour plus
   d'informations.

   Added in version 3.3.

   Note:

     L'addition de nouveaux attributs requis doivent passer par le
     processus de **PEP** classique. Voir **PEP 421** pour plus
     d'informations.

sys.int_info

   Un *named tuple* qui contient des informations sur la
   représentation interne des entiers de Python.  Les attributs sont
   en lecture seule.

   int_info.bits_per_digit

      The number of bits held in each digit. Python integers are
      stored internally in base "2**int_info.bits_per_digit".

   int_info.sizeof_digit

      The size in bytes of the C type used to represent a digit.

   int_info.default_max_str_digits

      The default value for "sys.get_int_max_str_digits()" when it is
      not otherwise explicitly configured.

   int_info.str_digits_check_threshold

      The minimum non-zero value for "sys.set_int_max_str_digits()",
      "PYTHONINTMAXSTRDIGITS", or "-X int_max_str_digits".

   Added in version 3.1.

   Modifié dans la version 3.11: Added "default_max_str_digits" and
   "str_digits_check_threshold".

sys.__interactivehook__

   Lorsque cet attribut existe, sa valeur est automatiquement appelée
   (sans argument) par l'interpréteur lors de son démarrage en mode
   interactif.  L'appel se fait après que le fichier "PYTHONSTARTUP"
   soit lu, afin que vous puissiez y configurer votre fonction.
   Configuré par le module "site".

   Lève un évènement d'audit "cpython.run_interactivehook" avec comme
   argument "hook".

   Added in version 3.4.

sys.intern(string)

   Ajoute *string* dans le tableau des chaînes "internées" et renvoie
   la chaîne internée -- qui peut être *string* elle-même ou une
   copie. Interner une chaîne de caractères permet de gagner un peu de
   performance lors de l'accès aux dictionnaires -- si les clés du
   dictionnaire et la clé recherchée sont internées, les comparaisons
   de clés (après le hachage) pourront se faire en comparant les
   pointeurs plutôt que caractère par caractère. Normalement, les noms
   utilisés dans les programmes Python sont automatiquement internés,
   et les dictionnaires utilisés pour stocker les attributs de
   modules, de classes, ou d'instances ont aussi leurs clés internées.

   Les chaînes internées ne sont pas immortelles ; vous devez garder
   une référence à la valeur renvoyée par "intern()" pour en
   bénéficier.

sys.is_finalizing()

   Donne "True" si l'interpréteur Python est *en train de s'arrêter*,
   et "False" dans le cas contraire.

   Added in version 3.5.

sys.last_exc

   This variable is not always defined; it is set to the exception
   instance when an exception is not handled and the interpreter
   prints an error message and a stack traceback.  Its intended use is
   to allow an interactive user to import a debugger module and engage
   in post-mortem debugging without having to re-execute the command
   that caused the error.  (Typical use is "import pdb; pdb.pm()" to
   enter the post-mortem debugger; see "pdb" module for more
   information.)

   Added in version 3.12.

sys.last_type
sys.last_value
sys.last_traceback

   These three variables are deprecated; use "sys.last_exc" instead.
   They hold the legacy representation of "sys.last_exc", as returned
   from "exc_info()" above.

sys.maxsize

   Un entier donnant à la valeur maximale qu'une variable de type
   "Py_ssize_t" peut prendre.  C'est typiquement "2**31 - 1" sur une
   plateforme 32 bits et "2**63 - 1" sur une plateforme 64 bits.

sys.maxunicode

   Un entier donnant la valeur du plus grand point de code Unicode,
   c'est-à-dire "1114111" ("0x10FFFF" en hexadécimal).

   Modifié dans la version 3.3: Avant la **PEP 393**, "sys.maxunicode"
   valait soit "0xFFFF" soit "0x10FFFF", en fonction l'option de
   configuration qui spécifiait si les caractères Unicode étaient
   stockés en UCS-2 ou UCS-4.

sys.meta_path

   A list of *meta path finder* objects that have their "find_spec()"
   methods called to see if one of the objects can find the module to
   be imported. By default, it holds entries that implement Python's
   default import semantics. The "find_spec()" method is called with
   at least the absolute name of the module being imported. If the
   module to be imported is contained in a package, then the parent
   package's "__path__" attribute is passed in as a second argument.
   The method returns a *module spec*, or "None" if the module cannot
   be found.

   Voir aussi:

     "importlib.abc.MetaPathFinder"
        La classe de base abstraite définissant l'interface des objets
        *finder* de "meta_path".

     "importlib.machinery.ModuleSpec"
        La classe concrète dont "find_spec()" devrait renvoyer des
        instances.

   Modifié dans la version 3.4: *Module specs* were introduced in
   Python 3.4, by **PEP 451**.

   Modifié dans la version 3.12: Removed the fallback that looked for
   a "find_module()" method if a "meta_path" entry didn't have a
   "find_spec()" method.

sys.modules

   This is a dictionary that maps module names to modules which have
   already been loaded.  This can be manipulated to force reloading of
   modules and other tricks. However, replacing the dictionary will
   not necessarily work as expected and deleting essential items from
   the dictionary may cause Python to fail.  If you want to iterate
   over this global dictionary always use "sys.modules.copy()" or
   "tuple(sys.modules)" to avoid exceptions as its size may change
   during iteration as a side effect of code or activity in other
   threads.

sys.orig_argv

   The list of the original command line arguments passed to the
   Python executable.

   The elements of "sys.orig_argv" are the arguments to the Python
   interpreter, while the elements of "sys.argv" are the arguments to
   the user's program. Arguments consumed by the interpreter itself
   will be present in "sys.orig_argv" and missing from "sys.argv".

   Added in version 3.10.

sys.path

   Une liste de chaînes de caractères spécifiant les chemins de
   recherche des modules, initialisée à partir de la variable
   d'environnement "PYTHONPATH" et d'une valeur par défaut dépendante
   de l'installation.

   By default, as initialized upon program startup, a potentially
   unsafe path is prepended to "sys.path" (*before* the entries
   inserted as a result of "PYTHONPATH"):

   * "python -m module" command line: prepend the current working
     directory.

   * "python script.py" command line: prepend the script's directory.
     If it's a symbolic link, resolve symbolic links.

   * "python -c code" and "python" (REPL) command lines: prepend an
     empty string, which means the current working directory.

   To not prepend this potentially unsafe path, use the "-P" command
   line option or the "PYTHONSAFEPATH" environment variable.

   A program is free to modify this list for its own purposes.  Only
   strings should be added to "sys.path"; all other data types are
   ignored during import.

   Voir aussi:

     * Le module "site" décrit comment utiliser les fichiers *.pth*
       pour étendre "sys.path".

sys.path_hooks

   Une liste d'appelables d'un argument, *path*, pour essayer de créer
   un *finder* pour ce chemin. Si un *finder* peut être créé, il doit
   être renvoyé par l'appelable, sinon une "ImportError" doit être
   levée.

   Précisé à l'origine dans la **PEP 302**.

sys.path_importer_cache

   Un dictionnaire faisant office de cache pour les objets *finder*.
   Les clés sont les chemins qui ont été passés à "sys.path_hooks" et
   les valeurs sont les *finders* trouvés. Si un chemin est valide
   selon le système de fichiers mais qu'aucun *finder* n'est trouvé
   dans "sys.path_hooks", "None" est stocké.

   Précisé à l'origine dans la **PEP 302**.

sys.platform

   Cette chaîne contient un identificateur de plateforme qui peut être
   typiquement utilisé pour ajouter des composants spécifiques à
   "sys.path".

   Pour les systèmes Unix, sauf sur Linux et AIX, c'est le nom de l'OS
   en minuscules comme renvoyé par "uname -s" suivi de la première
   partie de la version comme renvoyée par "uname -r", e.g. "'sunos5'"
   ou "'freebsd8'", *au moment où Python a été compilé*.  A moins que
   vous ne souhaitiez tester pour une version spécifique du système,
   vous pouvez faire comme suit :

      if sys.platform.startswith('freebsd'):
          # FreeBSD-specific code here...
      elif sys.platform.startswith('linux'):
          # Linux-specific code here...
      elif sys.platform.startswith('aix'):
          # AIX-specific code here...

   Pour les autres systèmes, les valeurs sont :

   +------------------+-----------------------------+
   | Système          | Valeur pour "plateforme"    |
   |==================|=============================|
   | AIX              | "'aix'"                     |
   +------------------+-----------------------------+
   | Emscripten       | "'emscripten'"              |
   +------------------+-----------------------------+
   | Linux            | "'linux'"                   |
   +------------------+-----------------------------+
   | WASI             | "'wasi'"                    |
   +------------------+-----------------------------+
   | Windows          | "'win32'"                   |
   +------------------+-----------------------------+
   | Windows/Cygwin   | "'cygwin'"                  |
   +------------------+-----------------------------+
   | macOS            | "'darwin'"                  |
   +------------------+-----------------------------+

   Modifié dans la version 3.3: On Linux, "sys.platform" doesn't
   contain the major version anymore. It is always "'linux'", instead
   of "'linux2'" or "'linux3'".  Since older Python versions include
   the version number, it is recommended to always use the
   "startswith" idiom presented above.

   Modifié dans la version 3.8: On AIX, "sys.platform" doesn't contain
   the major version anymore. It is always "'aix'", instead of
   "'aix5'" or "'aix7'".  Since older Python versions include the
   version number, it is recommended to always use the "startswith"
   idiom presented above.

   Voir aussi:

     "os.name" has a coarser granularity.  "os.uname()" gives system-
     dependent version information.

     Le module "platform" fournit des vérifications détaillées pour
     l'identité du système.

sys.platlibdir

   Nom du dossier de la bibliothèque spécifique à la plateforme. Il
   est utilisé pour construire le chemin de vers la bibliothèque
   standard et les chemins vers les modules d'extensions installés.

   C'est égal à ""lib"" sur la plupart des plateformes. Sur Fedora et
   SuSE, c'est égal à ""lib64"" sur les plateformes 64-bits qui
   renvoient les chemins "sys.path" suivants (où "X.Y" et la version
   "majeure.mineur" de Python) :

   * "/usr/lib64/pythonX.Y/" : Bibliothèque standard (comme "os.py" du
     module "os")

   * "/usr/lib64/pythonX.Y/lib-dynload/" : Modules d'extension C de la
     bibliothèque standard (comme le module "errno", le nom du fichier
     exact est spécifique à la plateforme)

   * "/usr/lib/pythonX.Y/site-packages/" (toujours utiliser "lib", et
     non "sys.platlibdir") : modules tiers

   * "/usr/lib64/pythonX.Y/site-packages/" : Modules d'extension C de
     paquets tiers

   Added in version 3.9.

sys.prefix

   A string giving the site-specific directory prefix where the
   platform independent Python files are installed; on Unix, the
   default is "/usr/local". This can be set at build time with the "--
   prefix" argument to the **configure** script.  See Installation
   paths for derived paths.

   Note:

     Si a environnement virtuel est activé, cette valeur sera changée
     par "site py" pour pointer vers l'environnement virtuel. La
     valeur donnée au moment de la compilation de Python sera toujours
     disponible, dans "base_prefix".

sys.ps1
sys.ps2

   Chaînes spécifiant l'invite primaire et secondaire de
   l'interpréteur.  Celles-ci ne sont définies que si l'interpréteur
   est en mode interactif.  Dans ce cas, leurs valeurs initiales sont
   "'>>>'" et "'...'".  Si un objet qui n'est pas une chaîne est
   assigné à l'une ou l'autre variable, sa méthode "str()" sera
   appelée à chaque fois que l'interpréteur se prépare à lire une
   nouvelle commande interactive, c'est donc utilisable pour
   implémenter une invite dynamique.

sys.setdlopenflags(n)

   Set the flags used by the interpreter for "dlopen()" calls, such as
   when the interpreter loads extension modules.  Among other things,
   this will enable a lazy resolving of symbols when importing a
   module, if called as "sys.setdlopenflags(0)".  To share symbols
   across extension modules, call as
   "sys.setdlopenflags(os.RTLD_GLOBAL)".  Symbolic names for the flag
   values can be found in the "os" module ("RTLD_*xxx*" constants,
   e.g. "os.RTLD_LAZY").

   Disponibilité : Unix.

sys.set_int_max_str_digits(maxdigits)

   Set the integer string conversion length limitation used by this
   interpreter. See also "get_int_max_str_digits()".

   Added in version 3.11.

sys.setprofile(profilefunc)

   Définit la fonction de profilage du système, qui vous permet
   d'implémenter un profileur de code source Python en Python.  Voir
   le chapitre The Python Profilers pour plus d'informations sur le
   profileur Python. La fonction de profilage du système est appelée
   de la même façon que la fonction trace du système (voir
   "settrace()"), mais elle est appelée pour des évènements
   différents, par exemple elle n'est pas appelée à chaque ligne de
   code exécutée (seulement sur appel et retours, mais l'événement
   pour les retours est appelé même en cas d'exception). Cette
   fonction est locale au fil d'exécution, et il n'existe aucun moyen,
   du point de vue du profileur, de prendre conscience des changements
   de contextes entre fils d'exécution, ça n'a donc aucun sens
   d'utiliser cette fonction dans un contexte *multithread*. Sa valeur
   de retour n'est pas utilisée, elle peut simplement renvoyer "None".

   Note:

     The same tracing mechanism is used for "setprofile()" as
     "settrace()". To trace calls with "setprofile()" inside a tracing
     function (e.g. in a debugger breakpoint), see "call_tracing()".

   Les fonctions de traçage doivent avoir trois arguments : *frame*,
   *event*, et *arg*. *frame* est la *stack frame* actuelle. *event*
   est une chaîne de caractères pouvant valoir : "'call'", "'return'",
   "'c_call'", "'c_return'" ou "'c_exception'". *arg* dépend du type
   de l'évènement.

   Les événements ont la signification suivante :

   "'call'"
      Une fonction est appelée (ou Python entre dans un autre bloc de
      code). La fonction de traçage est appelée, *arg* est "None".

   "'return'"
      La fonction (ou un autre type de bloc) est sur le point de se
      terminer. La fonction de traçage est appelée, *arg* est la
      valeur qui sera renvoyée, ou "None" si l'événement est causé par
      la levée d'une exception.

   "'c_call'"
      Une fonction C est sur le point d'être appelée.  C'est soit une
      fonction d'extension ou une fonction native.  *arg* représente
      la fonction C.

   "'c_return'"
      Une fonction C a renvoyé une valeur. *arg* représente la
      fonction C.

   "'c_exception'"
      Une fonction C a levé une exception.  *arg* représente la
      fonction C.

   Lève un évènement d'audit "sys.setprofile" sans arguments.

sys.setrecursionlimit(limit)

   Définit la profondeur maximale de la pile de l'interpréteur Python
   à *limit*.  Cette limite empêche une récursion infinie de provoquer
   un débordement de la pile C et ainsi un crash de Python.

   La limite haute dépend de la plate-forme.  Un utilisateur pourrait
   avoir besoin de remonter la limite, lorsque son programme nécessite
   une récursion profonde, si sa plate-forme le permet.  Cela doit
   être fait avec précaution, car une limite trop élevée peut conduire
   à un crash.

   Si la nouvelle limite est plus basse que la profondeur actuelle,
   une "RecursionError" est levée.

   Modifié dans la version 3.5.1: Une "RecursionError" est maintenant
   levée si la nouvelle limite est plus basse que la profondeur de
   récursion actuelle.

sys.setswitchinterval(interval)

   Configure l'intervalle de bascule des fils d'exécution de
   l'interpréteur (en secondes). Ce nombre à virgule flottante
   détermine la durée idéale allouée aux fils d'exécution en cour
   d'exécution (durée appelée *timeslices*). Notez que la durée
   observée peut être plus grande, typiquement si des fonctions ou
   méthodes prenant beaucoup de temps sont utilisées.  Aussi, le choix
   du fil d'exécution prenant la main à la fin de l'intervalle revient
   au système d'exploitation. L'interpréteur n'a pas son propre
   ordonnanceur.

   Added in version 3.2.

sys.settrace(tracefunc)

   Définit la fonction de traçage du système, qui vous permet
   d'implémenter un débogueur de code source Python en Python. Cette
   fonction est locale au fil d'exécution courant. Pour qu'un
   débogueur puisse gérer plusieurs fils d'exécution, il doit
   enregistrer sa fonction en appelant "settrace()" pour chaque fil
   d'exécution qu'il souhaite surveiller ou utilisez
   "threading.settrace()".

   Les fonctions de traçage doivent avoir trois arguments : *frame*,
   *event*, et *arg*. *frame* est la *stack frame* actuelle. *event*
   est une chaîne de caractères pouvant valoir : "'call'", "'line'",
   "'return'", "'exception'" ou "'opcode'". *arg* dépend du type de
   l'évènement.

   La fonction de traçage est appelée (avec *event* à "'call'") à
   chaque fois que l'interpréteur entre dans un nouveau *scope*. Elle
   doit renvoyer une référence à une fonction de traçage locale à
   utiliser pour ce *scope*, ou "None" si le *Scope* ne doit pas être
   tracé.

   The local trace function should return a reference to itself, or to
   another function which would then be used as the local trace
   function for the scope.

   Si une erreur se produit dans la fonction de trace, elle sera
   désactivée, tout comme si "settrace(None)" avait été appelée.

   Note:

     Tracing is disabled while calling the trace function (e.g. a
     function set by "settrace()"). For recursive tracing see
     "call_tracing()".

   Les événements ont la signification suivante :

   "'call'"
      Une fonction est appelée (un un bloc de code). La fonction de
      traçage globale est appelée, *arg* est "None", la valeur
      renvoyée donne la fonction de traçage locale.

   "'line'"
      The interpreter is about to execute a new line of code or re-
      execute the condition of a loop.  The local trace function is
      called; *arg* is "None"; the return value specifies the new
      local trace function.  See "Objects/lnotab_notes.txt" for a
      detailed explanation of how this works. Per-line events may be
      disabled for a frame by setting "f_trace_lines" to "False" on
      that frame.

   "'return'"
      La fonction (ou un autre type de bloc) est sur le point de se
      terminer. La fonction de traçage locale est appelée, *arg* est
      la valeur qui sera renvoyée, ou "None" si l'événement est causé
      par la levée d'une exception. La valeur renvoyée par la fonction
      de traçage est ignorée.

   "'exception'"
      Une exception est survenue. La fonction de traçage locale est
      appelée, *arg* est le triplet "(exception, valeur, traceback)",
      la valeur renvoyée spécifie la nouvelle fonction de traçage
      locale.

   "'opcode'"
      The interpreter is about to execute a new opcode (see "dis" for
      opcode details).  The local trace function is called; *arg* is
      "None"; the return value specifies the new local trace function.
      Per-opcode events are not emitted by default: they must be
      explicitly requested by setting "f_trace_opcodes" to "True" on
      the frame.

   Remarquez que, comme une exception se propage au travers de toute
   chaîne d'appelants, un événement "'exception'" est généré à chaque
   niveau.

   Pour une utilisation plus fine, il est possible de définir une
   fonction de traçage en assignant "frame.f_trace = tracefunc"
   explicitement, plutôt que de s'appuyer sur le fait qu'elle soit
   définie indirectement par la valeur de retour d'une fonction trace
   déjà installée. Cela est aussi demandé pour l'activation de la
   fonction de traçage dans le cadre, ce que "settrace()" ne fait pas.
   Notez que pour que cela fonctionne, une fonction globale de traçage
   doit avoir été installée avec "settrace()" afin d'activer le
   mécanisme de traçage au moment de l'exécution, mais il n'est pas
   nécessaire que ce soit la même fonction de traçage (Par exemple,
   cela pourrait être une fonction de traçage avec peu de surcharge
   qui retourne simplement "None" pour se désactiver immédiatement à
   chaque cadre).

   Pour plus d'informations sur les objets code et objets représentant
   une *frame* de la pile, consultez Hiérarchie des types standards.

   Lève un évènement d'audit "sys.settrace" sans arguments.

   **Particularité de l'implémentation CPython :** La fonction
   "settrace()" est destinée uniquement à l'implémentation de
   débogueurs, de profileurs, d'outils d'analyse de couverture et
   d'autres outils similaires. Son comportement fait partie de
   l'implémentation, plutôt que de la définition du langage, et peut
   donc ne pas être disponible dans toutes les implémentations de
   Python.

   Modifié dans la version 3.7: "'opcode'" event type added;
   "f_trace_lines" and "f_trace_opcodes" attributes added to frames

   Modifié dans la version 3.12: "'opcode'" event will only be emitted
   if "f_trace_opcodes" of at least one frame has been set to "True"
   before "settrace()" is called. This behavior will be changed back
   in 3.13 to be consistent with previous versions.

sys.set_asyncgen_hooks([firstiter] [, finalizer])

   Accepte deux arguments optionnels nommés, qui sont appelables qui
   acceptent un *asynchronous generator iterator* comme argument.
   L'appelable *firsttiter* sera appelé lorsqu'un générateur
   asynchrone sera itéré pour la première fois, et l'appelable
   *finalizer* sera appelé lorsqu'un générateur asynchrone est sur le
   point d'être détruit.

   Lève un évènement d'audit "sys.set_asyncgen_hooks_firstiter" sans
   arguments.

   Lève un événement d'audit "sys.set_asyncgen_hooks_finalizer" sans
   arguments.

   Deux événements d'audit sont levés car l'API sous-jacente consiste
   de deux appels, dont chacun doit lever son propre événement.

   Added in version 3.6: Voir la **PEP 525** pour plus de détails.
   Pour un exemple de *finalizer*, voir l'implémentation de
   "asyncio.Loop.shutdown_asyncgens" dans Lib/asyncio/base_events.py

   Note:

     Cette fonction à été ajoutée à titre provisoire (voir la **PEP
     411** pour plus d'informations.)

sys.set_coroutine_origin_tracking_depth(depth)

   Allows enabling or disabling coroutine origin tracking. When
   enabled, the "cr_origin" attribute on coroutine objects will
   contain a tuple of (filename, line number, function name) tuples
   describing the traceback where the coroutine object was created,
   with the most recent call first. When disabled, "cr_origin" will be
   "None".

   Pour l'activer, passez une valeur *depth* supérieure à zéro ; cela
   définit le nombre de cadres d'exécution dont les informations sont
   capturées. Pour le désactiver, mettez *depth* à zéro.

   Ce paramètre est spécifique au fil d'exécution courant.

   Added in version 3.7.

   Note:

     Cette fonction à été ajoutée à titre provisoire (Voir la **PEP
     411** pour plus d'informations.)  Utilisez la uniquement à des
     fins de débogage.

sys.activate_stack_trampoline(backend, /)

   Activate the stack profiler trampoline *backend*. The only
   supported backend is ""perf"".

   Availability: Linux.

   Added in version 3.12.

   Voir aussi:

     * Python support for the Linux perf profiler

     * https://perf.wiki.kernel.org

sys.deactivate_stack_trampoline()

   Deactivate the current stack profiler trampoline backend.

   If no stack profiler is activated, this function has no effect.

   Availability: Linux.

   Added in version 3.12.

sys.is_stack_trampoline_active()

   Return "True" if a stack profiler trampoline is active.

   Availability: Linux.

   Added in version 3.12.

sys._enablelegacywindowsfsencoding()

   Changes the *filesystem encoding and error handler* to 'mbcs' and
   'replace' respectively, for consistency with versions of Python
   prior to 3.6.

   Équivaut à définir la variable d'environnement
   "PYTHONLEGACYWINDOWSFSENCODING" avant de lancer Python.

   See also "sys.getfilesystemencoding()" and
   "sys.getfilesystemencodeerrors()".

   Disponibilité : Windows.

   Added in version 3.6: Voir la **PEP 529** pour plus d'informations.

sys.stdin
sys.stdout
sys.stderr

   *objets fichiers* utilisés par l'interpréteur pour l'entrée
   standard, la sortie standard et la sortie d'erreurs :

   * "stdin" est utilisé pour toutes les entrées interactives (y
     compris les appels à "input()")

   * "stdout" est utilisé pour la sortie de "print()", des
     *expression* et pour les invites de "input()" ;

   * Les invites de l'interpréteur et ses messages d'erreur sont
     écrits sur "stderr".

   Ces flux sont de classiques *fichiers texte* comme ceux renvoyés
   par la fonction "open()". Leurs paramètres sont choisis comme suit
   :

   * The encoding and error handling are is initialized from
     "PyConfig.stdio_encoding" and "PyConfig.stdio_errors".

     On Windows, UTF-8 is used for the console device.  Non-character
     devices such as disk files and pipes use the system locale
     encoding (i.e. the ANSI codepage).  Non-console character devices
     such as NUL (i.e. where "isatty()" returns "True") use the value
     of the console input and output codepages at startup,
     respectively for stdin and stdout/stderr. This defaults to the
     system *locale encoding* if the process is not initially attached
     to a console.

     Le comportement spécial de la console peut être redéfini en
     assignant la variable d'environnement *PYTHONLEGACYWINDOWSSTDIO*
     avant de démarrer Python. Dans ce cas, les pages de code de la
     console sont utilisées comme pour tout autre périphérique de
     caractères.

     Sous toutes les plateformes, vous pouvez redéfinir le codage de
     caractères en assignant la variable d'environnement
     "PYTHONIOENCODING" avant de démarrer Python ou en utilisant la
     nouvelle option de ligne de commande "-X" "utf8" et la variable
     d'environnement "PYTHONUTF8". Toutefois, pour la console Windows,
     cela s'applique uniquement lorsque "PYTHONLEGACYWINDOWSSTDIO" est
     également défini.

   * When interactive, the "stdout" stream is line-buffered.
     Otherwise, it is block-buffered like regular text files.  The
     "stderr" stream is line-buffered in both cases.  You can make
     both streams unbuffered by passing the "-u" command-line option
     or setting the "PYTHONUNBUFFERED" environment variable.

   Modifié dans la version 3.9: Le "stderr" non interactif est
   maintenant mis en mémoire-tampon ligne par ligne plutôt
   qu'entièrement.

   Note:

     Pour écrire ou lire des données binaires depuis ou vers les flux
     standards, utilisez l'objet sous-jacent "buffer". Par exemple,
     pour écrire des octets sur "stdout", utilisez
     "sys.stdout.buffer.write(b'abc')".However, if you are writing a
     library (and do not control in which context its code will be
     executed), be aware that the standard streams may be replaced
     with file-like objects like "io.StringIO" which do not support
     the "buffer" attribute.

sys.__stdin__
sys.__stdout__
sys.__stderr__

   Ces objets contiennent les valeurs d'origine de "stdin", "stderr"
   et "stdout" tel que présentes au début du programme. Ils sont
   utilisés pendant la finalisation, et peuvent être utiles pour
   écrire dans le vrai flux standard, peu importe si l'objet
   "sys.std*" a été redirigé.

   Ils peuvent également être utilisés pour restaurer les entrées /
   sorties d'origine, au cas où ils auraient été écrasés par des
   objets cassé, cependant la bonne façon de faire serait de
   sauvegarder explicitement les flux avant de les remplacer et ainsi
   pouvoir les restaurer.

   Note:

     Dans certaines cas, "stdin", "stdout" et "stderr" ainsi que les
     valeurs initiales "__stdin__", "__stdout__" et "__stderr__"
     peuvent être "None". C'est typiquement le cas pour les
     applications graphiques sur Windows qui ne sont pas connectées à
     une console, ou les applications Python démarrées avec
     **pythonw**.

sys.stdlib_module_names

   A frozenset of strings containing the names of standard library
   modules.

   It is the same on all platforms. Modules which are not available on
   some platforms and modules disabled at Python build are also
   listed. All module kinds are listed: pure Python, built-in, frozen
   and extension modules. Test modules are excluded.

   For packages, only the main package is listed: sub-packages and
   sub-modules are not listed. For example, the "email" package is
   listed, but the "email.mime" sub-package and the "email.message"
   sub-module are not listed.

   See also the "sys.builtin_module_names" list.

   Added in version 3.10.

sys.thread_info

   Un *named tuple* contenant des informations sur l'implémentation
   des fils d'exécution.

   thread_info.name

      The name of the thread implementation:

      * ""nt"": Windows threads

      * ""pthread"": POSIX threads

      * ""pthread-stubs"": stub POSIX threads (on WebAssembly
        platforms without threading support)

      * ""solaris"": Solaris threads

   thread_info.lock

      The name of the lock implementation:

      * ""semaphore"": a lock uses a semaphore

      * ""mutex+cond"": a lock uses a mutex and a condition variable

      * "None" si cette information n'est pas connue

   thread_info.version

      The name and version of the thread library. It is a string, or
      "None" if this information is unknown.

   Added in version 3.3.

sys.tracebacklimit

   Lorsque cette variable contient un nombre entier, elle détermine la
   profondeur maximum de la pile d'appels affichée lorsqu'une
   exception non gérée se produit. La valeur par défaut est "1000",
   lorsque cette valeur est égale ou inférieure à "0", la pile
   d'appels n'est pas affichée, seul seuls le type et la valeur de
   l'exception sont le sont.

sys.unraisablehook(unraisable, /)

   Gère une exception *non levable* (**unraisable** en anglais)

   Appelé lorsqu'une exception s'est produite mais qu'il n'y a aucun
   moyen pour Python de la gérer. Par exemple, lorsqu'un destructeur
   lève une exception ou durant le passage du ramasse-miettes
   ("gc.collect()").

   Les arguments *unraisable* ont la signification suivante :

   * "exc_type": Exception type.

   * "exc_value": Exception value, can be "None".

   * "exc_traceback": Exception traceback, can be "None".

   * "err_msg": Error message, can be "None".

   * "object": Object causing the exception, can be "None".

   The default hook formats "err_msg" and "object" as: "f'{err_msg}:
   {object!r}'"; use "Exception ignored in" error message if "err_msg"
   is "None".

   "sys.unraisablehook()" peut être remplacé pour contrôler comment
   les exceptions *non levables* (**unraisable** en anglais) sont
   gérées.

   Voir aussi: "excepthook()" which handles uncaught exceptions.

   Avertissement:

     Storing "exc_value" using a custom hook can create a reference
     cycle. It should be cleared explicitly to break the reference
     cycle when the exception is no longer needed.Storing "object"
     using a custom hook can resurrect it if it is set to an object
     which is being finalized. Avoid storing "object" after the custom
     hook completes to avoid resurrecting objects.

   Raise an auditing event "sys.unraisablehook" with arguments *hook*,
   *unraisable* when an exception that cannot be handled occurs. The
   *unraisable* object is the same as what will be passed to the hook.
   If no hook has been set, *hook* may be "None".

   Added in version 3.8.

sys.version

   Une chaîne contenant le numéro de version de l'interpréteur Python,
   ainsi que d'autres informations comme le numéro de compilation et
   le compilateur utilisé. Cette chaîne est affichée lorsque
   l'interpréteur est démarré en mode interactif. N'essayez pas d'en
   extraire des informations de version, utilisez plutôt
   "version_info" et les fonctions fournies par le module "platform".

sys.api_version

   La version de l'API C pour cet interpréteur.  Les développeurs
   peuvent trouver cette information utile en déboguant des conflits
   de versions entre Python et des modules d'extension.

sys.version_info

   Un quintuplet contenant les composants du numéro de version :
   *major*, *minor*, *micro*, *releaselevel* et *serial*.  Toutes les
   valeurs sauf *releaselevel* sont des nombres entiers.
   *releaselevel* peut valoir "'alpha'", "'beta'", "'candidate'", ou
   "'final'". La valeur de "version_info" pour Python 2.0 est "(2, 0,
   0, 'final', 0)". Ces attributs sont aussi accessibles par leur nom,
   ainsi "sys.version_info[0]" est équivalent à
   "sys.version_info.major", et ainsi de suite.

   Modifié dans la version 3.1: Ajout des attributs nommés.

sys.warnoptions

   C'est une spécificité de l'implémentation de la gestion des
   avertissements. Ne modifiez pas cette valeur.  Reportez-vous au
   module "warnings" pour plus d'informations sur le gestionnaire
   d'avertissements.

sys.winver

   The version number used to form registry keys on Windows platforms.
   This is stored as string resource 1000 in the Python DLL.  The
   value is normally the major and minor versions of the running
   Python interpreter.  It is provided in the "sys" module for
   informational purposes; modifying this value has no effect on the
   registry keys used by Python.

   Disponibilité : Windows.

sys.monitoring

   Namespace containing functions and constants for register callbacks
   and controlling monitoring events. See  "sys.monitoring" for
   details.

sys._xoptions

   Un dictionnaire des différentes options spécifiques à
   l'implémentation passés en ligne de commande via l'option "-X".
   Aux noms des options correspondent soit leur valeur, si elle est
   donnée explicitement, soit à "True". Exemple :

      $ ./python -Xa=b -Xc
      Python 3.2a3+ (py3k, Oct 16 2010, 20:14:50)
      [GCC 4.4.3] on linux2
      Type "help", "copyright", "credits" or "license" for more information.
      >>> import sys
      >>> sys._xoptions
      {'a': 'b', 'c': True}

   **Particularité de l'implémentation CPython :** C'est un moyen
   spécifique à CPython pour accéder aux options passées via l'option
   "-X".  D'autres implémentations pourraient les exposer par d'autres
   moyens, ou pas du tout.

   Added in version 3.2.

-[ Citations ]-

[C99] ISO/IEC 9899:1999.  "Programming languages -- C."  A public
      draft of this standard is available at https://www.open-
      std.org/jtc1/sc22/wg14/www/docs/n1256.pdf.
