# 1. Ligne de commande et environnement

L’interpréteur CPython analyse la ligne de commande et l’environnement à la recherche de différents paramètres.

CPython implementation detail: Le format des lignes de commande utilisé par d’autres implémentations peut s’avérer différent. Voir Autres implémentations pour plus d’informations.

## 1.1. Ligne de commande

Quand vous invoquez Python, vous pouvez spécifier n’importe laquelle de ces options :

    python [-bBdEhiIOqsSuvVWx?] [-c command | -m module-name | script | - ] [args]

Le cas d’utilisation le plus courant est, bien entendu, la simple invocation d’un script :

    python myscript.py

### 1.1.1. Options de l’interface

L’interface de l’interpréteur ressemble à celle du shell UNIX mais fournit quelques méthodes d’invocation supplémentaires :

- Quand l’interpréteur est appelé avec l’entrée standard connectée à un périphérique tty, il lit les lignes de commande et les exécute jusqu’à ce qu’un caractère EOF (caractère fin de fichier, que vous pouvez produire avec `Ctrl-D` sous UNIX ou `Ctrl-Z, Enter` sous Windows) soit lu.

- Quand l’interpréteur est appelé avec un argument correspondant à un nom de fichier ou avec un fichier comme entrée standard, il lit et exécute le script contenu dans ce fichier.

- Quand l’interpréteur est appelé avec un argument correspondant à un répertoire, il lit et exécute un script d’un certain nom dans ce répertoire.

- Quand l’interpréteur est appelé avec l’option `-c commande`, il exécute la ou les instructions Python données comme commande. Ici commande peut contenir plusieurs instructions séparées par des fins de ligne. Les blancs en début de ligne ne sont pas ignorés dans les instructions Python !

- Quand l’interpréteur est appelé avec l’option `-m nom-de-module`, le module donné est recherché dans le chemin des modules Python et est exécuté en tant que script.

En mode non-interactif, toute l’entrée est analysée avant d’être exécutée.

Une option d’interface termine la liste des options consommées par l’interpréteur ; tous les arguments atterrissent dans `sys.argv` — notez que le premier élément, à l’indice zéro (`sys.argv|0]`), est une chaîne de caractères indiquant la source du programme.

`-c``<command>`

  Exécute le code Python dans command. command peut être une ou plusieurs instructions, séparées par des fins de ligne, dont les espaces en début de ligne sont significatives, comme dans le code d’un module.

  Si cette option est donnée, le premier élément de `sys.argv` est `"-c"` et le répertoire courant est ajouté au début de `sys.path` (permettant aux modules de ce répertoire d’être importés comme des modules de premier niveau).

`-m``<module-name>`

  Parcourt `sys.path` à la recherche du module donné et exécute son contenu en tant que module `__main__`.

  L’argument étant un nom de module, vous ne devez pas fournir d’extension de fichier (`.py`). Le nom du module doit être un nom de module Python valide, absolu, mais l’implémentation peut ne pas l’imposer (par exemple, l’utilisation d’un trait d’union peut être autorisée).

  Les noms de paquets sont aussi autorisés (ainsi que les paquets-espace de nommage, namespace packages en anglais). Quand un nom de paquet est donné à la place d’un simple module, l’interpréteur exécute `<pkg>.__main__` comme module principal. Ce comportement est délibérément identique au traitement d’un dossier ou d’un fichier zip donné en argument à l’interpréteur comme script.

  Note

  Cette option ne peut pas être utilisée avec les modules natifs et les modules d’extension écrits en C, étant donné qu’ils ne possèdent pas de fichiers modules en Python. Cependant, elle peut toujours être utilisée pour les modules pré-compilés, même si le fichier source original n’est pas disponible.

  Si cette option est donnée, le premier élément de `sys.argv` est le chemin complet d’accès au fichier du module (pendant que le fichier est recherché, le premier élément est mis à `"-m"`). Comme avec l’option `-c`, le dossier courant est ajouté au début de `sys.path`.

  De nombreux modules de la bibliothèque standard contiennent du code qui est invoqué quand ils sont exécutés comme scripts. Un exemple est le module `timeit` :

      python -mtimeit -s 'setup here' 'benchmarked code here'
      python -mtimeit -h # for details

  Voir aussi

  `runpy.run_module()`

    Fonctionnalité équivalente directement disponible en code Python

  PEP 338 – Exécuter des modules en tant que scripts

  Modifié dans la version 3.1: Fournir le nom d’un paquet pour exécuter un sous-module `__main__`.

  Modifié dans la version 3.4: les paquets-espaces de nommage sont aussi gérés

