DEV Community

Using .env Files for Environment Variables in Python Applications

Jake Witcher on December 24, 2020

Applications are made to be deployed. At some point during development you will need to think about the environment in which your application will ...

Read full post

NK • Mar 3 '21 • Edited

Hi Jake,

I am a noob, trying to learn python along with good practices. Now the queries: The official python-dotenv documentation talks about using the dotenv alongside settings module (python-settings). The load_dotenv() function is also recommended to be put in settings.py. Unable to wrap my head around the following:

Though you have not advised it, why is it advised by many to use both? wouldn't load_dotenv work in any .py file?
While going to pipenv shell for the project, the .env file is automatically loaded. What loads the settings.py file (which has code to load dotenv)?
if .env is excluded from git via .gitignore then, is the other team developer/ tester support to make his own while looking at settings.py for what all values could have been there? and only after the error of not finding the .env file is encountered/ reading the readme.md file?
In production, the environment variables are recommended to set at OS level? Why not in the same .env file, which can be manually created?
For any environment - dev/ test/ production, the code could be written to produce a template .env file with just keys (Key=) and user (dev/ tester, prod) team member can just fill the value in before using. Is this not workable and logical way to do this?
Just looked at python-decouple (as an alternate to python-settings) , won't this is even better as it can handle datatypes as well?

Thanks.

Hirusha Adikari • Apr 17 '23

i think load_dotenv() would be enough (it always works on linux, where you would normally deploy a web app)
you will have to import it manually and use. for testing of that file by running it directly, you can put it under if name == "main"
you can add it to the docs of the program and keep a .env.example file filled with dummy values or no values at all (with just the structure)
its secure to keep it away from application's code and config files. doing this, you can ensure that the data is only accessible to the application and not to other users or processes on the same machine
haven't tried it

Thierry Njike • Mar 19 '23 • Edited

you can write inside using this

with open("$path/to/.env", 'a+') as newenv:
    newenv.write("\n$varname=$varvalue")
load_dotenv()           #load vars again to consider the new added one

Kyle Mistele • Dec 24 '20

This is a great way to store API keys or other secrets so that they’re not hard coded into your application!

Jake Witcher • Dec 24 '20

Absolutely! Thanks for pointing that out. A .env file is a great way to work on a project with those kinds of security concerns in mind without the overhead of storing that information as a system environment variable on your computer.

ilija • Sep 21 '23

Tnx for article! But there is one important caveat here: if you use Linux for example you can not use env names like HOME or NAME or LOGNAME. Because your app variables from .env file (in currently working directory) will be overwritten by the global (from Linux).

For example: in case you put in .env NAME=Michale and you are logged in as user Daniel, inside your python script os.getenv("NAME") will return Daniel instead of Michael. And most probably this is not something you want in your app....

I guess there is different ways to resolve this, but most obvious one for me is to avoid this names entirely and to use some convention like APP_NAME or APP_HOME_DIR....

Vishal Sahu • Dec 11

To read environment variables from a .env file in Python, the most commonly used library is python-dotenv. This library helps load key-value pairs from a .env file into environment variables, allowing you to access them using Python's os module. Here's a step-by-step guide:

Step 1: Install `python-dotenv`

First, ensure you have the python-dotenv package installed:

pip install python-dotenv

Step 2: Create a `.env` File

In your project directory, create a .env file with key-value pairs:

DATABASE_URL=postgres://user:password@localhost/dbname
SECRET_KEY=supersecretkey
DEBUG=True

Step 3: Load the `.env` File in Your Python Code

Use the load_dotenv method from dotenv to load the environment variables:

from dotenv import load_dotenv
import os

# Load .env file
load_dotenv()

# Access environment variables
database_url = os.getenv("DATABASE_URL")
secret_key = os.getenv("SECRET_KEY")
debug_mode = os.getenv("DEBUG")

print(f"Database URL: {database_url}")
print(f"Secret Key: {secret_key}")
print(f"Debug Mode: {debug_mode}")

Step 4: Use the Variables

Now, you can use these variables throughout your application securely without hardcoding sensitive information in your source code.

Best Practices for Using `.env` Files:

Do Not Commit .env Files: Always include .env in your .gitignore file to avoid exposing sensitive data in version control.
Use Defaults: Provide default values in your code to handle cases where environment variables are missing.
Separation of Configurations: Use separate .env files for development, testing, and production environments.

For a more detailed discussion, you can refer to the LambdaTest community thread, where we dive deeper into practical use cases and advanced tips for managing environment variables in Python applications.

10CodeDev • Dec 24 '20

Really nice writeup! I was just playing around with Python-DotEnv today.

Jake Witcher • Dec 24 '20

Thanks! While it is a very lightweight package, there’s more to it than I initially realized. I’ve primarily used it as described in the article but it does have features that allow for a few other use cases.