28.1. "sys" — Paramètres et fonctions propres à des systèmes
************************************************************

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

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

   Nouveau dans la version 2.0.

sys.builtin_module_names

   Un *tuple* de chaînes de caractères donnant les noms de tous les
   modules compilés dans l’interpréteur Python.  (Cette information
   n’est pas disponible autrement — "`modules.keys()" liste seulement
   les modules importés.)

sys.call_tracing(func, args)

   Appelle "func(*args)", avec le traçage activé. L’état du traçage
   est sauvegardé et restauré après l’appel.  Ceci est destiné à être
   appelé depuis un débogueur à partir d’un point de contrôle, pour
   déboguer récursivement un autre code.

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

   Nouveau dans la version 2.6.

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

   Nouveau dans la version 2.5.

sys.dllhandle

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

sys.displayhook(value)

   If *value* is not "None", this function prints it to "sys.stdout",
   and saves it in "__builtin__._".

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

sys.dont_write_bytecode

   If this is true, Python won’t try to write ".pyc" or ".pyo" files
   on the import of source modules.  This value is initially set to
   "True" or "False" depending on the "-B" command line option and the
   "PYTHONDONTWRITEBYTECODE" environment variable, but you can set it
   yourself to control bytecode file generation.

   Nouveau dans la version 2.6.

sys.excepthook(type, value, traceback)

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

   Lorsqu’une exception est levée et n’est pas attrapée,
   l’interpréteur appelle "sys.excepthook" avec trois arguments, la
   classe de l’exception, l’instance de l’exception, et un objet
   *traceback*.  Dans une session interactive, cela se produit juste
   avant que le que l’invite soit rendue.  Dans un programme Python,
   cela se produit juste avant que le programme quitte. La gestion de
   ces exceptions peut être personnalisé en affectant une autre
   fonction de trois arguments à "sys.excepthook".

sys.__displayhook__
sys.__excepthook__

   Ces objets contiennent les valeurs originales de "displayhook" et
   "excepthook" au début du programme.  Elles sont sauvegardées de
   façon à ce que "displayhook" et "excepthook" puisse être restaurées
   au cas où elles seraient remplacées par des objets cassés.

sys.exc_info()

   This function returns a tuple of three values that give information
   about the exception that is currently being handled.  The
   information returned is specific both to the current thread and to
   the current stack frame.  If the current stack frame is not
   handling an exception, the information is taken from the calling
   stack frame, or its caller, and so on until a stack frame is found
   that is handling an exception.  Here, « handling an exception » is
   defined as « executing or having executed an except clause. »  For
   any stack frame, only information about the most recently handled
   exception is accessible.

   If no exception is being handled anywhere on the stack, a tuple
   containing three "None" values is returned.  Otherwise, the values
   returned are "(type, value, traceback)".  Their meaning is: *type*
   gets the exception type of the exception being handled (a class
   object); *value* gets the exception parameter (its *associated
   value* or the second argument to "raise", which is always a class
   instance if the exception type is a class object); *traceback* gets
   a traceback object (see the Reference Manual) which encapsulates
   the call stack at the point where the exception originally
   occurred.

   If "exc_clear()" is called, this function will return three "None"
   values until either another exception is raised in the current
   thread or the execution stack returns to a frame where another
   exception is being handled.

   Avertissement: Assigning the *traceback* return value to a local
     variable in a function that is handling an exception will cause a
     circular reference.  This will prevent anything referenced by a
     local variable in the same function or by the traceback from
     being garbage collected.  Since most functions don’t need access
     to the traceback, the best solution is to use something like
     "exctype, value = sys.exc_info()[:2]" to extract only the
     exception type and value.  If you do need the traceback, make
     sure to delete it after use (best done with a "try" … "finally"
     statement) or to call "exc_info()" in a function that does not
     itself handle an exception.

   Note: Beginning with Python 2.2, such cycles are automatically
     reclaimed when garbage collection is enabled and they become
     unreachable, but it remains more efficient to avoid creating
     cycles.

sys.exc_clear()

   This function clears all information relating to the current or
   last exception that occurred in the current thread.  After calling
   this function, "exc_info()" will return three "None" values until
   another exception is raised in the current thread or the execution
   stack returns to a frame where another exception is being handled.

   This function is only needed in only a few obscure situations.
   These include logging and error handling systems that report
   information on the last or current exception.  This function can
   also be used to try to free resources and trigger object
   finalization, though no guarantee is made as to what objects will
   be freed, if any.

   Nouveau dans la version 2.3.

