How to set environment variables in Python?

Question

I need to set some environment variables in the Python script and I want all the other scripts that are called from Python to see the environment variables' set.

If I do,

os.environ["DEBUSSY"] = 1

it complains saying that 1 has to be a string.

I also want to know how to read the environment variables in Python (in the latter part of the script) once I set it.

• Stevoisiak: Related: How do I access environment variables from Python?

Answer 1

Environment variables must be strings, so use

import os
os.environ["DEBUSSY"] = "1"

to set the variable DEBUSSY to the string 1.

To access this variable later, simply use

print(os.environ["DEBUSSY"])

Child processes automatically inherit the environment of the parent process -- no special action on your part is required.

• Evan: On some platforms, modifying os.environ will not actually modify the system environment either for the current process or child processes. See the docs for more info: docs.python.org/2/library/os.html#os.environ
• Sven Marnach: @Evan There might be some historical variants of Unix that don't support putenv(), but for those Unixen there is nothing you can do anyway. Even old version of AIX and HPUX I worked with did support it. If anyone is actually able to find a computer not supporting it today, I have severe doubts they will be able to run Python on that computer. :)
• CODE-REaD: Caution: to quote from @Evan's reference above, Such changes to the environment affect subprocesses started with os.system(), popen() or fork() and execv(). In other words, keep in mind that this approach won't modify the way your program is running, only the way your program's children run. True, your program can set and read back environment variables, but only from the environment it configures for its children. See also: change current process environment. So far I haven't found a way for a Python script to modify its parent env.
• Krishna: @SvenMarnach is the statement "child process automatically inherit the environment of the parent process' true for shell like bash.
• Harry: For any total noobs like me, you have to type import os first, or this won't work.

Answer 2

You may need to consider some further aspects for code robustness;

when you're storing an integer-valued variable as an environment variable, try

os.environ['DEBUSSY'] = str(myintvariable)

then for retrieval, consider that to avoid errors, you should try

os.environ.get('DEBUSSY', 'Not Set')

possibly substitute '-1' for 'Not Set'

so, to put that all together

myintvariable = 1
os.environ['DEBUSSY'] = str(myintvariable)
strauss = int(os.environ.get('STRAUSS', '-1'))
# NB KeyError <=> strauss = os.environ['STRAUSS']
debussy = int(os.environ.get('DEBUSSY', '-1'))
print "%s %u, %s %u" % ('Strauss', strauss, 'Debussy', debussy)

• Anurag-Sharma: Can you tell how would set the variable on a Linux machine, is the code same for all platforms ?
• Benjamin Atkin: It rarely makes sense to store -1 for a missing integer. A better bet would be myvar = int(os.environ.get('MYVAR')) if os.environ.get('MYVAR', '') != '' else None – that way it would be None if no number was provided
• yeOldeDataSmythe: If you are dealing with integers, a -1 makes sense. Though I would likely set a variable/constant to the value I would use for not set (e.g., value_not_set = '-1'). Then, you could use debussy = int(os.environ.get('DEBUSSY', value_not_set))

Answer 3

os.environ behaves like a python dictionary, so all the common dictionary operations can be performed. In addition to the get and set operations mentioned in the other answers, we can also simply check if a key exists. The keys and values should be stored as strings.

Python 3

For python 3, dictionaries use the in keyword instead of has_key

>>> import os
>>> 'HOME' in os.environ # Check an existing env. variable
True
...

Python 2

>>> import os
>>> os.environ.has_key('HOME') # Check an existing env. variable
True
>>> os.environ.has_key('FOO') # Check for a non existing variable
False
>>> os.environ['FOO'] = '1' # Set a new env. variable (String value)
>>> os.environ.has_key('FOO')
True
>>> os.environ.get('FOO') # Retrieve the value
'1'

There is one important thing to note about using os.environ:

Although child processes inherit the environment from the parent process, I had run into an issue recently and figured out, if you have other scripts updating the environment while your python script is running, calling os.environ again will not reflect the latest values.

Excerpt from the docs:

This mapping is captured the first time the os module is imported, typically during Python startup as part of processing site.py. Changes to the environment made after this time are not reflected in os.environ, except for changes made by modifying os.environ directly.

os.environ.data which stores all the environment variables, is a dict object, which contains all the environment values:

>>> type(os.environ.data) # changed to _data since v3.2 (refer comment below)
<type 'dict'>

• Al Sweigart: A process's environment variables are set when the process is created. Any changes made after this won't affect the process's own copy of the environment variable. This is common to all processes, not just Python. Further, os.environ.data was renamed in Python 3.2 to os.environ._data, the underscore prefix showing that you shouldn't read it directly. Anyway, os.environ._data won't have updated values anyway.
• sisanared: Yep, I understand now. I wanted to share my initial surprise with others who come looking. Thanks for pointing out the update to the variable name since 3.2, will update the answer.
• smci: ? "os.environ behaves like a python dictionary, so all the common dictionary operations can be performed. In addition to the get and set operations mentioned..." It doesn't have a .set() method, only a .setdefault()

