# `sys` --- System-specific parameters and functions

This module provides access to some variables used or maintained by the interpreter and to functions that interact strongly with the interpreter. It is always available. Unless explicitly noted otherwise, all variables are read-only.

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.

  Ajouté dans la 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).

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

  Ajouté dans la 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.

  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.

  Ajouté dans la version 3.8.

sys.base_exec_prefix

  Equivalent to `exec_prefix`, but referring to the base Python installation.

  When running under Virtual Environments, `exec_prefix` gets overwritten to the virtual environment prefix. `base_exec_prefix`, conversely, does not change, and always points to the base Python installation. Refer to Virtual Environments for more information.

  Ajouté dans la version 3.3.

sys.base_prefix

  Equivalent to `prefix`, but referring to the base Python installation.

  When running under virtual environment, `prefix` gets overwritten to the virtual environment prefix. `base_prefix`, conversely, does not change, and always points to the base Python installation. Refer to Virtual Environments for more information.

  Ajouté dans la 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é.

  Obsolète depuis la version 3.13: Use the more general `_clear_internal_caches()` function instead.

sys._clear_internal_caches()

  Clear all internal performance-related caches. Use this function only to release unnecessary references and memory blocks when hunting for leaks.

  Ajouté dans la version 3.13.

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

  Ajouté dans la 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.

  Ajouté dans la version 3.3.

  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.

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

  Ajouté dans la 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`.

  Ajouté dans la 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` lorsqu'une exception non interceptée se produit. Si aucun point d'entrée n'a été défini, `hook` peut être `None`. Si n'importe quel point d'entrée lève une exception dérivée de `RuntimeError`, l'appel au point d'entrée sera supprimé. Autrement, l'exception du point d'entrée d'audit sera reporté comme non levable (unraisable en anglais) et `sys.excepthook` sera appelé.

  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.

  Ajouté dans la version 3.7: `__breakpointhook__`

  Ajouté dans la 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`.

  Ajouté dans la 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/pythonX.Y/config`, et les modules sous forme de bibliothèques partagées sont installés dans `exec_prefix/lib/pythonX.Y/lib-dynload`, où X.Y est le numéro de version de Python, par exemple `3.2`.

  Note

  If a virtual environment is in effect, this `exec_prefix` will point to the virtual environment. The value for the Python installation will still be available, via `base_exec_prefix`. Refer to Virtual Environments for more information.

  Modifié dans la version 3.14: When running under a virtual environment, `prefix` and `exec_prefix` are now set to the virtual environment prefix by the path initialization, instead of `site`. This means that `prefix` and `exec_prefix` always point to the virtual environment, even when `site` is disabled (`-S`).

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

  The named tuple flags exposes the status of command line flags. Flags should only be accessed only by name and not by index. The attributes are read only.

  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`
  flags.gil | `-X gil` and `PYTHON_GIL`
  flags.thread_inherit_context | `-X thread_inherit_context` and `PYTHON_THREAD_INHERIT_CONTEXT`
  flags.context_aware_warnings | `-X context_aware_warnings` and `PYTHON_CONTEXT_AWARE_WARNINGS`

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

  Ajouté dans la 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.

  Modifié dans la version 3.13: Added the `gil` attribute.

  Modifié dans la version 3.14: Added the `thread_inherit_context` attribute.

  Modifié dans la version 3.14: Added the `context_aware_warnings` 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.

  Ajouté dans la version 3.1.

sys.getallocatedblocks()

  Return the number of memory blocks currently allocated by the interpreter, regardless of their size. This function is mainly useful for tracking and debugging memory leaks. Because of the interpreter's internal caches, the result can vary from call to call; you may have to call `_clear_internal_caches()` and `gc.collect()` to get more predictable results.

  If a Python build or implementation cannot reasonably compute this information, `getallocatedblocks()` is allowed to return 0 instead.

  Ajouté dans la version 3.4.

sys.getunicodeinternedsize()

  Return the number of unicode objects that have been interned.

  Ajouté dans la version 3.12.

sys.getandroidapilevel()

  Return the build-time API level of Android as an integer. This represents the minimum version of Android this build of Python can run on. For runtime version information, see `platform.android_ver()`.

  Availability: Android.

  Ajouté dans la version 3.7.

sys.getdefaultencoding()

  Return `'utf-8'`. This is the name of the default string encoding, used in methods like `str.encode()`.

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

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

  L'encodage du système de fichiers et gestionnaire d'erreurs associé sont configurés au démarrage de Python par la fonction `PyConfig_Read()` : regardez `filesystem_encoding` et `filesystem_errors` dans les membres de `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.

  L'encodage du système de fichiers et gestionnaire d'erreurs associé sont configurés au démarrage de Python par la fonction `PyConfig_Read()` : regardez `filesystem_encoding` et `filesystem_errors` dans les membres de `PyConfig`.

  Ajouté dans la 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()`.

  Ajouté dans la 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.

  Particularité de l'implémentation CPython : Immortal objects with a large reference count can be identified via `_is_immortal()`.

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

  Return the interpreter's "thread switch interval" in seconds; see `setswitchinterval()`.

  Ajouté dans la 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`.

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

  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.

  Ajouté dans la version 3.12.