`-`

  Lit les commandes depuis l’entrée standard (`sys.stdin`). Si l’entrée standard est un terminal, l’option `-i` est activée implicitement.

  Si cette option est donnée, le premier élément de `sys.argv` est `"-"` et le dossier courant est ajouté au début de `sys.path`.

`<script>`

  Exécute le code Python contenu dans script, qui doit être un chemin d’accès (absolu ou relatif) à un fichier, faisant référence à un fichier Python, à un répertoire contenant un fichier `__main__.py` ou à un fichier zip contenant un fichier `__main__.py`.

  Si cette option est donnée, le premier élément de `sys.argv` est le nom du script tel que donné sur la ligne de commande.

  Si le nom du script se réfère directement à un fichier Python, le répertoire contenant ce fichier est ajouté au début de `sys.path` et le fichier est exécuté en tant que module `__main__`.

  Si le nom du script fait référence à un dossier ou à un fichier zip, le nom du script est ajouté au début de `sys.path` et le fichier `__main__.py` à cet endroit est exécuté en tant que module `__main__`.

  Voir aussi

  `runpy.run_path()`

    Fonctionnalité équivalente directement disponible en code Python

Si aucune option d’interface n’est donnée, l’option `-i` est activée implicitement, `sys.argv[0]` est une chaine vide (`""`) et le dossier courant est ajouté au début de `sys.path`. Aussi, la complétion par tabulation et l’édition de l’historique sont automatiquement activés, s’ils sont disponibles sur votre système (voir Readline configuration).

Voir aussi

Lancement de l’interpréteur

Modifié dans la version 3.4: Activation automatique de la complétion par tabulation et édition de l’historique.

### 1.1.2. Options génériques

`-?```
`-h```
`--help```

  Affiche une brève description de toutes les options de la ligne de commande.

`-V```
`--version```

  Affiche la version de Python et termine. Par exemple :

      Python 3.6.0b2+

  Lorsque l’option est doublée, affiche davantage d’informations sur la manière dont Python a été compilé, comme :

      Python 3.6.0b2+ (3.6:84a3c5003510+, Oct 26 2016, 02:33:55)
      [GCC 6.2.0 20161005]

  Nouveau dans la version 3.6: L’option `-VV`.

### 1.1.3. Options diverses

`-b```

  Affiche un avertissement (warning en anglais) lors d’une comparaison d’un objet de type `bytes` ou `bytearray` avec un objet de type `str` ou un objet de type `bytes` avec un objet de type `int`. Lève une erreur si cette option est doublée (`-bb`).

  Modifié dans la version 3.5: Concerne les comparaisons de `bytes` avec `int`.

`-B```

  S’il est donné, Python ne tente pas d’écrire de fichier `.pyc` ou `.pyo` à l’importation des modules sources. Voir aussi `PYTHONDONTWRITEBYTECODE`.

`-d```

  Active la sortie de l’analyseur en mode débogage (pour les experts uniquement, en fonction des options de compilation). Voir aussi `PYTHONDEBUG`.

`-E```

  Ignore toutes les variables d’environnement `PYTHON*` qui pourraient être définies. Par exemple, `PYTHONPATH` et `PYTHONHOME`.

`-i```

  Quand un script est passé comme premier argument ou que l’option `-c` est utilisée, entre en mode interactif après avoir exécuté le script ou la commande, même lorsque `sys.stdin` ne semble pas être un terminal. Le fichier `PYTHONSTARTUP` n’est pas lu.

  Cela peut être utile pour examiner les variables globales ou une trace de la pile lorsque le script lève une exception. Voir aussi `PYTHONINSPECT`.

