How Do You Set an Environment Variable in Python?

AvatarByBarbara Hernandez Python

Setting environment variables is a fundamental skill for any Python developer aiming to create flexible, secure, and maintainable applications. Whether you’re managing sensitive information like API keys or configuring application settings that vary between development and production, environment variables offer a clean and efficient solution. Understanding how to set and access these variables in Python can significantly enhance your workflow and code portability.

In this article, we’ll explore the concept of environment variables and why they matter in Python programming. You’ll gain insight into the different methods available for setting these variables, both temporarily and permanently, across various operating systems. Additionally, we’ll touch on best practices to ensure your environment configurations remain organized and secure.

By the end of this guide, you’ll be equipped with the knowledge to seamlessly integrate environment variables into your Python projects, making your applications more adaptable and easier to manage. Whether you’re a beginner or looking to refine your development process, mastering environment variables is a step toward writing smarter, more professional code.

Setting Environment Variables Within a Python Script

In Python, environment variables can be set dynamically during runtime using the built-in `os` module. This approach allows you to modify or add environment variables for the duration of your script’s execution. It is particularly useful when you need temporary configuration changes without affecting the system-wide environment.

To set an environment variable in Python, use the `os.environ` dictionary-like object. Assigning a value to a key in `os.environ` creates or updates the environment variable for the current process and any child processes spawned thereafter.

Example:
“`python
import os

os.environ[‘MY_VARIABLE’] = ‘my_value’
print(os.environ[‘MY_VARIABLE’]) Output: my_value
“`

Keep in mind, changes made to `os.environ` affect only the current process and its children. Once the Python script terminates, these changes are discarded and do not persist in the system environment.

Using Environment Variables for Configuration Management

Environment variables are commonly used for configuration management in Python applications, especially in settings where sensitive information like API keys, database credentials, or configuration flags must be kept separate from source code.

Advantages of using environment variables include:

  • Security: Keeps secrets out of the source code.
  • Portability: Simplifies configuration across different environments (development, staging, production).
  • Flexibility: Enables changes without code modifications.

To read an environment variable in Python, use `os.environ.get()` to safely retrieve values without raising exceptions if the key is missing:

“`python
import os

db_password = os.environ.get(‘DB_PASSWORD’, ‘default_password’)
“`

This example uses `’default_password’` if `DB_PASSWORD` is not set, helping to avoid runtime errors.

Setting Environment Variables Permanently on Different Operating Systems

To make environment variables persistent beyond a single script execution, they must be set at the operating system level. The process varies depending on the platform.

Operating System How to Set Environment Variable Permanently Typical File/Location
Windows
  • Use System Properties > Environment Variables GUI
  • Or use `setx` command in Command Prompt

Example:
setx MY_VARIABLE "my_value"

System Environment Variables via Control Panel or Registry
Linux / macOS
  • Add export statement to shell configuration files

Example:
export MY_VARIABLE="my_value"

~/.bashrc, ~/.bash_profile, ~/.zshrc, or /etc/environment

After setting environment variables permanently, a system restart or shell reload (`source ~/.bashrc`) is often required to apply the changes.

Using dotenv Files to Manage Environment Variables in Python

For ease of managing environment variables locally without setting them globally, the `python-dotenv` package is a popular solution. It loads variables from a `.env` file into the environment at runtime.

Steps to use `python-dotenv`:

  • Install the package:

“`
pip install python-dotenv
“`

  • Create a `.env` file in your project directory containing:

“`
SECRET_KEY=your_secret_key
DATABASE_URL=postgres://user:password@localhost/dbname
“`

  • Load the `.env` file in your script:

“`python
from dotenv import load_dotenv
import os

load_dotenv() Loads variables from .env into os.environ

secret_key = os.environ.get(‘SECRET_KEY’)
“`

Using `.env` files improves local development convenience while maintaining separation between code and configuration.

Best Practices When Working with Environment Variables in Python

To ensure secure and maintainable use of environment variables, consider the following best practices:

  • Never commit `.env` files with sensitive data to public repositories. Use `.gitignore` to exclude them.
  • Use descriptive and consistent variable names to avoid confusion.
  • Validate the existence and format of required environment variables at application startup.
  • Provide sensible defaults where applicable to prevent application crashes.
  • Document all environment variables your application depends on for easier onboarding and troubleshooting.

By adhering to these guidelines, you can effectively leverage environment variables to build secure and configurable Python applications.

Setting Environment Variables Within Python Scripts

Environment variables are a crucial part of managing configuration and secrets in applications. In Python, you can set environment variables at runtime using the built-in `os` module. This approach is useful when you want to configure variables dynamically within your script or testing environment.

To set an environment variable inside a Python script, use the following method:

“`python
import os

Set an environment variable
os.environ[‘VARIABLE_NAME’] = ‘value’

Access the variable to confirm it’s set
print(os.environ[‘VARIABLE_NAME’])
“`

  • os.environ behaves like a dictionary representing the environment variables.
  • Assigning a value to os.environ['VARIABLE_NAME'] sets or updates that environment variable for the current process.
  • These changes do not persist beyond the Python process and are not propagated to the parent shell or system environment.

This method is ideal for temporary environment variable settings within a script’s runtime, such as setting API keys, toggling debug modes, or configuring runtime parameters.

Setting Environment Variables Before Running Python

Often, environment variables are set outside the script to separate configuration from code, improving security and flexibility. This can be done in the shell or operating system environment before executing the Python script.

Platform Command to Set Environment Variable Example
Linux / macOS (bash) export VARIABLE_NAME=value export API_KEY=12345
Windows (Command Prompt) set VARIABLE_NAME=value set API_KEY=12345
Windows (PowerShell) $env:VARIABLE_NAME = "value" $env:API_KEY = "12345"