sys.getobjects(limit[, type])

  This function only exists if CPython was built using the specialized configure option `--with-trace-refs`. It is intended only for debugging garbage-collection issues.

  Return a list of up to limit dynamically allocated Python objects. If type is given, only objects of that exact type (not subtypes) are included.

  Objects from the list are not safe to use. Specifically, the result will include objects from all interpreters that share their object allocator state (that is, ones created with `PyInterpreterConfig.use_main_obmalloc` set to 1 or using `Py_NewInterpreter()`, and the main interpreter). Mixing objects from different interpreters may lead to crashes or other unexpected behavior.

  Particularité de l'implémentation CPython : This function should be used for specialized purposes only. It is not guaranteed to exist in all implementations of Python.

  Modifié dans la version 3.14: The result may include objects from other interpreters.

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

  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.

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

  Ajouté dans la 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()`.

  Ajouté dans la 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

  Ajouté dans la 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.

  supports_isolated_interpreters is a boolean value, whether this implementation supports multiple isolated interpreters. It is `True` for CPython on most platforms. Platforms with this support implement the low-level `_interpreters` module.

  Voir aussi

  PEP 684, PEP 734, and `concurrent.interpreters`.

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

  Ajouté dans la version 3.3.

  Modifié dans la version 3.14: Added `supports_isolated_interpreters` field.

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

  Ajouté dans la 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 l'objet de point d'entrée comme argument lorsqu'il est appelé au démarrage.

  Ajouté dans la 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.

  Interned strings are not immortal; you must keep a reference to the return value of `intern()` around to benefit from it.

sys._is_gil_enabled()

  Return `True` if the GIL is enabled and `False` if it is disabled.

  Ajouté dans la version 3.13.

  Particularité de l'implémentation CPython : It is not guaranteed to exist in all implementations of Python.

sys.is_finalizing()

  Return `True` if the main Python interpreter is shutting down. Return `False` otherwise.

  See also the `PythonFinalizationError` exception.

  Ajouté dans la version 3.5.

sys._jit

  Utilities for observing just-in-time compilation.

  Particularité de l'implémentation CPython : JIT compilation is an experimental implementation detail of CPython. `sys._jit` is not guaranteed to exist or behave the same way in all Python implementations, versions, or build configurations.

  Ajouté dans la version 3.14.

  _jit.is_available()

    Return `True` if the current Python executable supports JIT compilation, and `False` otherwise. This can be controlled by building CPython with the `--experimental-jit` option on Windows, and the `--enable-experimental-jit` option on all other platforms.

  _jit.is_enabled()

    Return `True` if JIT compilation is enabled for the current Python process (implies `sys._jit.is_available()`), and `False` otherwise. If JIT compilation is available, this can be controlled by setting the `PYTHON_JIT` environment variable to `0` (disabled) or `1` (enabled) at interpreter startup.

  _jit.is_active()

    Return `True` if the topmost Python frame is currently executing JIT code (implies `sys._jit.is_enabled()`), and `False` otherwise.

    Note

    This function is intended for testing and debugging the JIT itself. It should be avoided for any other purpose.

    Note

    Due to the nature of tracing JIT compilers, repeated calls to this function may give surprising results. For example, branching on its return value will likely lead to unexpected behavior (if doing so causes JIT code to be entered or exited):

        >>> for warmup in range(BIG_NUMBER):
        ...     # This line is "hot", and is eventually JIT-compiled:
        ...     if sys._jit.is_active():
        ...         # This line is "cold", and is run in the interpreter:
        ...         assert sys._jit.is_active()
        ...
        Traceback (most recent call last):
          File "<stdin>", line 5, in <module>
            assert sys._jit.is_active()
                   ~~~~~~~~~~~~~~~~~~^^
        AssertionError

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

  Ajouté dans la version 3.12.

sys._is_immortal(op)

  Return `True` if the given object is immortal, `False` otherwise.

  Note

  Objects that are immortal (and thus return `True` upon being passed to this function) are not guaranteed to be immortal in future versions, and vice versa for mortal objects.

  Ajouté dans la version 3.14.

  Particularité de l'implémentation CPython : This function should be used for specialized purposes only. It is not guaranteed to exist in all implementations of Python.

sys._is_interned(string)

  Return `True` if the given string is "interned", `False` otherwise.

  Ajouté dans la version 3.13.

  Particularité de l'implémentation CPython : It is not guaranteed to exist in all implementations of Python.

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

  Ajouté dans la 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

  A string containing a platform identifier. Known values are:

  Système | Valeur pour `plateforme`
  --- | ---
  AIX | `'aix'`
  Android | `'android'`
  Emscripten | `'emscripten'`
  FreeBSD | `'freebsd'`
  iOS | `'ios'`
  Linux | `'linux'`
  macOS | `'darwin'`
  Windows | `'win32'`
  Windows/Cygwin | `'cygwin'`
  WASI | `'wasi'`

  On Unix systems not listed in the table, the value 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('sunos'):
          # SunOS-specific code here...

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

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

  Modifié dans la version 3.13: On Android, `sys.platform` now returns `'android'` rather than `'linux'`.

  Modifié dans la version 3.14: On FreeBSD, `sys.platform` doesn't contain the major version anymore. It is always `'freebsd'`, instead of `'freebsd13'` or `'freebsd14'`.

  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

  Ajouté dans la 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

  If a virtual environment is in effect, this `prefix` will point to the virtual environment. The value for the Python installation will still be available, via `base_prefix`. Refer to Virtual Environments for more information.

  Modifié dans la version 3.14: When running under a virtual environment, `prefix` and `exec_prefix` are now set to the virtual environment prefix by the path initialization, instead of `site`. This means that `prefix` and `exec_prefix` always point to the virtual environment, even when `site` is disabled (`-S`).

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

  Availability: 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()`.

  Ajouté dans la 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.

  Ajouté dans la 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()`.

  Trace functions should have three arguments: frame, event, and arg. frame is the current stack frame. event is a string: `'call'`, `'line'`, `'return'`, `'exception'` or `'opcode'`. 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é.

  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.

  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

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.

  Ajouté dans la 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`.

  To enable, pass a depth value greater than zero; this sets the number of frames whose information will be captured. To disable, set depth to zero.

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

  Ajouté dans la 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"`.

  Stack trampolines cannot be activated if the JIT is active.

  Availability: Linux.

  Ajouté dans la 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.

  Ajouté dans la version 3.12.

