This document is for an old version of Python that is no longer supported. You should upgrade and read the Python documentation for the current stable release.

# 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/pythonX.Y/config`, and shared library modules are installed in `exec_prefix/lib/pythonX.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-boutiste) | Signification
  --- | ---
  `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/pythonX.Y` while the platform independent header files (all except `pyconfig.h`) are stored in `prefix/include/pythonX.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.