After setting the environment variable in the shell, you run your Python script normally:

“`bash
python your_script.py
“`

Within the Python script, access the variable using:

“`python
import os

api_key = os.getenv(‘API_KEY’)
print(api_key)
“`

  • os.getenv() returns None if the environment variable is not set, which helps avoid exceptions.
  • Using this approach keeps sensitive information out of the source code.

Using dotenv Files for Environment Variables in Python

For projects requiring many environment variables, especially during development, a `.env` file is a common practice. This file contains key-value pairs that define environment variables and is loaded into your Python environment at runtime.

Use the python-dotenv package to read `.env` files:

  • Install the package:

“`bash
pip install python-dotenv
“`

  • Create a `.env` file in your project root:

“`
DATABASE_URL=postgresql://user:password@localhost/dbname
SECRET_KEY=supersecretkey123
“`

  • Load the `.env` file in your script:

“`python
from dotenv import load_dotenv
import os

load_dotenv() Loads variables from .env into environment

database_url = os.getenv(‘DATABASE_URL’)
secret_key = os.getenv(‘SECRET_KEY’)

print(database_url)
print(secret_key)
“`

Benefit Description
Separation of Configuration Keeps environment-specific settings outside the source code.
Ease of Use Simple key-value format, easy to edit and maintain.
Security Allows keeping secrets out of code repositories by adding `.env` to `.gitignore`.
Portability Works across multiple platforms without shell-specific syntax.

Best Practices When Working with Environment Variables in Python

Adopting best practices ensures that environment variables are handled securely and efficiently:

  • Never hardcode secrets: Avoid embedding passwords, API keys, or tokens directly in source code.
  • Use `.env` files for development: Store local environment settings in `.env` files and exclude them from version control.
  • Validate environment variables: Check for the existence and correctness of critical variables early in your application startup.
  • Document required variables: Maintain a sample `.env.example` file or documentation listing all required environment variables and their purpose.
  • Use type casting carefully: Environment variables are strings by default; convert them explicitly when necessary (e.g., integers, booleans).
  • Consider using configuration libraries: Libraries like pydantic or dynaconfExpert Perspectives on Setting Environment Variables in Python

    Dr. Emily Chen (Senior Software Engineer, Cloud Solutions Inc.) emphasizes that "Using Python's built-in os module to set environment variables is both straightforward and effective. By leveraging os.environ, developers can dynamically configure application settings at runtime without hardcoding sensitive data, which is crucial for maintaining security and flexibility in modern applications."

    Raj Patel (DevOps Architect, NextGen Technologies) notes, "In production environments, setting environment variables externally—such as through container orchestration tools or CI/CD pipelines—is best practice. However, for local development or testing, Python’s os.environ provides a quick and reliable method to simulate these variables, ensuring consistency across different stages."

    Linda Martinez (Python Instructor and Author, CodeCraft Academy) advises, "When setting environment variables within Python scripts, it is important to remember that changes to os.environ only affect the current process and its children. For persistent environment variables, one must configure the operating system or use environment management tools, but for ephemeral needs, os.environ is an excellent choice."

    Frequently Asked Questions (FAQs)

    What is an environment variable in Python?
    An environment variable is a dynamic value stored outside of the Python program, typically in the operating system, that can influence the behavior of running processes including Python scripts.

    How can I set an environment variable within a Python script?
    You can set an environment variable in Python using the `os` module: `import os` followed by `os.environ['VARIABLE_NAME'] = 'value'`. This change affects only the current process and its children.

    Can I set environment variables permanently from Python?
    No, environment variables set within a Python script are temporary and exist only during the script’s execution. Permanent changes must be made in the operating system’s environment settings.

    How do I access an environment variable in Python?
    Use `os.environ.get('VARIABLE_NAME')` to safely retrieve the value of an environment variable. This method returns `None` if the variable is not set.

    What are common use cases for setting environment variables in Python?
    Environment variables are commonly used to manage configuration settings such as API keys, database credentials, and application modes without hardcoding sensitive information in the source code.

    Is it possible to load environment variables from a file in Python?
    Yes, using packages like `python-dotenv`, you can load environment variables from a `.env` file into the Python environment, simplifying configuration management.
    Setting environment variables in Python is a fundamental task that enables developers to manage configuration settings and sensitive information securely and efficiently. By using the built-in `os` module, specifically the `os.environ` dictionary, Python programs can both read and set environment variables at runtime. This approach is straightforward and does not require external dependencies, making it suitable for a wide range of applications.

    In addition to programmatically setting environment variables within Python scripts, it is important to understand the broader context of environment management. Environment variables can also be defined outside the Python environment, such as in the operating system shell or through configuration files like `.env`, which can be loaded using packages like `python-dotenv`. This separation of configuration from code enhances security and flexibility, especially in production environments.

    Overall, mastering how to set and manage environment variables in Python contributes to writing more secure, maintainable, and portable code. Developers should consider best practices such as avoiding hardcoding sensitive data, leveraging environment variables for configuration, and using appropriate tools to manage these variables effectively across different development and deployment stages.

    Author Profile

    Avatar
    Barbara Hernandez
    Barbara Hernandez is the brain behind A Girl Among Geeks a coding blog born from stubborn bugs, midnight learning, and a refusal to quit. With zero formal training and a browser full of error messages, she taught herself everything from loops to Linux. Her mission? Make tech less intimidating, one real answer at a time.

    Barbara writes for the self-taught, the stuck, and the silently frustrated offering code clarity without the condescension. What started as her personal survival guide is now a go-to space for learners who just want to understand what the docs forgot to mention.