All the same, but thats the most readable version for me:

DEBUG = (os.getenv('DEBUG', 'False') == 'True')

Here anything but True will evaluate to False. DEBUG is False unless explicitly set to True in ENV

I recommend using strtobool function

example:

DEBUG = strtobool(os.getenv("DEBUG", "false"))

You can check them in python documentation https://docs.python.org/3/distutils/apiref.html#distutils.util.strtobool

Only one problem, they raise an error if you pass the wrong value

Code

from distutils.util import strtobool

print("Value: ", strtobool("false"))

print("Value: ", strtobool("Wrong value"))

Output

Value:  0
Traceback (most recent call last):
  File "<string>", line 9, in <module>
  File "/usr/lib/python3.8/distutils/util.py", line 319, in strtobool
    raise ValueError("invalid truth value %r" % (val,))
ValueError: invalid truth value 'wrong value'

Highly recommend environs:

from environs import Env

env = Env()

MY_BOOL_VALUE = env.bool("MY_BOOL_VALUE", False)

if MY_BOOL_VALUE:
    print("MY_BOOL_VALUE was set to True.")
else:
    print("MY_BOOL_VALUE was either set to False or was not defined.")

Neither of the ways you have will work. os.environ['ENV_VAR'] alone will cause a KeyError if the key doesn't exist, and will return the value associated with the 'ENV_VAR' if it does. In either case, you'll error out, or compare to True or "true" which will always result in False (unless the value associated with the environment variable happens to be "true"; but that isn't what you're after).

To check if a mapping contains a particular key, you would use in:

if 'ENV_VAR' in os.environ:
    # It contains the key
else:
    # It doesn't contain the key

I use the following to have more strict typing and support wider boolean variations in inputs

import os

def getenv_bool(name: str, default: bool = False) -> bool:
    return os.getenv(name, str(default)).lower() in ("yes", "y", "true", "1", "t")

Usage :

feature_1=getenv_bool('FEATURE_1', False)

Another alternative that accepts either "false", "False", "true" or "True":

import os
import ast

def getenv_bool(name: str, default: str = "False"):
    raw = os.getenv(name, default).title()
    return ast.literal_eval(raw)

If you don't want to use the environs library mentioned above then strtobool is perfect for this. The only problem is it is deprecated, there does not seem to be a replacement library anywhere, but luckily it is only a few lines of simple code with no dependencies. Just implement the code:

# Copied from distutils.util.strtobool, which is deprecated
def strtobool (val):
    """Convert a string representation of truth to true (1) or false (0).

    True values are case insensitive 'y', 'yes', 't', 'true', 'on', and '1'.
    false values are case insensitive 'n', 'no', 'f', 'false', 'off', and '0'.
    Raises ValueError if 'val' is anything else.
    """
    val = val.lower()
    if val in ('y', 'yes', 't', 'true', 'on', '1'):
        return 1
    elif val in ('n', 'no', 'f', 'false', 'off', '0'):
        return 0
    else:
        raise ValueError("invalid truth value %r" % (val,))

Use it like this:

my_env_var_value = strtobool(os.getenv("ENV_VAR", "False"))

And YES, this will throw an error if the environment variable has some value that is neither true nor false. In the great majority of cases that is probably the best course of action.

Another possible solution is parse values as JSON values:

import json
import os

def getenv(name, default="null"):
    try:
        return json.loads(os.getenv(name, default))
    except json.JSONDecodeError:
        return name

The try is for cases when is not possible a direct conversion.

assert getenv("0") == 0
assert getenv("1.1") = 1.1
assert getenv("true") == True
assert getenv("Hello") = "Hello"
assert getenv('["list", "of", "strings"]') == ["list", "of", "strings"]

Here's my 2 cents: Why not use YAML?

Code:

import os, yaml

bool(yaml.load(os.getenv("MY_VAR") or "", yaml.Loader))

Test:

for val, expected in {
    "yes": True,
    "no": False,
    "on": True,
    "off": False,
    "true": True,
    "false": False,
    "1": True,
    "0": False,
    "": False,
    None: False,
}.items():
    actual = bool(yaml.load(val or "", yaml.Loader))
    assert actual == expected

I prefer to require strictly that the environment variable is set to either True or False, and to not allow so many other squishy possibilities. Also, if the variable isn't defined, I want an exception to be raised.

assert os.environ["MY_KEY"] in ("True", "False")

my_key = os.environ["MY_KEY"] == "True"

This will raise a KeyError if MY_KEY is not defined, or raise an AssertionError if it's not set to either 'True' or 'False'.

If you are doing this frequently and therefore want a function, use this:

def get_env_bool(key):
    """ Handles the case of a boolean environment variable
    """
    if not key in os.environ:
        raise KeyError(f"No environment variable {key}")

    if not os.environ[key] in ("True", "False"):
        raise AssertionError(f"Key {key} is not proper boolean: {os.environ[key]}")

    return os.environ[key] == "True"

Usage:

if get_env_bool("MY_KEY"):
   ...

Python Version: 3.9.13 (main, May 27 2022, 17:01:00)

I used solution below and it works perfect;

In your env file;

SOMEHING_ENABLED=True

and use case in your python file;

from distutils.util import strtobool

if bool(strtobool(os.getenv('SOMEHING_ENABLED'))):
   # good to go.

Not: distutils will no longer work from version 3.12

In Django, if you are using python-dotenv also make sure you don't use DEBUG in the .env file as it will always default to True when we do os.getenv("DEBUG"). Use another variable e.g DEBUG_MODE. For example:

#.env 

DEBUG_MODE = False

#settings.py 

import os
from dotenv import load_dotenv

load_dotenv()
DEBUG = os.getenv("DEBUG_MODE", False) == "True"