Answer 4

Before using this method please go through Comments Sections

I have been trying to add environment variables. My goal was to store some user information to system variables such that I can use those variables for future solutions, as an alternative to config files. However, the method described in the code below did not help me at all.

import os
os.environ["variable_1"] = "value_1"
os.environ["variable_2"] = "value_2"
# To Verify above code
os.environ.get("variable_1")
os.environ.get("variable_2")

This simple code block works well, however, these variables exist inside the respective processes such that you will not find them in the environment variables tab of windows system settings. Pretty much above code did not serve my purpose. This problem is discussed here: variable save problem

os.environ.putenv(key, value)

Another unsuccessful attempt. So, finally, I managed to save variables successfully inside the window environment register by mimicking the windows shell commands wrapped inside the system class of os package. The following code describes this successful attempt.

os.system("SETX {0} {1} /M".format(key, value))

I hope this will be helpful for some of you.

• Apostolos: This is a very bad idea! The variable will be stored permanently in the system and you can only delete it by editing the registry! (HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\Environment). You should at least warn people when you suggest such things! (But maybe you didn't even have an idea about that!)
• Sourabh Desai: Yes, adding a permanent variable is the idea here. I should have mentioned that. Thanks for the update. Methods described at the start of the answers do add env variables which exist in that process only, which is matter of choice, I needed a permanent save.
• Apostolos: I don't think this is the idea at all. For one thing, the question or its description doesn't mention anything like that. Then, logically one assumes that the questioner wants to create just a persistent variable that can be used by other scripts, etc., not a permanent variable in the registry! Now, I admit I was aggressive in my comment, but you made me lost a lot of time until I find out how to remove a permanent a variable from the environment that I created just for testing!!
• Amit Naidu: Its actually worse than just permanent registry storage. setx can truncate your environment variables. If you use it for something important like the PATH variable, your entire existing environment configuration will get mangled when the variable is longer than 1024 characters. There is no way to 'undo' that either. Do not use it. Even Microsoft doesn't know better.

Answer 5

if i do os.environ["DEBUSSY"] = 1, it complains saying that 1 has to be string.

Then do

os.environ["DEBUSSY"] = "1"

I also want to know how to read the environment variables in python(in the later part of the script) once i set it.

Just use os.environ["DEBUSSY"], as in

some_value = os.environ["DEBUSSY"]

Answer 6

to Set Variable:

item Assignment method using key:

import os 
os.environ['DEBUSSY'] = '1' #Environ Variable must be string not Int

to get or to check whether its existed or not,

since os.environ is an instance you can try object way.

Method 1:

os.environ.get('DEBUSSY') # this is error free method if not will return None by default

will get '1' as return value

Method 2:

os.environ['DEBUSSY'] # will throw an key error if not found!

Method 3:

'DEBUSSY' in os.environ # will return Boolean True/False

Method 4:

os.environ.has_key('DEBUSSY') #last 2 methods are Boolean Return so can use for conditional statements

Answer 7

What about os.environ["DEBUSSY"] = '1'? Environment variables are always strings.

Answer 8

You should assign string value to environment variable.

os.environ["DEBUSSY"] = "1"

If you want to read or print the environment variable just use

print os.environ["DEBUSSY"]

This changes will be effective only for the current process where it was assigned, it will no change the value permanently. The child processes will automatically inherit the environment of the parent process.

enter image description here

• spitfiredd: "This changes will be effective only for the current process where it was assigned, it will no change the value permanently. " This answered a question I had about the scope of setting an environ variable.
• MeadowMuffins: If I exit the python shell, and the os environmet set previously is gone.
• Filip: How do I set an environment variable in windows? I tried set [<name>=[<value>]] but it only makes it for the current running process. When I close the cmd it doesn't exist and even when it's open other programms can't see it.

Answer 9

It should be noted that if you try to set the environment variable to a bash evaluation it won't store what you expect. Example:

from os import environ
environ["JAVA_HOME"] = "$(/usr/libexec/java_home)"

This won't evaluate it like it does in a shell, so instead of getting /Library/Java/JavaVirtualMachines/jdk1.8.0_144.jdk/Contents/Home as a path you will get the literal expression $(/usr/libexec/java_home).

Make sure to evaluate it before setting the environment variable, like so:

from os import environ
from subprocess import Popen, PIPE
bash_variable = "$(/usr/libexec/java_home)"
capture = Popen(f"echo {bash_variable}", stdout=PIPE, shell=True)
std_out, std_err = capture.communicate()
return_code = capture.returncode
if return_code == 0:
 evaluated_env = std_out.decode().strip()
 environ["JAVA_HOME"] = evaluated_env
else:
 print(f"Error: Unable to find environment variable {bash_variable}")

Answer 10

Set Environment Variables like this :

import os
 # Set environment variables
 os.environ['API_USER'] = 'username'
 os.environ['API_PASSWORD'] = 'secret'
 # Get environment variables
 USER = os.getenv('API_USER')
 PASSWORD = os.environ.get('API_PASSWORD')

• sharhp: How is this different from the first answer by Sven Marnach?

Answer 11

You can use the os.environ dictionary to access your environment variables.

Now, a problem I had is that if I tried to use os.system to run a batch file that sets your environment variables (using the SET command in a **.bat* file) it would not really set them for your python environment (but for the child process that is created with the os.system function). To actually get the variables set in the python environment, I use this script:

import re
import system
import os
def setEnvBat(batFilePath, verbose = False):
 SetEnvPattern = re.compile("set (\w+)(?:=)(.*)$", re.MULTILINE)
 SetEnvFile = open(batFilePath, "r")
 SetEnvText = SetEnvFile.read()
 SetEnvMatchList = re.findall(SetEnvPattern, SetEnvText)
 for SetEnvMatch in SetEnvMatchList:
 VarName=SetEnvMatch[0]
 VarValue=SetEnvMatch[1]
 if verbose:
 print "%s=%s"%(VarName,VarValue)
 os.environ[VarName]=VarValue

Answer 12

When you play with environment variables (add/modify/remove variables), a good practice is to restore the previous state at function completion.

You may need something like the modified_environ context manager describe in this question to restore the environment variables.

Classic usage:

with modified_environ(DEBUSSY="1"):
 call_my_function()

Answer 13

Use setdefault function to set a new variable if the variable does not exist in the environment.

make sure you set the environment variable as a string, not int. Otherwise will throw TypeError.

import os
if not os.environ.get("DEBUSSY"):
 os.environ.setdefault("DEBUSSY","1")
else:
 os.environ["DEBUSSY"] = "1"
print(os.environ["DEBUSSY"])

• Smart Humanism: Don't you need the if statement at all? I think just using setdefault method alone is enough.

Answer 14

A neat way to manage user defined environment variables is to put all of them in a text file and load them at runtime. We can achieve this using the python-dotenv package, which allows us to import these variables. This package can be installed via:

pip install python-dotenv

By default the module looks for a file named .env in the current directory. Define all your variables in this file, one per line as follows:

DEBUSSY=1 
PATH_TO_EXECUTABLE=/home/user_name/project/run.sh

And then import these to your environment as follows:

from dotenv import load_dotenv
load_dotenv()
print(os.getenv('DEBUSSY'))

You can specify the path to the file containing the defined variables as an optional argument to load_dotenv. Subsequently, these environment variables can be accessed via the os module as explained in some of the other responses.

Answer 15

I wrote this little context manager which sets variables for the duration of an indented block only:

import os
from contextlib import contextmanager
@contextmanager
def extended_env(new_env_vars):
 old_env = os.environ.copy()
 os.environ.update(new_env_vars)
 yield
 os.environ.clear()
 os.environ.update(old_env)

Example usage (with % for Windows and $ for Linux):

import subprocess
subprocess.run("echo $ENVTEST %ENVTEST%", shell=True)
with extended_env({"ENVTEST": "17"}):
 subprocess.run("echo $ENVTEST %ENVTEST%", shell=True)
subprocess.run("echo $ENVTEST %ENVTEST%", shell=True)

• xjcl: Or in Python 3.9+: subprocess.run(..., env=os.environ | {"ENVTEST": "17"})

Answer 16

What about the following?

os.environ["DEBUSSY"] = '1'
debussy = int(os.environ.get('DEBUSSY'))
print(type(debussy))

<class 'int'>

Answer 17

There is good out of the box Python solution called pycrosskit. It will create environment variables that are persistent both for Linux and Windows.

Usage:

# Will Set Persistent Value for Variable in System
# * subkey works only for windows like file in folder
# * reg_path works only for windows as register path 
SysEnv.set_var(name, value, subkey, reg_path=default_reg_path)
# Will Get Persistent Value for Variable in System
# * reg_path works only for windows as register path
# * delete, deletes key from environment and its subkeys after read
SysEnv.get_var(name, reg_path=default_reg_path, delete=False)

• Marcell: The environment variables created this way do not seem to be persistent at all.

Answer 18

Late answer that might help someone test fast without code changes. Just run your app with the environment variable attached as so:

 $ DEBUSSY=1 python3 api.py

You can pass env vars this way to any script.

Answer 19

If you are struggling with Flask and unittest, please remember that if you set a variable outside any method, this variable is read when you import the app. Might seem trivial, but could save some headache to someone.

For example, if into your Flask unittest you:

1. import the app
2. set the environment variable in the setUp method.
3. use app.test_client() to test your application

The variable into the second step will not be seen by the third step, because the variable is already read when you perform the first step.

Answer 20

The environment is frozen for the code itself (not child processes) and cannot be accomplished with programmatically.

A good solution, no matter what platform, is to wrap the call to python in a batch file. For example: if I were on linux, the batch file might look like

export "DEBUSSY"="1"
python mycode.py