Kurs
Python Umgebungsvariablen: Was du wissen musst
Umgebungsvariablen sind leistungsstarke Mechanismen, um Konfigurationsdetails deines Entwicklungsprojekts flexibel und sicher zu speichern. Sie speichern Schlüssel-Wert-Paare von Daten, auf die Programmiersprachen wie Python zugreifen können, und halten diese Informationen vor neugierigen Blicken verborgen. In diesem Lernprogramm lernst du die wichtigsten Konzepte und Techniken kennen, um Umgebungsvariablen in Python zu erstellen und zu verwalten.
Was sind Umgebungsvariablen?
Umgebungsvariablen sind Name-Wert-Paare, die an einem sicheren Ort in deinem Betriebssystem gespeichert sind. Meistens sehen sie so aus:
API_KEY=1akn4nka-aqwej3
In Python kannst du solche Variablen verwenden, um sensible Informationen über dein Entwicklungsprojekt zu speichern. Sensible Informationen können sein:
- API-Schlüssel für den Zugriff auf die Anwendungen anderer
- Benutzernamen und Passwörter, um sich über Skripte bei Anwendungen anzumelden
- Datenbank-Anmeldeinformationen
- alles, was ein Sicherheitsproblem verursachen könnte, wenn es versehentlich offengelegt wird.
Wenn du zum Beispiel ein Python-Skript schreibst, das offen deine AWS-Anmeldedaten verwendet, und dieses Skript versehentlich auf GitHub einstellst, besteht die Möglichkeit, dass böswillige Parteien es entdecken und deine AWS-Rechnung erheblich erhöhen (das ist bekannt).
Ein weiterer Vorteil von Umgebungsvariablen ist ihre Konfigurierbarkeit. Du kannst Einstellungen (Datenbank-URLs, Dateipfade) ganz einfach anpassen, indem du Umgebungsvariablen veränderst, ohne deinen Code zu ändern. Diese Funktion ist besonders hilfreich, wenn du die gleiche Einstellung in mehreren Teilen deines Projekts verwendest.
Lernen wir also, wie man mit ihnen in Python arbeitet.
Wie man Umgebungsvariablen in Pythons os-Modul abruft
Um bestehende Umgebungsvariablen in deinem System abzurufen, kannst du das Modul os
verwenden. Es hat die Funktion .getenv
zum Abrufen von Variablen:
import os
os.getenv("USER")
'bexgboost'
Oben habe ich den Systembenutzernamen abgefragt, der in allen Systemen enthalten ist. Es gibt viele andere wie den Heimweg:
os.getenv("HOME")
'/home/bexgboost'
Oder den Pfad zu deiner ausführbaren Conda-Datei:
os.getenv("CONDA_EXE")
'/home/bexgboost/anaconda3/bin/conda'
Wenn du also conda
Befehle ausführst, weiß dein Terminal, welche Anwendung ausgeführt werden soll.
Aber was passiert, wenn du versuchst, eine Variable abzurufen, die nicht existiert?
os.getenv("MYDATABASE")
Die Funktion .getenv()
gibt nichts zurück, aber wir können dieses Verhalten ändern. Du kannst den Parameter default
verwenden, um einen benutzerdefinierten Wert zurückzugeben, wenn eine Variable nicht existiert:
os.getenv("COMPUTER_PASSWORD", default="Nope!")
'Nope!'
Die Funktion .getenv(
) ist die beste Methode, um vorhandene Variablen abzurufen.
In anderen Quellen kannst du jedoch andere Methoden sehen, wie das Attribut .environ, das ein Wörterbuch mit allen Umgebungsvariablen zurückgibt:
current_directory = os.environ.get("PWD", None)
current_directory
'/home/bexgboost/articles/2024/4_april'
Da es sich um ein Wörterbuch handelt, kannst du die Klammerschreibweise (nicht empfohlen) oder die Funktion .get()
verwenden, um einen Wert abzurufen.
os
hat auch Zugriff auf die vielleicht wichtigste Systemvariable namens PATH. PATH
enthält die absoluten Pfade zu allen ausführbaren Dateien, die auf deinem System installiert sind, und ist daher ziemlich lang:
os.getenv("PATH")[:46]
'/home/bexgboost/.local/bin:/home/bexgboost/bin'
Jeder Pfad in PATH
wird durch einen Doppelpunkt getrennt. Zählen wir mal die Länge von PATH
auf meinem System:
def count_path_items():
items = os.getenv("PATH").split(":")
return len(items)
count_path_items()
79
79! Nicht schlecht.
Die python-dotenv Bibliothek zur effektiven Verwaltung von Umgebungsvariablen in Python
Benutzerdefinierte Umgebungsvariablen setzen
Da wir nun wissen, wie wir bestehende Variablen extrahieren können, wollen wir sehen, wie wir benutzerdefinierte Variablen setzen können. Die erste Methode ist die Verwendung des os.environ
Wörterbuchs:
# Create a new environment variable
os.environ["NEW_VARIABLE"] = "42" # Always expects a string value
os.getenv("NEW_VARIABLE")
'42'
Diese Methode ist jedoch nicht sehr nützlich, da alle neuen Variablen verloren gehen, sobald die aktuelle Sitzung beendet wird.
Zum Glück gibt es eine dauerhaftere Methode zum Speichern von Umgebungsvariablen, nämlich die .env
Dateien (ausgesprochen dot-env). Diese Dateien haben die gleiche Syntax, d.h. sie funktionieren auf allen Betriebssystemen. Hier siehst du, wie eine Beispiel-.env-Datei aussieht:
CUSTOM_API_LINK=https://myapi.com/v1/api
SNOWFLAKE_USERNAME=bexgboost
MYSQL_DATABASE_PASSWORD=as3ndf03
Im Moment werden nur drei Variablen definiert. Um diese Datei zu lesen und ihren Inhalt zu extrahieren, werden wir eine Bibliothek namens python-dotenv
verwenden:
$ pip install python-dotenv
In einem Python-Skript oder einem Jupyter-Notebook importieren wir dann die Funktion load_dotenv
und rufen sie auf:
from dotenv import load_dotenv
load_dotenv()
True
Wenn die Datei .env
im aktuellen Verzeichnis nicht gefunden wird, durchsucht sie alle übergeordneten Verzeichnisse und gibt True zurück, wenn sie gefunden wurde.
Ich habe die obige Datei .env
in meinem Heimatverzeichnis ~/.env
gespeichert; deshalb konnte load_dotenv
sie finden.
Um deine eigenen Dateien zu erstellen, kannst du den Befehl touch
im Terminal verwenden oder einen Texteditor wie VSCode benutzen:
$ touch ~/.env
Die Syntax von .env
Dateien ist ziemlich flexibel. Du kannst zum Beispiel Variablen mit mehrzeiligen Werten setzen (müssen Anführungszeichen haben):
LONG_ENV="This is an environment
variable with a long message"
Verwende Escape-Zeichen:
LONG_ENV="This value uses an \"escape character"
Du kannst die Datei auch mit Kommentaren versehen, um sie später zu überprüfen:
# You can also add comments anywhere with a hashtag
CUSTOM_API_LINK=https://myapi.com/v1/api
SNOWFLAKE_USERNAME=bexgboost
MYSQL_DATABASE_PASSWORD=as3ndf03
Es ist auch möglich, den Wert einer Variablen innerhalb einer anderen zu verwenden, indem du die ${VAR_NAME}
Syntax verwendest:
FIRST_NAME=John
LAST_NAME=Doe
FULL_NAME="I am ${FIRST_NAME} ${LAST_NAME}"
Abrufen von benutzerdefinierten Umgebungsvariablen mit python-dotenv
Das Abrufen von benutzerdefinierten Variablen ist dasselbe wie zuvor - verwende einfach das Modul os
:
import os
os.getenv("CUSTOM_API_LINK")
'https://myapi.com/v1/api'
os.getenv("SNOWFLAKE_USERNAME")
'bexgboost'
Vergewissere dich, dass du zuerst load_dotenv
anrufst.
Wenn sich deine .env
Datei an einem Ort befindet, der für load_dotenv
nicht erreichbar ist, kannst du einen direkten Pfad zu ihr angeben, wie unten beschrieben:
load_dotenv("/home/bexgboost/somewhere/unreachable/.env")
True
Arbeiten mit .env-Dateien in Jupyter
Sobald du Python-dotenv
installiert hast, musst du es nicht mehr in Python importieren, wenn du Jupyter verwendest. Die Bibliothek wird mit einer Jupyter-Magic-Methode geliefert, die sie automatisch lädt:
# Run this anywhere in the notebook to load EVs from .env
%load_ext dotenv
%dotenv
Dann kannst du das Modul os
wieder verwenden:
import os
os.getenv("SNOWFLAKE_USERNAME")
'bexgboost'
Best Practices für die Verwendung von Umgebungsvariablen in Python
In diesem Abschnitt werden wir einige Best Practices auflisten, um sicherzustellen, dass die Umgebungsvariablen sicher und vollständig nutzbar bleiben.
1. Füge immer .env
Dateien zu .gitignore
hinzu, damit du sie nicht versehentlich auf GitHub überträgst.
# Create .gitignore if it doesn't exist
$ touch .gitignore
$ echo ".env" >> .gitignore
2. Verwende bei der Definition von Variablen beschreibende Namen, die alle in Großbuchstaben geschrieben sind.
# Good
DEBUG=True
LOGGING_VERBOSITY=3
# Bad
debug=True
LV=3
3. Erstelle eine einzige .env-Datei, um systemweite Variablen zu speichern, die du in jedem Projekt brauchst.
$ touch ~/.env
4. Kontrolliere den Umfang deiner .env-Dateien. Erstelle getrennte Dateien für die verschiedenen Teile deines Entwicklungsworkflows wie unten:
$ touch development/.env.development
$ touch testing/.env.testing
$ touch production/.env.production
Die Funktion load_dotenv
wird sie erkennen.
Wenn du mehrere .env
Dateien mit unterschiedlichen Namen erstellst, ändere deine .gitignore
Datei so, dass sie alle von der Git-Indizierung ausgeschlossen werden:
# Pay attention to the asterisk *
$ echo ".env*" >> .gitignore
Fazit
In diesem Artikel haben wir alle wichtigen Konzepte und Techniken gelernt, um Umgebungsvariablen in Python effektiv zu verwalten. Wir haben herausgefunden, wie man mit dem Python OS-Modul vorhandene Variablen abruft und wie man mit der python-dotenv
Bibliothek eigene Werte erstellt. Wir haben auch gelernt, wie man .env
Dateien schreibt, die den Best Practices entsprechen.
Wenn du mehr über die Softwareentwicklung mit Python erfahren möchtest, schau dir unseren Kurs Software Engineering Principles in Python an.
Du kannst dir auch unseren Lernpfad zur Python-Programmierung ansehen, der dich mit praktischen Übungen und Projekten vom Anfänger zum fortgeschrittenen Pythonista macht.

Ich bin ein Data Science Content Creator mit über 2 Jahren Erfahrung und einem der größten Follower auf Medium. Ich schreibe gerne ausführliche Artikel über KI und ML mit einem etwas sarkastischen Stil, denn man muss etwas tun, damit sie nicht so langweilig sind. Ich habe mehr als 130 Artikel verfasst und einen DataCamp-Kurs gemacht, ein weiterer ist in Vorbereitung. Meine Inhalte wurden von über 5 Millionen Augenpaaren gesehen, von denen 20.000 zu Followern auf Medium und LinkedIn wurden.
Setze deine Python-Reise heute fort!
Lernpfad
Python Programmierung
Kurs