`-I```

  Lance Python en mode isolé. Cela implique aussi -E et -s. En mode isolé, `sys.path` ne contient ni le répertoire du script ni le répertoire site-packages de l’utilisateur. Toutes les variables d’environnement `PYTHON*` sont aussi ignorées. Davantage de restrictions peuvent être imposées pour éviter que l’utilisateur n’injecte du code malicieux.

  Nouveau dans la version 3.4.

`-O```

  Enlève les instructions assert et tout le code qui dépend de la valeur de `__debug__`. Ajoute `.opt-1` au nom de fichier du code intermédiaire (bytecode), avant l’extension `.pyc` (voir la PEP 488). Voir aussi `PYTHONOPTIMIZE`.

  Modifié dans la version 3.5: Modifie les noms de fichiers `.pyc` suivant la PEP 488.

`-OO```

  Agit comme `-O` et ignore aussi les docstrings. Ajoute `.opt-2` au nom de fichier du code intermédiaire (bytecode), avant l’extension `.pyc` (voir la PEP 488).

  Modifié dans la version 3.5: Modifie les noms de fichiers `.pyc` suivant la PEP 488.

`-q```

  N’affiche pas le copyright et la version, même en mode interactif.

  Nouveau dans la version 3.2.

`-R```

  Conservé pour compatibilité ascendante. Sur Python 3.3 ou supérieur, la randomisation des empreintes (hash en anglais) est activée par défaut.

  Sur les versions précédentes de Python, cette option activait la randomisation des empreintes de manière à ce que les `__hash__()` de chaînes, bytes et `datetime` soient « salés » avec une valeur aléatoire non prévisible. Bien que ce sel soit constant durant le déroulement d’un processus Python, il n’est pas prévisible pour des invocations répétées de code Python.

  L’imprévisibilité des empreintes a pour objectif de se protéger contre les dénis de service qui utiliseraient des valeurs d’entrée judicieusement choisies afin de forcer la construction des dictionnaires dans le pire cas, c’est-à-dire avec une complexité en O(n2). Voir http://www.ocert.org/advisories/ocert-2011-003.html pour obtenir les détails.

  `PYTHONHASHSEED` vous permet de définir vous-même la valeur du sel pour l’algorithme de calcul des empreintes.

  Nouveau dans la version 3.2.3.

`-s```

  N’ajoute pas le répertoire utilisateur `site-packages` à `sys.path`.

  Voir aussi

  PEP 370 – Répertoire site-packages propre à l’utilisateur

`-S```

  Désactive l’importation du module `site` et les modifications locales de `sys.path` qu’il implique. Désactive aussi ces manipulations si `site` est importé explicitement plus tard (appelez `site.main()` si vous voulez les déclencher).

`-u```

  Désactive les mémoires tampons de la couche binaire des flux de la sortie standard (stdout) et de la sortie d’erreurs (stderr) (ils restent accessibles via leur attribut `buffer`). La couche d’entrée-sortie est mise en tampon ligne par ligne lors de l’écriture sur la console, ou par blocs si elle est redirigée sur un fichier non-interactif.

  Voir aussi `PYTHONUNBUFFERED`.

`-v```

  Affiche un message chaque fois qu’un module est initialisé, montrant l’emplacement (nom du fichier ou module natif) à partir duquel il est chargé. Lorsque l’option est doublée (`-vv`), affiche un message pour chaque fichier vérifié lors de la recherche du module. Fournit aussi des informations sur le nettoyage des modules à la fin. Voir aussi `PYTHONVERBOSE`.