sys.exc_type
sys.exc_value
sys.exc_traceback

   Obsolète depuis la version 1.5: Use "exc_info()" instead.

   Since they are global variables, they are not specific to the
   current thread, so their use is not safe in a multi-threaded
   program.  When no exception is being handled, "exc_type" is set to
   "None" and the other two are undefined.

sys.exec_prefix

   A string giving the site-specific directory prefix where the
   platform-dependent Python files are installed; by default, this is
   also "'/usr/local'".  This can be set at build time with the "--
   exec-prefix" argument to the **configure** script.  Specifically,
   all configuration files (e.g. the "pyconfig.h" header file) are
   installed in the directory "*exec_prefix*/lib/python*X.Y*/config",
   and shared library modules are installed in
   "*exec_prefix*/lib/python*X.Y*/lib-dynload", where *X.Y* is the
   version number of Python, for example "2.7".

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])

   Quitte Python.  C’est implémente en levant l’exception
   "SystemExit", afin que toutes les actions de nettoyage spécifiées
   par des clauses *finally* des instructions "try" soient
   correctement exécutées. Il est aussi possible d’intercepter la
   tentative de sortie à un niveau au dessus.

   The optional argument *arg* can be an integer giving the exit
   status (defaulting to zero), or another type of object.  If it is
   an integer, zero is considered « successful termination » and any
   nonzero value is considered « abnormal termination » by shells and
   the like.  Most systems require it to be in the range 0–127, and
   produce undefined results otherwise.  Some systems have a
   convention for assigning specific meanings to specific exit codes,
   but these are generally underdeveloped; Unix programs generally use
   2 for command line syntax errors and 1 for all other kind of
   errors.  If another type of object is passed, "None" is equivalent
   to passing zero, and any other object is printed to "stderr" and
   results in an exit code of 1.  In particular, "sys.exit("some error
   message")" is a quick way to exit a program when an error occurs.

   Puisque la fonction "exit()" ne fait « que » lever une exception,
   elle ne fera quitter le processus que si elle est appelée depuis le
   fil d’exécution principal, et que l’exception n’est pas
   interceptée.

sys.exitfunc

   This value is not actually defined by the module, but can be set by
   the user (or by a program) to specify a clean-up action at program
   exit.  When set, it should be a parameterless function.  This
   function will be called when the interpreter exits.  Only one
   function may be installed in this way; to allow multiple functions
   which will be called at termination, use the "atexit" module.

   Note: The exit function is not called when the program is killed
     by a signal, when a Python fatal internal error is detected, or
     when "os._exit()" is called.

   Obsolète depuis la version 2.4: Use "atexit" instead.

sys.flags

   The struct sequence *flags* exposes the status of command line
   flags. The attributes are read only.

   +-------------------------------+-------------------------------------+
   | attribut                      | option                              |
   |===============================|=====================================|
   | "debug"                       | "-d"                                |
   +-------------------------------+-------------------------------------+
   | "py3k_warning"                | "-3"                                |
   +-------------------------------+-------------------------------------+
   | "division_warning"            | "-Q"                                |
   +-------------------------------+-------------------------------------+
   | "division_new"                | "-Qnew"                             |
   +-------------------------------+-------------------------------------+
   | "inspect"                     | "-i"                                |
   +-------------------------------+-------------------------------------+
   | "interactive"                 | "-i"                                |
   +-------------------------------+-------------------------------------+
   | "optimize"                    | "-O" or "-OO"                       |
   +-------------------------------+-------------------------------------+
   | "dont_write_bytecode"         | "-B"                                |
   +-------------------------------+-------------------------------------+
   | "no_user_site"                | "-s"                                |
   +-------------------------------+-------------------------------------+
   | "no_site"                     | "-S"                                |
   +-------------------------------+-------------------------------------+
   | "ignore_environment"          | "-E"                                |
   +-------------------------------+-------------------------------------+
   | "tabcheck"                    | "-t" or "-tt"                       |
   +-------------------------------+-------------------------------------+
   | "verbose"                     | "-v"                                |
   +-------------------------------+-------------------------------------+
   | "unicode"                     | "-U"                                |
   +-------------------------------+-------------------------------------+
   | "bytes_warning"               | "-b"                                |
   +-------------------------------+-------------------------------------+
   | "hash_randomization"          | "-R"                                |
   +-------------------------------+-------------------------------------+

   Nouveau dans la version 2.6.

   Nouveau dans la version 2.7.3: L’attribut "hash_randomization".

