Formulation du problème : Supposons que vous définissiez une variable d'environnement et que vous souhaitiez y accéder dans votre script Python. Comment obtenir la valeur de la variable d'environnement ?
Contexte :Les variables d'environnement sont externes à l'environnement Python. Ils décrivent l'environnement du système d'exploitation que nous utilisons.
Les applications installées utilisent ces informations pour effectuer des tâches spécifiques telles que le stockage de fichiers temporaires, l'accès au profil de l'utilisateur ou la localisation de fichiers et de données particuliers.
Certaines de ces variables contiennent des informations de configuration d'environnement, telles que le nombre de processeurs installés que d'autres applications utilisent pour améliorer leurs performances. Habituellement, le registre Windows est utilisé pour stocker les informations de configuration et les applications accèdent au registre pour les récupérer.
De plus, l'utilisation de variables d'environnement minimise le codage en dur et, par conséquent, les applications sont plus portables et plus faciles à déplacer vers un autre serveur ou système d'exploitation.
Python accède aux variables d'environnement via le os module de classe de mappage et le dictionnaire renvoyé par le os.environ objet de mappage.
Le mappage se produit lorsque le os chargements des modules. Par conséquent, toute modification des variables d'environnement après le os les charges de module ne sont pas incluses.
Comment obtenir et définir des variables d'environnement en Python ?
Le os.environ fournit une structure de données de dictionnaire de toutes les variables d'environnement définies pour le système d'exploitation spécifique. Par conséquent, on peut utiliser toutes les méthodes du dictionnaire Python pour gérer le dictionnaire et récupérer les informations requises.
Une fois le os module est chargé, créer une nouvelle variable d'environnement et accéder à sa valeur est simple.
import os os.environ['ENV_VAR'] = 'username' # SET environment variable ENV_VAR
Cependant, si la variable d'environnement existe, nous écraserons sa valeur, et peut-être que l'application qui l'utilise fonctionnera mal.
Pour nous assurer que nous n'écrasons pas la variable existante, nous pouvons utiliser une instruction if pour vérifier l'existence de la variable :
If os.environ['ENV_VAR'] == None:
os.environ['ENV_VAR'] ='value'
else:
print("Environment Variable Exists")
Une façon d'obtenir la valeur d'une variable d'environnement consiste à utiliser l'instruction de notation du dictionnaire Python que nous avons utilisée pour définir la valeur de la variable : os.environ['ENV_VAR'] renvoie la valeur attribuée au ENV_VAR
Une autre façon est d'utiliser le dictionnaire get() méthode pour obtenir la valeur d'une variable d'environnement os.environ.get('ENV_VAR')
Une troisième façon d'obtenir la valeur d'une variable d'environnement consiste à utiliser os.environ.setdefault() méthode. Cette méthode est similaire au get() celle décrite ci-dessus, mais elle prend deux paramètres obligatoires :le nom de la variable que nous recherchons et une valeur par défaut si la variable n'existe pas.
os.environ.setdefault('ENV_VAR', 'Variable Does not Exist')
Quelqu'un pourrait demander, qu'en est-il du os.getenv() méthode? Que fait-il et pourquoi l'utiliser au lieu d'utiliser le dictionnaire notation déclaration ?
La raison principale est que la méthode de notation du dictionnaire lèvera une exception lorsque la variable n'existe pas, et si elle n'est pas gérée correctement, l'application plantera. En revanche, os.getenv() renverra None (comportement par défaut) si la variable d'environnement n'existe pas. Nous pouvons définir la valeur par défaut sur quelque chose de plus approprié en spécifiant une chaîne facultative après le nom de la variable :os.getenv('ENV_VRR', 'Variable Does Not Exist')
On pourrait dire que os.getenv est une version améliorée de os.environ.get avec None la valeur par défaut, où os.environ.setdefault nécessite une valeur par défaut.
Depuis que nous avons utilisé le getenv() pour obtenir la valeur de la variable d'environnement, nous pensons utiliser setenv() pour définir une nouvelle variable d'environnement. Nous essayons la commande en étant sûr qu'elle fonctionnera :
os.setenv('NewVar', 'VALUE')
Nous obtenons à la place un message d'erreur :module 'os' has no attribute 'setenv.'
Nous avons probablement mal orthographié le nom; donc, nous essayons dir(os) et passez en revue toutes les méthodes et tous les attributs répertoriés. Il n'y a pas de setenv() méthode. Plus vous vous rapprochez de putenv() , et nous essayons : os.putenv('NewVar', 'VALUE')
Il semble que cela fonctionne ; nous ne recevons aucun message d'erreur. Nous exécutons les commandes décrites ci-dessus, en recherchant la variable create, mais la variable n'est pas là.
Documents Python conseiller d'utiliser os.environ pour créer et attribuer des valeurs aux variables d'environnement.
" Attributions aux éléments dans os.environ sont automatiquement traduits en appels correspondants à putenv() ; cependant, les appels vers putenv() ne pas mettre à jour os.environ , il est donc préférable d'attribuer aux éléments de os.environ ." (https://docs.python.org/3/library/os.html)
Alors, quel est le but du putenv() méthode?
Le __setitem__() la méthode l'utilise pour définir la valeur de la variable d'environnement.
def __setitem__(self, key, value):
key = self.encodekey(key)
value = self.encodevalue(value)
putenv(key, value)
self._data[key] = value
Nous pouvons voir cela lorsque nous créons une déclaration d'affectation invalide telle que la suivante :
os.environ['ENV_VAR'] ='value' if 'ENV_VAR' not in os.environ else print("Wrong Value") Comment imprimer une variable d'environnement en Python ?
Pour parcourir toutes les variables d'environnement, nous pouvons utiliser une boucle for :
for var in os.environ:
print(var)
Pour un environnement Windows 10, une liste partielle de la variable d'environnement est la suivante :
| ALLUSERSPROFILE | CHEMIN | TEMP |
| APPDATA | DONNÉES DU PROGRAMME | NOM D'UTILISATEUR |
| HOMEDRIVE | FICHIERS DE PROGRAMME | PROFIL UTILISATEUR |
| CHEMIN D'ACCUEIL | PUBLIQUE | WINDIR |
Ces variables sont utiles pour définir, accéder et stocker des données à un emplacement auquel l'utilisateur a toujours accès, même en itinérance sur le LAN/WAN.
Le "pour" L'instruction qui vient d'être utilisée fournit une liste non triée de toutes les variables d'environnement. Pour que les variables soient listées par ordre croissant, nous pouvons utiliser le sorted() fonction :
for var in sorted(os.environ): print(var)
Utilisation de reverse=True affichera la liste en ordre décroissant :
for var in sorted(os.environ, reverse=True):
Remarque : reverse=False est la valeur par défaut du sorted() fonction, et il n'est pas nécessaire de le spécifier.
Qu'en est-il de l'obtention des valeurs de chaque variable ? Comment afficher les valeurs associées ?
Il existe plusieurs façons d'obtenir les valeurs associées. Étant donné que os.environ renvoie un dictionnaire et que le for l'instruction que nous avons utilisée ci-dessus affiche le key de chaque entrée du dictionnaire, nous pouvons utiliser la notation du dictionnaire pour retourner la valeur de chaque clé :
for var in sorted(os.environ): print(var, os.environ[v])
ou bien utilisez la méthode get Dictionary
for var in sorted(os.environ): print(var, os.environ.get(var))
Nous pouvons utiliser les styles de formatage de chaîne familiers pour afficher la liste comme nous le souhaitons. Pour afficher la liste des variables d'environnement de la même manière que lorsque nous utilisons le set Commande Windows, nous pouvons utiliser le f format :print(f"{var} = {os.environ[var]}")
C'est une façon. Une autre façon est d'utiliser le items() collection à la place :
for v, k in os.environ.items():
print(f"{v} = {k}")
Nous pouvons également convertir le dictionnaire des variables d'environnement en une liste de tuples et le découper pour obtenir un sous-ensemble des variables d'environnement, par ex. les 10 premières variables :
envl=list(os.environ.items())
for v, k in envl[0:10]:
print(f"{v} = {k}")
Avec autant de façons d'obtenir la paire clé-valeur des variables d'environnement, nous nous demandons laquelle est la meilleure. Nous croyons que l'efficacité devrait être la principale raison de choisir une déclaration plutôt qu'une autre. Une façon de chronométrer un morceau de code consiste à utiliser la magie de cellule Jupyter Notebook %%time .
Par conséquent, nous précédons les trois pour les déclarations décrit ci-dessus avec le %%time , et nous voyons que l'instruction for utilisant os.environ.items() est le plus lent , où les deux autres ont le même temps d'exécution.
%%time
for v, k in os.environ.items():
print(f"{v} = {k}")
La boucle for ci-dessus est plus lente de 1 ms. Pour ce cas, cela n'a pas d'importance car il est toujours très rapide. Cependant, c'est quelque chose à garder à l'esprit puisque les appels au os.environ sont plus lents et plus chers qu'une bibliothèque locale, comme nous l'avons démontré.
Comment trouver votre chemin Python ?
L'une des variables d'environnement qui a tendance à devenir encombrée et très longue est celle de PATH. Les anciennes versions de Windows avaient une limite de 256 caractères pour la variable d'environnement Path. La limite de chemin d'accès de Windows a été supprimée et, avec les nouvelles versions de Windows, la longueur du PATH peut être beaucoup plus longue. Pour lire la valeur de la variable PATH, vous pouvez utiliser os.environ['PATH'] ou os.getenv('PATH') . La chaîne renvoyée sera très longue et pas si facile à lire dans les deux cas. Pour obtenir les entrées de chemin dans un format plus utilisable, nous devons convertir la chaîne os.environ['PATH'] dans une liste :
path_list = os.environ['PATH'].split(';') # or
path_list = os.getenv('PATH').split(';')
Remarque : Le système d'exploitation Windows utilise le point-virgule (;) comme séparateur de chemin, là où Linux utilise les deux-points (:).
On dirait que nous sommes en train de coder en dur, n'est-ce pas ? Comment pouvons-nous éviter de coder en dur le séparateur du code ci-dessus ?
Si on liste tous les attributs et méthodes du os module nous verrons qu'il y a un attribut séparateur de chemin pathsep . Par conséquent, le code ci-dessus devient :
path_list = os.environ['PATH'].split(os.pathsep) or
path_list = os.getenv('PATH').split(os.pathsep)
Nous n'avons plus à nous soucier du séparateur, et l'application peut passer à un système d'exploitation différent avec tout problème lié au caractère séparateur de chemin.
Si nous aimons obtenir le chemin d'installation de Python, nous pouvons utiliser le sys.prefix chaîne comme suit :
import sys print(sys.prefix)
Le sys.prefix string nous indique l'emplacement des fichiers d'installation de Python, autrement connu sous le nom de chemin d'installation de Python.
On s'attendrait à trouver une variable d'environnement telle que PYTHONPATH avec la valeur fournie par sys.prefix . Cependant, la variable PYTHONPATH n'existe pas. Nous pouvons utiliser le sys.prefix informations pour créer une variable d'environnement PYTHONPATH et accédez-y via le os.environ classe d'instance :
os.environ['PYTHONPATH'] = sys.prefix # Set environment variable
os.environ['PYTHONPATH'] # Get the variable value
for p in sorted(os.environ): # Verify the os.environ has been updated
print(p)
Comment supprimer une variable d'environnement ?
NOUS RECOMMANDONS DE NE PAS SUPPRIMER LES VARIABLES D'ENVIRONNEMENT DÉFINIES PAR D'AUTRES APPLICATIONS OU LE SYSTÈME D'EXPLOITATION.
Qu'en est-il lorsque nous devons désinstaller l'application et que nous aimons nettoyer l'environnement ?
Au moment où nous décidons de créer une variable d'environnement, nous autorisons d'autres applications à l'utiliser. Par conséquent, à moins d'être absolument sûrs que la variable d'environnement que nous avons créée n'est pas utilisée par d'autres applications, nous devons éviter de la supprimer .
Depuis le os.environ est un dictionnaire avec toutes les méthodes et attributs du dictionnaire, la suppression d'une variable d'environnement peut être effectuée en utilisant le .pop() méthode.