`-W` `arg`

  Contrôle des avertissements. Le mécanisme d’avertissement de Python, par défaut, affiche les messages d’avertissement sur `sys.stderr`. Un message d’avertissement type est de la forme suivante :

      file:line: category: message

  Par défaut, chaque avertissement est affiché une seule fois pour chaque ligne de source où il se trouve. Cette option définit à quelle fréquence afficher ces avertissements.

  L’option `-W` peut être répétée ; lorsqu’un avertissement correspond à plus d’une option, l’action associée à la dernière correspondance est effectuée. Les options `-W` invalides sont ignorées (cependant, un message d’avertissement est affiché sur les options invalides au moment où le premier avertissement est généré).

  Les avertissements peuvent aussi être contrôlés dans le programme Python en utilisant le module `warnings`.

  La forme la plus simple de l’argument est l’une des chaînes d’actions suivantes (ou une abréviation unique) :

  `ignore`

    Ignore tous les avertissements.

  `default`

    Demande explicitement le comportement par défaut (affiche chaque avertissement une fois par ligne de code source).

  `all`

    Affiche un avertissement à chaque fois qu’il se produit (ce qui peut générer beaucoup de messages si l’avertissement est déclenché à plusieurs reprises, comme à l’intérieur d’une boucle).

  `module`

    Affiche chaque avertissement uniquement la première fois qu’il apparaît dans chaque module.

  `once`

    Affiche chaque avertissement uniquement la première fois qu’il apparaît dans le programme.

  `error`

    Déclenche une exception au lieu d’afficher un message d’avertissement.

  La forme complète de l’argument est :

      action:message:category:module:line

  Ici, action est tel qu’expliqué ci-dessus, mais s’applique uniquement aux messages qui correspondent aux champs restants. Les champs vides correspondent à toutes les valeurs ; les champs vides de fin peuvent être omis. Le champ message correspond au début du message d’avertissement affiché, cette expression est insensible à la casse. Le champ category correspond à la catégorie d’avertissement. Ce nom doit être un nom complet de classe ; La règle s’applique à tous les messages d’alertes construits avec une classe qui hérite de celle spécifiée. Le nom de la classe complète doit être donnée. Le champ module correspond au nom (pleinement qualifié) du module, cette correspondance est sensible à la casse. Le champ line correspond au numéro de ligne, où zéro correspond à n’importe quel numéro de ligne et correspond donc à l’option par défaut.

  Voir aussi

  `warnings` – le module qui gère les avertissements.

  PEP 230 – Gestion des alertes

  `PYTHONWARNINGS`

`-x```

  Saute la première ligne du code source, autorisant ainsi les directives de type `#!cmd` non conformes au standard Unix. L’objectif est de proposer une astuce spécifique pour le DOS.

`-X```

  Réservée pour les options spécifiques aux différentes implémentations. CPython reconnaît actuellement les valeurs suivantes :

  - `-X faulthandler` pour activer `faulthandler` ;

  - `-X showrefcount` pour afficher le compteur des références et le nombre de blocs mémoire utilisés lorsque le programme se termine ou après chaque entrée de l’interpréteur interactif. Ceci ne fonctionne que sur les versions compilées en mode débogage.

  - `-X tracemalloc` pour lancer le suivi des allocations mémoire par Python en utilisant le module `tracemalloc`. Par défaut, seul l’appel (la frame en anglais) le plus récent est stocké dans la trace de la pile d’appels. Utilisez `-X tracemalloc=NFRAME` pour lancer le suivi avec une limite des traces à NFRAME appels. Voir `tracemalloc.start()` pour plus d’informations.

  - `-X showalloccount` pour afficher à la fin de l’exécution du programme le total des objets alloués pour chaque type. Ceci ne fonctionne que si Python a été compilé avec l’option `COUNT_ALLOCS`.

  Il est aussi possible de passer des valeurs arbitraires et de les récupérer par le dictionnaire `sys._xoptions`.

  Modifié dans la version 3.2: L’option `-X` a été ajoutée.

  Nouveau dans la version 3.3: L’option `-X faulthandler`.

  Nouveau dans la version 3.4: Les options `-X showrefcount` et `-X tracemalloc` .

  Nouveau dans la version 3.6: L’option `-X showalloccount`.

### 1.1.4. Options à ne pas utiliser

`-J```

  Utilisation réservée à Jython.