sys.float_info

   A structseq holding information about the float type. It contains
   low level information about the precision and internal
   representation.  The values correspond to the various floating-
   point constants defined in the standard header file "float.h" for
   the “C” programming language; see section 5.2.4.2.2 of the 1999
   ISO/IEC C standard [C99], “Characteristics of floating types”, for
   details.

   +-----------------------+------------------+----------------------------------------------------+
   | attribut              | macro *float.h*  | explication                                        |
   |=======================|==================|====================================================|
   | "epsilon"             | DBL_EPSILON      | différence entre 1 et la plus petite valeur plus   |
   |                       |                  | grande que 1 représentable en *float*              |
   +-----------------------+------------------+----------------------------------------------------+
   | "dig"                 | DBL_DIG          | nombre maximum de décimales pouvant être           |
   |                       |                  | représentées fidèlement dans un *float* (voir ci-  |
   |                       |                  | dessous)                                           |
   +-----------------------+------------------+----------------------------------------------------+
   | "mant_dig"            | DBL_MANT_DIG     | précision : nombre de *base-*"radix" chiffres dans |
   |                       |                  | la mantisse du *float*                             |
   +-----------------------+------------------+----------------------------------------------------+
   | "max"                 | DBL_MAX          | plus grand *float* fini représentable              |
   +-----------------------+------------------+----------------------------------------------------+
   | "max_exp"             | DBL_MAX_EXP      | plus grand nombre entier *e* tel que               |
   |                       |                  | "radix**(e-1)" soit représentable sous forme de    |
   |                       |                  | *float* finit                                      |
   +-----------------------+------------------+----------------------------------------------------+
   | "max_10_exp"          | DBL_MAX_10_EXP   | plus grand nombre entier *e* tel que "10**e" est   |
   |                       |                  | dans l’intervalle des nombre flottants finis       |
   +-----------------------+------------------+----------------------------------------------------+
   | "min"                 | DBL_MIN          | plus petit nombre à virgule flottante positif      |
   |                       |                  | normalisé                                          |
   +-----------------------+------------------+----------------------------------------------------+
   | "min_exp"             | DBL_MIN_EXP      | plus petit entier *e* tel que "radix**(e-1)" est   |
   |                       |                  | un *float* normalisé                               |
   +-----------------------+------------------+----------------------------------------------------+
   | "min_10_exp"          | DBL_MIN_10_EXP   | plus petit nombre entier *e* tel que "10**e" est   |
   |                       |                  | un nombre à virgule flottante normalisé            |
   +-----------------------+------------------+----------------------------------------------------+
   | "radix"               | FLT_RADIX        | base de la représentation de l’exposant            |
   +-----------------------+------------------+----------------------------------------------------+
   | "rounds"              | FLT_ROUNDS       | constante, nombre entier représentant le mode      |
   |                       |                  | d’arrondi utilisé pour les opérations              |
   |                       |                  | arithmétiques. Elle reflète la valeur de la macro  |
   |                       |                  | système FLT_ROUNDS au moment du démarrage de       |
   |                       |                  | l’interpréteur. Voir section 5.2.4.4.2.2 de la     |
   |                       |                  | norme C99 pour une explication des valeurs         |
   |                       |                  | possibles et de leurs significations.              |
   +-----------------------+------------------+----------------------------------------------------+

   L’attribut "sys.float_info.dig" nécessite plus d’explications : Si
   "s" est une chaîne représentant un nombre décimal avec au plus
   "sys.float_info.dig" chiffres significatifs, alors, convertir "s"
   en un nombre à virgule flottante puis à nouveau en chaîne redonnera
   la même valeur :

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

   Nouveau dans la version 2.6.

sys.float_repr_style

   A string indicating how the "repr()" function behaves for floats.
   If the string has value "'short'" then for a finite float "x",
   "repr(x)" aims to produce a short string with the property that
   "float(repr(x)) == x".  This is the usual behaviour in Python 2.7
   and later.  Otherwise, "float_repr_style" has value "'legacy'" and
   "repr(x)" behaves in the same way as it did in versions of Python
   prior to 2.7.

   Nouveau dans la version 2.7.