sys.is_stack_trampoline_active()

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

  Availability: Linux.

  Ajouté dans la version 3.12.

sys.remote_exec(pid, script)

  Executes script, a file containing Python code in the remote process with the given pid.

  This function returns immediately, and the code will be executed by the target process's main thread at the next available opportunity, similarly to how signals are handled. There is no interface to determine when the code has been executed. The caller is responsible for making sure that the file still exists whenever the remote process tries to read it and that it hasn't been overwritten.

  The remote process must be running a CPython interpreter of the same major and minor version as the local process. If either the local or remote interpreter is pre-release (alpha, beta, or release candidate) then the local and remote interpreters must be the same exact version.

  When the code is executed in the remote process, an auditing event `sys.remote_exec` is raised with the pid and the path to the script file. This event is raised in the process that called `sys.remote_exec()`.

  When the script is executed in the remote process, an auditing event `cpython.remote_debugger_script` is raised with the path in the remote process. This event is raised in the remote process, not the one that called `sys.remote_exec()`.

  Availability: Unix, Windows.

  Ajouté dans la version 3.14.

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

  Availability: Windows.

  Note

  Changing the filesystem encoding after Python startup is risky because the old fsencoding or paths encoded by the old fsencoding may be cached somewhere. Use `PYTHONLEGACYWINDOWSFSENCODING` instead.

  Ajouté dans la version 3.6: Voir la PEP 529 pour plus d'informations.

  Deprecated since version 3.13, will be removed in version 3.16: Use `PYTHONLEGACYWINDOWSFSENCODING` instead.

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.

  Ajouté dans la 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.

  Ajouté dans la 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`.

  Ajouté dans la 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

  The C API version, equivalent to the C macro `PYTHON_API_VERSION`. Defined for backwards compatibility.

  Currently, this constant is not updated in new Python versions, and is not useful for versioning. This may change in the future.

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.

  Availability: 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}

  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.

  Ajouté dans la 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.