## 1.2. Variables d’environnement

Les variables d’environnement suivantes modifient le comportement de Python. Elles sont analysées avant les options de la ligne de commande, autres que -E ou -I. Il est d’usage que les options de la ligne de commande prennent le pas sur les variables d’environnement en cas de conflit.

`PYTHONHOME`

  Modifie l’emplacement des bibliothèques standards de Python. Par défaut, les bibliothèques sont recherchées dans `préfixe/lib/pythonversion` et `préfixe_exec/lib/pythonversion` où `préfixe` et `préfixe_exec` sont des répertoires qui dépendent de l’installation (leur valeur par défaut étant `/usr/local`).

  Quand `PYTHONHOME` est défini à un simple répertoire, sa valeur remplace à la fois `préfixe` et `préfixe_exec`. Pour spécifier des valeurs différentes à ces variables, définissez `PYTHONHOME` à `préfixe:préfixe_exec`.

`PYTHONPATH`

  Augmente le chemin de recherche par défaut des fichiers de modules. Le format est le même que pour `PATH` du shell : un ou plusieurs chemins de répertoires séparés par `os.pathsep` (par exemple, le caractère deux-points sous Unix et point-virgule sous Windows). Les répertoires qui n’existent pas sont ignorés silencieusement.

  En plus des répertoires normaux, des entrées individuelles de `PYTHONPATH` peuvent faire référence à des fichiers zip contenant des modules en pur Python (soit sous forme de code source, soit sous forme compilée). Les modules d’extensions ne peuvent pas être importés à partir de fichiers zip.

  Le chemin de recherche par défaut dépend de l’installation mais commence généralement par `préfixe/lib/pythonversion` (voir `PYTHONHOME` ci-dessus). Il est toujours ajouté à `PYTHONPATH`.

  Comme indiqué ci-dessus dans Options de l’interface, un répertoire supplémentaire est inséré dans le chemin de recherche devant `PYTHONPATH`. Le chemin de recherche peut être manipulé depuis un programme Python avec la variable `sys.path`.

`PYTHONSTARTUP`

  S’il s’agit d’un nom de fichier accessible en lecture, les commandes Python de ce fichier sont exécutées avant que la première invite ne soit affichée en mode interactif. Le fichier est exécuté dans le même espace de nommage que les commandes interactives, de manière à ce que les objets définis ou importés puissent être utilisés sans qualificatif dans la session interactive. Vous pouvez aussi changer les invites `sys.ps1` et `sys.ps2` ainsi que le point d’entrée (hook en anglais) `sys.__interactivehook__` dans ce fichier.

`PYTHONOPTIMIZE`

  Si elle est définie à une chaîne non vide, c’est équivalent à spécifier l’option `-O`. Si elle est définie à un entier, c’est équivalent à spécifier l’option `-O` plusieurs fois.

`PYTHONDEBUG`

  Si elle est définie à une chaîne non vide, c’est équivalent à spécifier l’option `-d`. Si elle est définie à un entier, c’est équivalent à spécifier l’option `-d` plusieurs fois.

`PYTHONINSPECT`

  Si elle est définie à une chaîne non vide, c’est équivalent à spécifier l’option `-i`.

  Cette variable peut aussi être modifiée par du code Python en utilisant `os.environ` pour forcer le mode introspectif à la fin du programme.

`PYTHONUNBUFFERED`

  Si elle est définie à une chaîne non vide, c’est équivalent à spécifier l’option `-u`.

`PYTHONVERBOSE`

  Si elle est définie à une chaîne non vide, c’est équivalent à spécifier l’option `-v`. Si elle est définie à un entier, c’est équivalent à spécifier l’option `-v` plusieurs fois.

`PYTHONCASEOK`

  Si elle est définie, Python ignore la casse dans les instructions `import`. Ceci ne fonctionne que sous Windows et OS X.

`PYTHONDONTWRITEBYTECODE`

  Si elle est définie et n’est pas une chaîne vide, Python n’écrit pas de fichier `.pyc` à l’importation des modules sources. C’est équivalent à spécifier l’option `-B`.