sys.getcheckinterval()

   Renvoie le *check interval* de l’interpréteur, voir
   "setcheckinterval()".

   Nouveau dans la version 2.3.

sys.getdefaultencoding()

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

   Nouveau dans la version 2.0.

sys.getdlopenflags()

   Return the current value of the flags that are used for "dlopen()"
   calls. The flag constants are defined in the "dl" and "DLFCN"
   modules. Availability: Unix.

   Nouveau dans la version 2.2.

sys.getfilesystemencoding()

   Return the name of the encoding used to convert Unicode filenames
   into system file names, or "None" if the system default encoding is
   used. The result value depends on the operating system:

   * Sur Mac OS X, l’encodage est "'utf-8'".

   * On Unix, the encoding is the user’s preference according to the
     result of nl_langinfo(CODESET), or "None" if the
     "nl_langinfo(CODESET)" failed.

   * On Windows NT+, file names are Unicode natively, so no
     conversion is performed. "getfilesystemencoding()" still returns
     "'mbcs'", as this is the encoding that applications should use
     when they explicitly want to convert Unicode strings to byte
     strings that are equivalent when used as file names.

   * On Windows 9x, the encoding is "'mbcs'".

   Nouveau dans la version 2.3.

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()".

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.

   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.

   Nouveau dans la version 2.6.

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.

   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()".

   Nouveau dans la version 2.6.

sys.gettrace()

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

   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.

   Nouveau dans la version 2.6.

sys.getwindowsversion()

   Return a named tuple describing the Windows version currently
   running.  The named elements are *major*, *minor*, *build*,
   *platform*, *service_pack*, *service_pack_minor*,
   *service_pack_major*, *suite_mask*, and *product_type*.
   *service_pack* contains a string while all other values are
   integers. The components can also be accessed by name, so
   "sys.getwindowsversion()[0]" is equivalent to
   "sys.getwindowsversion().major". For compatibility with prior
   versions, only the first 5 elements are retrievable by indexing.

   *platform* may be one of the following values:

   +-------------------------------------------+---------------------------+
   | Constante                                 | Plateforme                |
   |===========================================|===========================|
   | "0 (VER_PLATFORM_WIN32s)"                 | Win32s on Windows 3.1     |
   +-------------------------------------------+---------------------------+
   | "1 (VER_PLATFORM_WIN32_WINDOWS)"          | Windows 95/98/ME          |
   +-------------------------------------------+---------------------------+
   | "2 (VER_PLATFORM_WIN32_NT)"               | Windows NT/2000/XP/x64    |
   +-------------------------------------------+---------------------------+
   | "3 (VER_PLATFORM_WIN32_CE)"               | Windows CE                |
   +-------------------------------------------+---------------------------+

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

   Cette fonction enveloppe la fonction Win32 "GetVersionEx()". Voir
   la documentation de Microsoft sur "OSVERSIONINFOEX()" pour plus
   d’informations sur ces champs.

   Disponibilité : Windows.

   Nouveau dans la version 2.3.

   Modifié dans la version 2.7: Changé en un *tuple* nommé, et ajout
   de *service_pack_minor*, *service_pack_major*, *suite_mask*, et
   *product_type*.

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

   This is called "hexversion" since it only really looks meaningful
   when viewed as the result of passing it to the built-in "hex()"
   function.  The "version_info" value may be used for a more human-
   friendly encoding of the same information.

   The "hexversion" is a 32-bit number with the following layout:

   +---------------------------+--------------------------------------------------+
   | Bits (ordre gros-         | Signification                                    |
   | boutiste)                 |                                                  |
   |===========================|==================================================|
   | "1-8"                     | "PY_MAJOR_VERSION"  (the "2" in "2.1.0a3")       |
   +---------------------------+--------------------------------------------------+
   | "9-16"                    | "PY_MINOR_VERSION"  (the "1" in "2.1.0a3")       |
   +---------------------------+--------------------------------------------------+
   | "17-24"                   | "PY_MICRO_VERSION"  (the "0" in "2.1.0a3")       |
   +---------------------------+--------------------------------------------------+
   | "25-28"                   | "PY_RELEASE_LEVEL"  ("0xA" for alpha, "0xB" for  |
   |                           | beta, "0xC" for release candidate and "0xF" for  |
   |                           | final)                                           |
   +---------------------------+--------------------------------------------------+
   | "29-32"                   | "PY_RELEASE_SERIAL"  (the "3" in "2.1.0a3", zero |
   |                           | for final releases)                              |
   +---------------------------+--------------------------------------------------+

   Thus "2.1.0a3" is hexversion "0x020100a3".

   Nouveau dans la version 1.5.2.

