{"id":3469,"date":"2023-08-14T19:32:34","date_gmt":"2023-08-15T02:32:34","guid":{"rendered":"https:\/\/ioflood.com\/blog\/?p=3469"},"modified":"2024-02-07T10:39:41","modified_gmt":"2024-02-07T17:39:41","slug":"python-dotenv-guide-how-to-use-environment-variables-in-python","status":"publish","type":"post","link":"https:\/\/ioflood.com\/blog\/python-dotenv-guide-how-to-use-environment-variables-in-python\/","title":{"rendered":"Python Dotenv Guide | Using Python Environment Variables"},"content":{"rendered":"
\n
\"Digital<\/figure>\n<\/div>\n

Are you wrestling with the task of managing sensitive data in your Python application? Do you feel like you’re treading on thin ice when it comes to handling confidential information? You’re not alone.<\/p>\n

We have a powerful solution for you – the python-dotenv library. This library is a game-changer for securely managing environment variables in Python applications.<\/p>\n

In this comprehensive guide, we will plunge into the world of python-dotenv, exploring its capabilities, peeling back the layers of its advanced features, and demonstrating how to use it to keep your sensitive data secure.<\/p>\n

TL;DR: What is python-dotenv and how does it secure Python applications?<\/h2>\n

\n Python-dotenv is a library that enables secure management of environment variables in Python applications. It allows you to separate sensitive information from your application code, enhancing security. With python-dotenv, you can store sensitive data in a .env file in the user’s home directory, and access it when needed, keeping your code clean and maintainable. For a more advanced understanding and methods, continue reading the article.\n<\/p><\/blockquote>\n

Example usage for loading “SECRET KEY”:<\/p>\n

from dotenv import load_dotenv\nimport os\n\nload_dotenv()\n\nsecret_key = os.getenv('SECRET_KEY')\nprint(secret_key)\n<\/code><\/pre>\n
Python-dotenv Basics<\/h2>\n
By keeping your secure data in your .env environment variable file, you can avoid accidentally including passwords, API keys, and other secrets in your program code. This is essential for making sure these secrets don’t accidentally get leaked on github, for example.<\/p>\n
\n  Python-dotenv allows you to separate sensitive information from your application code, providing an additional layer of security. This separation ensures that even if your code is compromised, your sensitive data remains protected.\n<\/p><\/blockquote>\n
In addition to enhanced security, python-dotenv also brings convenience to the table. The installation is straightforward, setting up the .env file is a breeze, and the separation of sensitive data makes your code cleaner and more maintainable.<\/p>\n
Installing Python-dotenv<\/h3>\n
The first step in our journey is the installation of python-dotenv. It’s a straightforward process that only requires pip, Python’s package installer. Here’s how you do it:<\/p>\n
pip install python-dotenv\n<\/code><\/pre>\n
With just one command, you’ve successfully installed python-dotenv. Simple, isn’t it?<\/p>\n
Setting Up the .env File<\/h3>\n
After installing python-dotenv, the next step is to set up the .env file. This file will act as a safe where you store your sensitive information. Here’s how you can append a secret to a .env file:<\/p>\n
echo SECRET_KEY=my_secret_key >> .env\n<\/code><\/pre>\n
In the command above, ‘SECRET_KEY’ is the name of the environment variable, and ‘my_secret_key’ is the value. You can replace these with your own variables and values.<\/p>\n
\n  By default, Python will load the .env file in \/home\/username\/.env<\/code>, and Python will have access to the .env file associated with the user running the Python script.\n<\/p><\/blockquote>\n
Example of using .env file in a Python application:<\/p>\n
from dotenv import load_dotenv\nimport os\n\nload_dotenv()\n\nsecret_key = os.getenv('SECRET_KEY')\nprint(secret_key)\n<\/code><\/pre>\n
The Advantages of Separation<\/h3>\n
By storing sensitive information in a separate .env file, you’re enhancing security and also making your code cleaner and more maintainable. You no longer have to hard-code sensitive data into your application code. Instead, you can store it in the .env file and access it when needed.<\/p>\n
\n  This separation also allows you to share your code without revealing your secrets.\n<\/p><\/blockquote>\n
Using the load_dotenv() Function<\/h2>\n
Having set up our .env file, the next step is to integrate it into our application. This is where the load_dotenv()<\/code> function comes into play. This function loads the variables from the .env file into the environment, making them accessible to our application.<\/p>\n
For example, if your .env file looks like this:<\/p>\n
DATABASE_URL=postgresql:\/\/localhost\/db\nSECRET_KEY=YourSecretKey\n<\/code><\/pre>\n
You can access these values like this:<\/p>\n
import os\nfrom dotenv import load_dotenv\n\n# Load the dotenv file\nload_dotenv()\n\n# Access variables\ndatabase_url = os.getenv('DATABASE_URL', 'default_value_if_not_found')\nsecret_key = os.getenv('SECRET_KEY')\n\n# Use these values in your application\nprint(f'Database URL: {database_url}')\nprint(f'Secret Key: {secret_key}')\n<\/code><\/pre>\n
In this script, ‘DATABASE_URL’ and ‘SECRET_KEY’ are strings that match the names of variables in your .env file.<\/p>\n
\n  If you think the .env file might have changed, you can refresh the variables inside of Python by running load_dotenv()<\/code> again.\n<\/p><\/blockquote>\n
Loading All Environment Variables as a Dictionary<\/h3>\n
What if you want to load all the environment variables at once? Python-dotenv has a solution for that too. You can load all the variables from your .env file as a dictionary. Here’s how:<\/p>\n
from dotenv import dotenv_values\n\n# Get a dictionary of .env variables\nconfig = dotenv_values()\n\n# Get 'SECRET_KEY'\nsecret_key = config.get('SECRET_KEY')\n\n# Now you can use the secret_key variable in your application\nprint(f'Secret Key: {secret_key}')\n<\/code><\/pre>\n
The dotenv_values()<\/code> function returns a dictionary containing all the environment variables from the specified .env file.<\/p>\n
In the code snippet above, ‘SECRET_KEY’ is the name of the variable. You can replace it with the name of the variable you wish to refer to.<\/p>\n
\n  dotenv_values()<\/code> will load the .env file when you run it, making it unnecessary to run load_dotenv()<\/code>, and also takes the place of running os.getenv<\/code>\n<\/p><\/blockquote>\n
Loading Environment Variables via Streams<\/h3>\n
Python-dotenv goes a step further by supporting loading variables via streams. This means you can source your environment variables from non-filesystem entities, like network streams or in-memory files. This allows you to store your configurations in a database or a remote server and python-dotenv can still load them.<\/p>\n
Example of loading variables via streams:<\/p>\n
from dotenv import dotenv_values\nfrom io import StringIO\n\nstream = StringIO('SECRET_KEY=my_secret_key')\nconfig = dotenv_values(stream=stream)\nprint(config)\n<\/code><\/pre>\n
Advanced Uses of dotenv()<\/h2>\n
Although the basic uses outlined above are already powerful, there are many ways to get more out of dotenv() with advanced use cases.<\/p>\n
Loading Different Environment Variable Files<\/h3>\n
During the development of a Python application, it’s common to require different environment variables for different environments.<\/p>\n
For instance, you might need to use a different database for development and production. Here’s how you can employ it:<\/p>\n
import platform\n\nif platform.node() == 'dev-machine':\n    load_dotenv('.env.dev')\nelse:\n    load_dotenv('.env.prod')\n<\/code><\/pre>\n
In the code snippet above, platform.node()<\/code> returns the network name of the machine. If the network name is ‘dev-machine’, the development environment variables are loaded. Otherwise, the production environment variables are loaded.<\/p>\n
Example of loading different .env files based on the machine’s network name:<\/p>\n
import platform\nfrom dotenv import load_dotenv\n\nif platform.node() == 'dev-machine':\n    load_dotenv('.env.dev')\nelse:\n    load_dotenv('.env.prod')\n<\/code><\/pre>\n
The capability to load different sets of variables based on the code environment can be a game-changer. It enables you to segregate your development and production environments, minimizing the risk of errors and enhancing the robustness of your application.<\/p>\n
Excluding .env Files from Version Control<\/h3>\n
To further bolster security, it’s recommended to exclude your .env file from your version control system. This can be achieved by creating a .gitignore file. Here’s how you can do it:<\/p>\n
echo .env >> .gitignore\n<\/code><\/pre>\n
The above command adds ‘.env’ to your .gitignore file, ensuring that your .env file is not tracked by Git.<\/p>\n
Delving into Variable Expansions in Python-dotenv<\/h3>\n
Python-dotenv takes the management of environment variables a step further with the feature of variable expansions. This capability allows you to use the value of one environment variable within another. Here’s an illustrative example:<\/p>\n
APP_PATH=\/usr\/app\nLOG_PATH=${APP_PATH}\/logs\n<\/code><\/pre>\n
In the example above, LOG_PATH<\/code> utilizes the value of APP_PATH<\/code>. This is referred to as variable expansion, and it’s an influential feature that can render your .env files more dynamic and flexible.<\/p>\n
Example of variable expansion:<\/p>\n
from dotenv import load_dotenv\nimport os\n\nload_dotenv()\n\napp_path = os.getenv('APP_PATH')\nlog_path = os.getenv('LOG_PATH')\n\nprint(app_path) # Output: \/usr\/app\nprint(log_path) # Output: \/usr\/app\/logs\n<\/code><\/pre>\n
\n  Python-dotenv extends support for POSIX variable expansion, paving the way for dynamic configuration. This means you can use special characters like $<\/code> and :<\/code> in your environment variables, offering even more flexibility.\n<\/p><\/blockquote>\n
Integrating Python-dotenv in Django Projects<\/h3>\n
Python-dotenv isn’t limited to just standalone Python applications – it can also be integrated into Django projects. By adding load_dotenv()<\/code> to your Django settings.py file, you can load your environment variables directly into your Django project.<\/p>\n
Example of integrating python-dotenv into a Django project:<\/p>\n
# settings.py\nfrom dotenv import load_dotenv\nimport os\n\nload_dotenv()\n\nSECRET_KEY = os.getenv('SECRET_KEY')\n<\/code><\/pre>\n
Python-dotenv’s Command-Line Interface<\/h2>\n
Python-dotenv also provides a command-line interface, enabling you to interact with your .env files directly from the command line. This can be a potent tool for managing your environment variables, particularly in development environments.<\/p>\n
Here’s an example of how you can use it:<\/p>\n
# Commands within your terminal\n\n# Load the .env file\ndotenv -f \/path\/to\/your\/.env list\n\n# Set a new variable\ndotenv -f \/path\/to\/your\/.env set NEW_VARIABLE \"New Value\"\n\n# Get a variable value\ndotenv -f \/path\/to\/your\/.env get VARIABLE_NAME\n\n# Unset (delete) a variable\ndotenv -f \/path\/to\/your\/.env unset VARIABLE_NAME\n<\/code><\/pre>\n
You can replace \/path\/to\/your\/.env<\/code> with the path to your .env file, VARIABLE_NAME<\/code> with the name of the variable you want to print or delete, and NEW_VARIABLE<\/code> and \"New Value\"<\/code> with the name and value of the variable you want to set.<\/p>\n
\n  If you have installed Python-dotenv and it’s available in your system’s PATH, then you should be able to utilize it as a command-line tool just like any other shell command.\n<\/p><\/blockquote>\n
However, on some systems, depending on how your Python environment is set up, you might need to use it via the python -m switch from the command line, like so:<\/p>\n
# Load the .env file\npython -m dotenv list\n\n# Set a new variable\npython -m dotenv set NEW_VARIABLE \"New Value\"\n\n# Get a variable value\npython -m dotenv get VARIABLE_NAME\n\n# Unset (delete) a variable\npython -m dotenv unset VARIABLE_NAME\n<\/code><\/pre>\n
This will ensure that you’re using the dotenv<\/code> module that’s associated with the particular Python interpreter you’re invoking.<\/p>\n
Python-dotenv Summary: Flexibility, Security, and Convenience<\/h2>\n
As we’ve seen in this article, python-dotenv offers a high degree of flexibility when it comes to handling environment variables. Whether you want to load variables individually, load them all at once, or load them from diverse sources, python-dotenv has got you covered.<\/p>\n
But python-dotenv is not just about flexibility – it’s also about security and convenience.<\/p>\n\n\n\n\n\n\n\n
Feature<\/th>\nDescription<\/th>\n<\/tr>\n<\/thead>\n
Flexibility<\/td>\nLoad variables individually, load them all at once, or load them from diverse sources<\/td>\n<\/tr>\n
Security<\/td>\nSeparate sensitive data from application code and load it only when needed<\/td>\n<\/tr>\n
Convenience<\/td>\nSimple and intuitive API for managing environment variables<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
By allowing you to separate your sensitive data from your application code and load it only when needed, python-dotenv enhances the security of your application. Its simple and intuitive API makes managing your environment variables a breeze.<\/p>\n
Further Resources for Environment Variables<\/h3>\n
For more info on Environment Variables, Click Here<\/a> for info on Python CLI best practices for clean interfaces, which can help further your usage of Environment Variables.<\/p>\n
To further your understanding of Environment Variables we have sourced some resources that will assist you in deepening your knowledge:<\/p>\n