`PYTHONHASHSEED`

  Si cette variable n’est pas définie ou définie à `random`, une valeur aléatoire est utilisée pour saler les empreintes des objets chaines, bytes et `datetime`.

  Si `PYTHONHASHSEED` est définie à une valeur entière, elle est utilisée comme valeur de salage pour générer les empreintes des types utilisant l’imprévisibilité du hachage.

  L’objectif est d’avoir des empreintes reproductibles, pour des tests de l’interpréteur lui-même ou pour qu’un groupe de processus Python puisse partager des empreintes.

  Le nombre entier doit être écrit en base 10 et être compris entre 0 et 4 294 967 295. Spécifier la valeur 0 désactive l’imprévisibilité des empreintes.

  Nouveau dans la version 3.2.3.

`PYTHONIOENCODING`

  Si la variable est définie sous la forme `nom_encodage:gestionnaire_erreur` avant le lancement de l’interpréteur, cela prend le pas sur l’encodage utilisé pour l’entrée standard, la sortie standard ou la sortie d’erreur. `nom_encodage` et `:gestionnaire_erreur` sont facultatifs tous les deux et possèdent la même signification que dans `str.encode()`.

  Pour la sortie d’erreur, la partie `:gestionnaire_erreur` est ignorée : le gestionnaire est toujours `'backslashreplace'`.

  Modifié dans la version 3.4: La partie `nom_encodage` est maintenant optionnelle.

  Modifié dans la version 3.6: Sous Windows, l’encodage spécifié par cette variable est ignoré pour le tampon des consoles interactives à moins que `PYTHONLEGACYWINDOWSSTDIO` ne soit aussi spécifié. Les fichiers et tubes (pipes en anglais) redirigés vers les flux standards ne sont pas concernés.

`PYTHONNOUSERSITE`

  Si elle est définie, Python n’ajoute pas le répertoire `site-packages propre à l'utilisateur` à `sys.path`.

  Voir aussi

  PEP 370 – Répertoire site-packages propre à l’utilisateur

`PYTHONUSERBASE`

  Définit le répertoire `base utilisateur`. Celui-ci est utilisé pour déterminer le chemin du `répertoire site-packages propre à l'utilisateur` et des schémas d’installation de Distutils pour `python setup.py install --user`.

  Voir aussi

  PEP 370 – Répertoire site-packages propre à l’utilisateur

`PYTHONEXECUTABLE`

  Si cette variable d’environnement est définie, `sys.argv[0]` est définie à cette valeur au lieu de la valeur fournie par l’exécutable. Ne fonctionne que sur Mac OS X.

`PYTHONWARNINGS`

  C’est équivalent à spécifier l’option `-W`. Si la valeur est une chaîne séparée par des virgules, c’est équivalent à spécifier l’option `-W` plusieurs fois.

`PYTHONFAULTHANDLER`

  Si elle est définie à une chaîne non vide, `faulthandler.enable()` est appelée au démarrage : ceci installe un gestionnaire pour les signaux `SIGSEGV`, `SIGFPE`, `SIGABRT`, `SIGBUS` et `SIGILL` afin de générer une trace de la pile d’appels. C’est équivalent à spécifier l’option `-X` `faulthandler`.

  Nouveau dans la version 3.3.

`PYTHONTRACEMALLOC`

  Si elle est définie à une chaîne non vide, lance le suivi des allocations mémoire par Python en utilisant le module `tracemalloc`. La valeur de la variable définit le nombre maximum d’appels (les frames en anglais) stockés dans la trace de pile d’appels. Par exemple, `PYTHONTRACEMALLOC=1` ne stocke que l’appel le plus récent. Voir `tracemalloc.start()` pour davantage d’informations.

  Nouveau dans la version 3.4.

`PYTHONASYNCIODEBUG`

  Si elle est définie à une chaîne non vide, active le mode debogage du module `asyncio`.

  Nouveau dans la version 3.4.