sys.long_info

   A struct sequence that holds information about Python’s internal
   representation of integers.  The attributes are read only.

   +---------------------------+------------------------------------------------+
   | Attribut                  | Explication                                    |
   |===========================|================================================|
   | "bits_per_digit"          | number of bits held in each digit.  Python     |
   |                           | integers are stored internally in base         |
   |                           | "2**long_info.bits_per_digit"                  |
   +---------------------------+------------------------------------------------+
   | "sizeof_digit"            | taille en octets du type C utilisé pour        |
   |                           | représenter un chiffre                         |
   +---------------------------+------------------------------------------------+

   Nouveau dans la version 2.7.

sys.last_type
sys.last_value
sys.last_traceback

   These three variables are not always defined; they are set when an
   exception is not handled and the interpreter prints an error
   message and a stack traceback. Their 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 chapter pdb — Le débogueur Python for
   more information.)

   The meaning of the variables is the same as that of the return
   values from "exc_info()" above.  (Since there is only one
   interactive thread, thread-safety is not a concern for these
   variables, unlike for "exc_type" etc.)

sys.maxint

   The largest positive integer supported by Python’s regular integer
   type.  This is at least 2**31-1.  The largest negative integer is
   "-maxint-1" — the asymmetry results from the use of 2’s complement
   binary arithmetic.

sys.maxsize

   The largest positive integer supported by the platform’s Py_ssize_t
   type, and thus the maximum size lists, strings, dicts, and many
   other containers can have.

sys.maxunicode

   An integer giving the largest supported code point for a Unicode
   character.  The value of this depends on the configuration option
   that specifies whether Unicode characters are stored as UCS-2 or
   UCS-4.

sys.meta_path

   A list of *finder* objects that have their "find_module()" methods
   called to see if one of the objects can find the module to be
   imported. The "find_module()" method is called at least with the
   absolute name of the module being imported. If the module to be
   imported is contained in package then the parent package’s
   "__path__" attribute is passed in as a second argument. The method
   returns "None" if the module cannot be found, else returns a
   *loader*.

   "sys.meta_path" is searched before any implicit default finders or
   "sys.path".

   See **PEP 302** for the original specification.

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. Note that removing a module from this
   dictionary is *not* the same as calling "reload()" on the
   corresponding module object.

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.

   Puisqu’il est initialisé au démarrage du programme, le premier
   élément de cette liste, "path[0]", est le dossier contenant le
   script qui a été utilisé pour invoquer l’interpréteur Python.  Si
   le dossier du script n’est pas disponible (typiquement, si
   l’interpréteur est invoqué interactivement ou si le script est lu à
   partir d’une entrée standard), "path[0]" sera une chaîne vide, qui
   indiquera à Python de chercher des modules dans le dossier actuel.
   Notez que le dossier du script est inséré *avant* les dossiers de
   "PYTHONPATH".

   A program is free to modify this list for its own purposes.

   Modifié dans la version 2.3: Unicode strings are no longer ignored.

   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

   A dictionary acting as a cache for *finder* objects. The keys are
   paths that have been passed to "sys.path_hooks" and the values are
   the finders that are found. If a path is a valid file system path
   but no explicit finder is found on "sys.path_hooks" then "None" is
   stored to represent the implicit default finder should be used. If
   the path is not an existing path then "imp.NullImporter" is set.

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

   For most Unix systems, this is the lowercased OS name as returned
   by "uname -s" with the first part of the version as returned by
   "uname -r" appended, e.g. "'sunos5'", *at the time when Python was
   built*.  Unless you want to test for a specific system version, it
   is therefore recommended to use the following idiom:

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

   Modifié dans la version 2.7.3: Since lots of code check for
   "sys.platform == 'linux2'", and there is no essential change
   between Linux 2.x and 3.x, "sys.platform" is always set to
   "'linux2'", even on Linux 3.x.  In Python 3.3 and later, the value
   will always be set to "'linux'", so it is recommended to always use
   the "startswith" idiom presented above.

   Pour les autres systèmes, les valeurs sont:

   +-----------------------+-----------------------------+
   | Système               | "platform" value            |
   |=======================|=============================|
   | Linux (2.x *and* 3.x) | "'linux2'"                  |
   +-----------------------+-----------------------------+
   | Windows               | "'win32'"                   |
   +-----------------------+-----------------------------+
   | Windows/Cygwin        | "'cygwin'"                  |
   +-----------------------+-----------------------------+
   | Mac OS X              | "'darwin'"                  |
   +-----------------------+-----------------------------+
   | OS/2                  | "'os2'"                     |
   +-----------------------+-----------------------------+
   | OS/2 EMX              | "'os2emx'"                  |
   +-----------------------+-----------------------------+
   | RiscOS                | "'riscos'"                  |
   +-----------------------+-----------------------------+
   | AtheOS                | "'atheos'"                  |
   +-----------------------+-----------------------------+

   Voir aussi: "os.name" a une granularité plus grossière.
     "os.uname()" donne des informations sur la version dépendantes du
     système.

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