`PYTHONMALLOC`

  Définit l’allocateur mémoire de Python ou installe des points d’entrée (hooks en anglais) de débogage.

  Définit la famille d’allocateurs mémoire utilisés par Python :

  - `malloc` : utilise la fonction `malloc()` de la bibliothèque C standard pour tous les domaines (`PYMEM_DOMAIN_RAW`, `PYMEM_DOMAIN_MEM`, `PYMEM_DOMAIN_OBJ`).

  - `pymalloc` : utilise l’allocateur pymalloc pour les domaines `PYMEM_DOMAIN_MEM` ainsi que `PYMEM_DOMAIN_OBJ` et utilise la fonction `malloc()` pour le domaine `PYMEM_DOMAIN_RAW`.

  Installe des points d’entrée de débogage :

  - `debug` : installe des fonctions automatiques de débogage au-dessus de l’allocateur mémoire par défaut.

  - `malloc_debug`: identique à `malloc` mais installe aussi des fonctions automatiques de débogage.

  - `pymalloc_debug`: identique à `pymalloc` mais installe aussi des fonctions automatiques de débogage.

  Quand Python est compilé en mode release, la valeur par défaut est `pymalloc`. Quand il est compilé en mode débogage, la valeur par défaut est `pymalloc_debug` et les fonctions automatiques de débogage sont utilisées automatiquement.

  Si Python est configuré sans le support de `pymalloc`, `pymalloc` et `pymalloc_debug` ne sont pas disponibles. Les valeurs par défaut sont `malloc` en mode release et `malloc_debug` en mode débogage.

  Reportez-vous à la fonction `PyMem_SetupDebugHooks()` pour ce qui concerne les fonctions automatiques de débogage de l’allocateur mémoire de Python.

  Nouveau dans la version 3.6.

`PYTHONMALLOCSTATS`

  Si elle est définie à une chaîne non vide, Python affiche des statistiques relatives à l’allocateur mémoire pymalloc chaque fois qu’un objet est créé par ce gestionnaire, ainsi qu’à la fin de l’exécution du programme.

  Cette variable est ignorée si la variable d’environnement `PYTHONMALLOC` est utilisée pour forcer l’allocateur `malloc()` de la bibliothèque C standard ou si Python est configuré sans le support de `pymalloc`.

  Modifié dans la version 3.6: Cette variable peut maintenant être utilisée avec Python compilé en mode release. Elle n’a pas d’effet si elle est définie à une chaine vide.

`PYTHONLEGACYWINDOWSFSENCODING`

  Si elle est définie et n’est pas une chaîne vide, l’encodage par défaut respectivement du système de fichiers et des erreurs reviennent à leur valeur pré-3.6, respectivement `'mbcs'` et `'replace'`. Sinon, les nouvelles valeurs par défaut `"UTF-8"` et `"surrogatepass"` sont utilisées.

  Vous pouvez aussi activer ceci à l’exécution avec `sys._enablelegacywindowsfsencoding()`.

  Disponibilité : Windows

  Nouveau dans la version 3.6: Voir la PEP 529 pour plus d’informations.

`PYTHONLEGACYWINDOWSSTDIO`

  Si elle est définie et n’est pas une chaîne vide, n’utilise pas les lecteur et écrivain de la nouvelle console. Cela signifie que les caractères Unicode sont encodés avec l’encodage de la console active plutôt qu’en UTF-8.

  Cette variable est ignorée si les flux standards sont redirigés (vers des fichiers ou des tubes) plutôt que pointant vers des mémoires tampons de console.

  Disponibilité : Windows

  Nouveau dans la version 3.6.

### 1.2.1. Variables en mode débogage

Définir ces variables n’a d’effet que si Python a été compilé en mode débogage, c’est-à-dire que l’option de compilation `--with-pydebug` a été spécifiée.

`PYTHONTHREADDEBUG`

  Si elle est définie, Python affiche des informations de débogage relatives aux différents fils d’exécution.

`PYTHONDUMPREFS`

  Si elle est définie, Python affiche (de manière brute) les objets et les compteurs de références toujours existant après la fermeture de l’interpréteur.