sys.prefix

   A string giving the site-specific directory prefix where the
   platform independent Python files are installed; by default, this
   is the string "'/usr/local'".  This can be set at build time with
   the "--prefix" argument to the **configure** script.  The main
   collection of Python library modules is installed in the directory
   "*prefix*/lib/python*X.Y*" while the platform independent header
   files (all except "pyconfig.h") are stored in
   "*prefix*/include/python*X.Y*", where *X.Y* is the version number
   of Python, for example "2.7".

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

   Bool containing the status of the Python 3 warning flag. It’s
   "True" when Python is started with the -3 option.  (This should be
   considered read-only; setting it to a different value doesn’t have
   an effect on Python 3 warnings.)

   Nouveau dans la version 2.6.

sys.setcheckinterval(interval)

   Défini  l“« intervalle de vérification » de l’interpréteur. Ce
   nombre entier détermine la fréquence à laquelle l’interpréteur
   effectue des tâches périodiques tels que la commutation de fil
   d’exécution et la gestion de signaux.  La valeur par défaut est
   "100", ce qui signifie que le contrôle est effectué toutes les 100
   instructions virtuelles Python. L’augmenter peut améliorer les
   performances des programmes utilisant des fils d’exécution.  Le
   paramétrer à une valeur inférieure ou égale à zéro permet
   d’effectuer ces tâches à chaque instruction virtuelle, maximisant
   ainsi la réactivité mais aussi son surcoût.

sys.setdefaultencoding(name)

   Set the current default string encoding used by the Unicode
   implementation.  If *name* does not match any available encoding,
   "LookupError" is raised. This function is only intended to be used
   by the "site" module implementation and, where needed, by
   "sitecustomize".  Once used by the "site" module, it is removed
   from the "sys" module’s namespace.

   Nouveau dans la version 2.0.

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(dl.RTLD_NOW |
   dl.RTLD_GLOBAL)".  Symbolic names for the flag modules can be
   either found in the "dl" module, or in the "DLFCN" module. If
   "DLFCN" is not available, it can be generated from
   "/usr/include/dlfcn.h" using the **h2py** script. Availability:
   Unix.

   Nouveau dans la version 2.2.

sys.setprofile(profilefunc)

   Set the system’s profile function, which allows you to implement a
   Python source code profiler in Python.  See chapter The Python
   Profilers for more information on the Python profiler.  The
   system’s profile function is called similarly to the system’s trace
   function (see "settrace()"), but it is called with different
   events, for example it isn’t called for each executed line of code
   (only on call and return, but the return event is reported even
   when an exception has been set). The function is thread-specific,
   but there is no way for the profiler to know about context switches
   between threads, so it does not make sense to use this in the
   presence of multiple threads. Also, its return value is not used,
   so it can simply return "None".

   Profile functions should have three arguments: *frame*, *event*,
   and *arg*. *frame* is the current stack frame.  *event* is a
   string: "'call'", "'return'", "'c_call'", "'c_return'", or
   "'c_exception'". *arg* depends on the event type.

   Les événements ont la signification suivante :

   "'call'"
      A function is called (or some other code block entered).  The
      profile function is called; *arg* is "None".

   "'return'"
      A function (or other code block) is about to return.  The
      profile function is called; *arg* is the value that will be
      returned, or "None" if the event is caused by an exception being
      raised.

   "'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.

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.

   The highest possible limit is platform-dependent.  A user may need
   to set the limit higher when she has a program that requires deep
   recursion and a platform that supports a higher limit.  This should
   be done with care, because a too-high limit can lead to a crash.

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.

   Trace functions should have three arguments: *frame*, *event*, and
   *arg*. *frame* is the current stack frame.  *event* is a string:
   "'call'", "'line'", "'return'" or "'exception'".  *arg* depends on
   the event type.

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

   La fonction de traçage doit renvoyer une référence à elle-même (ou
   à une autre fonction de traçage pour un traçage ultérieur dans
   cette portée), ou "None" pour désactiver le traçage dans cette
   portée.

   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'"
      L’interpréteur est sur le point d’exécuter une nouvelle ligne de
      code ou de ré-exécuter la condition d’une boucle.  La fonction
      de traçage locale est appelée, *arg* vaut "None", et la valeur
      de retour donne la nouvelle fonction de traçage locale.  Voir
      "Objects/lnotab_notes.txt" pour une explication détaillée de ce
      mécanisme.

   "'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 *tuple* "(exception, valeur, traceback)",
      la valeur renvoyée spécifie la nouvelle fonction de traçage
      locale.

   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 plus d’informations sur les objets code et objets représentant
   une *frame* de la pile, consultez Hiérarchie des types standards.

   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.

sys.settscdump(on_flag)

   Activate dumping of VM measurements using the Pentium timestamp
   counter, if *on_flag* is true. Deactivate these dumps if *on_flag*
   is off. The function is available only if Python was compiled with
   "--with-tsc". To understand the output of this dump, read
   "Python/ceval.c" in the Python sources.

   Nouveau dans la version 2.4.

   **CPython implementation detail:** This function is intimately
   bound to CPython implementation details and thus not likely to be
   implemented elsewhere.

sys.stdin
sys.stdout
sys.stderr

   File objects corresponding to the interpreter’s standard input,
   output and error streams.  "stdin" is used for all interpreter
   input except for scripts but including calls to "input()" and
   "raw_input()".  "stdout" is used for the output of "print" and
   *expression* statements and for the prompts of "input()" and
   "raw_input()". The interpreter’s own prompts and (almost all of)
   its error messages go to "stderr".  "stdout" and "stderr" needn’t
   be built-in file objects: any object is acceptable as long as it
   has a "write()" method that takes a string argument.  (Changing
   these objects doesn’t affect the standard I/O streams of processes
   executed by "os.popen()", "os.system()" or the "exec*()" family of
   functions in the "os" module.)

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.

sys.subversion

   A triple (repo, branch, version) representing the Subversion
   information of the Python interpreter. *repo* is the name of the
   repository, "'CPython'". *branch* is a string of one of the forms
   "'trunk'", "'branches/name'" or "'tags/name'". *version* is the
   output of "svnversion", if the interpreter was built from a
   Subversion checkout; it contains the revision number (range) and
   possibly a trailing “M” if there were local modifications. If the
   tree was exported (or svnversion was not available), it is the
   revision of "Include/patchlevel.h" if the branch is a tag.
   Otherwise, it is "None".

   Nouveau dans la version 2.5.

   Note: Python is now developed using Git.  In recent Python 2.7
     bugfix releases, "subversion" therefore contains placeholder
     information.  It is removed in Python 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.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.

   Nouveau dans la version 2.3.

sys.version_info

   Un *tuple* contenant les cinq 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.

   Nouveau dans la version 2.0.

   Modifié dans la version 2.7: Added named component attributes

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

   Le numéro de version utilisé pour construire les clefs de registre
   sous Windows. Elle est stockée en tant que *string resource* 1000
   dans la DLL Python. Cette valeur équivaut typiquement aux trois
   premiers caractères de "version".  Elle est fournie par le module
   "sys" à titre d’information, et la modifier n’a aucun effet sur les
   clés de registre utilisées par Python. Disponibilité: Windows.

-[ Citations ]-

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