Browse Source
Co-authored-by: pr-submit[bot] <pr-submit[bot]@users.noreply.github.com> Co-authored-by: Yurii Motov <[email protected]> Co-authored-by: pr-push[bot] <pr-push[bot]@users.noreply.github.com>master
pr-submit[bot]
12 hours ago
committed by
GitHub
GitHub
61 changed files with 415 additions and 1475 deletions
@ -2,45 +2,49 @@ |
|||||
|
|
||||
In vielen Fällen benötigt Ihre Anwendung möglicherweise einige externe Einstellungen oder Konfigurationen, zum Beispiel geheime Schlüssel, Datenbank-Anmeldeinformationen, Anmeldeinformationen für E-Mail-Dienste, usw. |
In vielen Fällen benötigt Ihre Anwendung möglicherweise einige externe Einstellungen oder Konfigurationen, zum Beispiel geheime Schlüssel, Datenbank-Anmeldeinformationen, Anmeldeinformationen für E-Mail-Dienste, usw. |
||||
|
|
||||
Die meisten dieser Einstellungen sind variabel (können sich ändern), wie z. B. Datenbank-URLs. Und vieles könnten schützenswerte, geheime Daten sein. |
Die meisten dieser Einstellungen sind variabel (können sich ändern), wie z. B. Datenbank-URLs. Und viele könnten schützenswerte, geheime Daten sein. |
||||
|
|
||||
Aus diesem Grund werden diese üblicherweise in Umgebungsvariablen bereitgestellt, die von der Anwendung gelesen werden. |
Aus diesem Grund werden diese üblicherweise in Umgebungsvariablen bereitgestellt, die von der Anwendung gelesen werden. |
||||
|
|
||||
|
Eine **Umgebungsvariable** (auch bekannt als **Env-Var**) ist ein Wert, der außerhalb des Python-Codes, im Betriebssystem, existiert und von Ihrer Anwendung und anderen Programmen gelesen werden kann. |
||||
|
|
||||
|
Sie können eine Umgebungsvariable für einen Befehl erstellen, wenn Sie ihn ausführen. Sie werden unten die plattformspezifischen Befehle sehen. |
||||
|
|
||||
/// tip | Tipp |
/// tip | Tipp |
||||
|
|
||||
Um Umgebungsvariablen zu verstehen, können Sie [Umgebungsvariablen](../environment-variables.md) lesen. |
Lesen Sie den [Leitfaden zu Umgebungsvariablen](https://tiangolo.com/guides/environment-variables/) für eine detaillierte Erklärung, wie Umgebungsvariablen funktionieren. |
||||
|
|
||||
/// |
/// |
||||
|
|
||||
## Typen und Validierung { #types-and-validation } |
## Typen und Validierung { #types-and-validation } |
||||
|
|
||||
Diese Umgebungsvariablen können nur Text-Strings verarbeiten, da sie außerhalb von Python liegen und mit anderen Programmen und dem Rest des Systems (und sogar mit verschiedenen Betriebssystemen wie Linux, Windows, macOS) kompatibel sein müssen. |
Diese Umgebungsvariablen können nur Text-Strings verarbeiten, da sie außerhalb von Python liegen und mit anderen Programmen und dem Rest des Systems (und sogar mit verschiedenen Betriebssystemen wie Linux, Windows und macOS) kompatibel sein müssen. |
||||
|
|
||||
Das bedeutet, dass jeder in Python aus einer Umgebungsvariablen gelesene Wert ein `str` ist und jede Konvertierung in einen anderen Typ oder jede Validierung im Code erfolgen muss. |
Das bedeutet, dass jeder in Python aus einer Umgebungsvariablen gelesene Wert ein `str` ist und jede Konvertierung in einen anderen Typ oder jede Validierung im Code erfolgen muss. |
||||
|
|
||||
## Pydantic `Settings` { #pydantic-settings } |
## Pydantic `Settings` { #pydantic-settings } |
||||
|
|
||||
Glücklicherweise bietet Pydantic ein großartiges Werkzeug zur Verarbeitung dieser Einstellungen, die von Umgebungsvariablen stammen, mit [Pydantic: Settings-Verwaltung](https://docs.pydantic.dev/latest/concepts/pydantic_settings/). |
Glücklicherweise bietet Pydantic ein großartiges Werkzeug zur Verarbeitung dieser Einstellungen, die von Umgebungsvariablen stammen, mit [Pydantic: Settings-Verwaltung](https://pydantic.dev/docs/validation/latest/concepts/pydantic_settings/). |
||||
|
|
||||
### `pydantic-settings` installieren { #install-pydantic-settings } |
### `pydantic-settings` installieren { #install-pydantic-settings } |
||||
|
|
||||
Stellen Sie zunächst sicher, dass Sie Ihre [virtuelle Umgebung](../virtual-environments.md) erstellt und aktiviert haben, und installieren Sie dann das Package `pydantic-settings`: |
Fügen Sie Ihrem Projekt das Package `pydantic-settings` hinzu: |
||||
|
|
||||
<div class="termy"> |
<div class="termy"> |
||||
|
|
||||
```console |
```console |
||||
$ pip install pydantic-settings |
$ uv add pydantic-settings |
||||
---> 100% |
---> 100% |
||||
``` |
``` |
||||
|
|
||||
</div> |
</div> |
||||
|
|
||||
Es ist bereits enthalten, wenn Sie die `all`-Extras installiert haben, mit: |
Es ist auch enthalten, wenn Sie die `all`-Extras installieren mit: |
||||
|
|
||||
<div class="termy"> |
<div class="termy"> |
||||
|
|
||||
```console |
```console |
||||
$ pip install "fastapi[all]" |
$ uv add "fastapi[all]" |
||||
---> 100% |
---> 100% |
||||
``` |
``` |
||||
|
|
||||
@ -76,19 +80,39 @@ Dann können Sie das neue `settings`-Objekt in Ihrer Anwendung verwenden: |
|||||
|
|
||||
Als Nächstes würden Sie den Server ausführen und die Konfigurationen als Umgebungsvariablen übergeben. Sie könnten beispielsweise `ADMIN_EMAIL` und `APP_NAME` festlegen mit: |
Als Nächstes würden Sie den Server ausführen und die Konfigurationen als Umgebungsvariablen übergeben. Sie könnten beispielsweise `ADMIN_EMAIL` und `APP_NAME` festlegen mit: |
||||
|
|
||||
|
//// tab | Linux, macOS, Windows Bash |
||||
|
|
||||
<div class="termy"> |
<div class="termy"> |
||||
|
|
||||
```console |
```console |
||||
$ ADMIN_EMAIL="[email protected]" APP_NAME="ChimichangApp" fastapi run main.py |
$ ADMIN_EMAIL="[email protected]" APP_NAME="ChimichangApp" uv run fastapi run main.py |
||||
|
|
||||
<span style="color: green;">INFO</span>: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit) |
<span style="color: green;">INFO</span>: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit) |
||||
``` |
``` |
||||
|
|
||||
</div> |
</div> |
||||
|
|
||||
|
//// |
||||
|
|
||||
|
//// tab | Windows PowerShell |
||||
|
|
||||
|
<div class="termy"> |
||||
|
|
||||
|
```console |
||||
|
$ $Env:ADMIN_EMAIL = "[email protected]" |
||||
|
$ $Env:APP_NAME = "ChimichangApp" |
||||
|
$ uv run fastapi run main.py |
||||
|
|
||||
|
<span style="color: green;">INFO</span>: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit) |
||||
|
``` |
||||
|
|
||||
|
</div> |
||||
|
|
||||
|
//// |
||||
|
|
||||
/// tip | Tipp |
/// tip | Tipp |
||||
|
|
||||
Um mehrere Umgebungsvariablen für einen einzelnen Befehl festzulegen, trennen Sie diese einfach durch ein Leerzeichen und fügen Sie alle vor dem Befehl ein. |
In Bash trennen Sie, um mehrere Umgebungsvariablen für einen einzelnen Befehl festzulegen, diese durch ein Leerzeichen und fügen sie alle vor dem Befehl ein. |
||||
|
|
||||
/// |
/// |
||||
|
|
||||
@ -172,11 +196,11 @@ Aber eine dotenv-Datei muss nicht unbedingt genau diesen Dateinamen haben. |
|||||
|
|
||||
/// |
/// |
||||
|
|
||||
Pydantic unterstützt das Lesen dieser Dateitypen mithilfe einer externen Bibliothek. Weitere Informationen finden Sie unter [Pydantic Settings: Dotenv (.env)-Unterstützung](https://docs.pydantic.dev/latest/concepts/pydantic_settings/#dotenv-env-support). |
Pydantic unterstützt das Lesen dieser Dateitypen mithilfe einer externen Bibliothek. Weitere Informationen finden Sie unter [Pydantic Settings: Dotenv (.env)-Unterstützung](https://pydantic.dev/docs/validation/latest/concepts/pydantic_settings/#dotenv-env-support). |
||||
|
|
||||
/// tip | Tipp |
/// tip | Tipp |
||||
|
|
||||
Damit das funktioniert, müssen Sie `pip install python-dotenv` ausführen. |
Damit das funktioniert, fügen Sie Ihrem Projekt `python-dotenv` mit `uv add python-dotenv` hinzu. |
||||
|
|
||||
/// |
/// |
||||
|
|
||||
@ -197,7 +221,7 @@ Und dann aktualisieren Sie Ihre `config.py` mit: |
|||||
|
|
||||
/// tip | Tipp |
/// tip | Tipp |
||||
|
|
||||
Das Attribut `model_config` wird nur für die Pydantic-Konfiguration verwendet. Weitere Informationen finden Sie unter [Pydantic: Konzepte: Konfiguration](https://docs.pydantic.dev/latest/concepts/config/). |
Das Attribut `model_config` wird nur für die Pydantic-Konfiguration verwendet. Weitere Informationen finden Sie unter [Pydantic: Konzepte: Konfiguration](https://pydantic.dev/docs/validation/latest/concepts/config/). |
||||
|
|
||||
/// |
/// |
||||
|
|
||||
|
|||||
@ -1,298 +1,11 @@ |
|||||
# Umgebungsvariablen { #environment-variables } |
# Umgebungsvariablen { #environment-variables } |
||||
|
|
||||
/// tip | Tipp |
Eine **Umgebungsvariable** (auch bekannt als **env var**) ist ein Wert, der außerhalb Ihres Python-Codes im Betriebssystem existiert und von Ihrer Anwendung und anderen Programmen gelesen werden kann. |
||||
|
|
||||
Wenn Sie bereits wissen, was „Umgebungsvariablen“ sind und wie man sie verwendet, können Sie dies überspringen. |
FastAPI-Anwendungen verwenden häufig Umgebungsvariablen für Konfigurationen wie Datenbank-URLs, E-Mail-Zugangsdaten und Secret-Keys. |
||||
|
|
||||
/// |
Sie werden lernen, wie Sie sie für Anwendungskonfigurationen verwenden, in [Einstellungen und Umgebungsvariablen](advanced/settings.md). |
||||
|
|
||||
Eine Umgebungsvariable (auch bekannt als „**env var**“) ist eine Variable, die **außerhalb** des Python-Codes im **Betriebssystem** lebt und von Ihrem Python-Code (oder auch von anderen Programmen) gelesen werden kann. |
## Mehr erfahren { #learn-more } |
||||
|
|
||||
Umgebungsvariablen können nützlich sein, um **Einstellungen** der Anwendung zu handhaben, als Teil der **Installation** von Python usw. |
Lesen Sie den [Leitfaden zu Umgebungsvariablen](https://tiangolo.com/guides/environment-variables/) für eine detaillierte, plattformübergreifende Erklärung, einschließlich der Erstellung und des Lesens von Umgebungsvariablen und wie die `PATH`-Umgebungsvariable funktioniert. |
||||
|
|
||||
## Umgebungsvariablen erstellen und verwenden { #create-and-use-env-vars } |
|
||||
|
|
||||
Sie können Umgebungsvariablen in der **Shell (Terminal)** **erstellen** und verwenden, ohne Python zu benötigen: |
|
||||
|
|
||||
//// tab | Linux, macOS, Windows Bash |
|
||||
|
|
||||
<div class="termy"> |
|
||||
|
|
||||
```console |
|
||||
// Sie können eine Umgebungsvariable MY_NAME erstellen mit |
|
||||
$ export MY_NAME="Wade Wilson" |
|
||||
|
|
||||
// Dann können Sie sie mit anderen Programmen verwenden, etwa |
|
||||
$ echo "Hello $MY_NAME" |
|
||||
|
|
||||
Hello Wade Wilson |
|
||||
``` |
|
||||
|
|
||||
</div> |
|
||||
|
|
||||
//// |
|
||||
|
|
||||
//// tab | Windows PowerShell |
|
||||
|
|
||||
<div class="termy"> |
|
||||
|
|
||||
```console |
|
||||
// Erstellen Sie eine Umgebungsvariable MY_NAME |
|
||||
$ $Env:MY_NAME = "Wade Wilson" |
|
||||
|
|
||||
// Verwenden Sie sie mit anderen Programmen, etwa |
|
||||
$ echo "Hello $Env:MY_NAME" |
|
||||
|
|
||||
Hello Wade Wilson |
|
||||
``` |
|
||||
|
|
||||
</div> |
|
||||
|
|
||||
//// |
|
||||
|
|
||||
## Umgebungsvariablen in Python lesen { #read-env-vars-in-python } |
|
||||
|
|
||||
Sie können auch Umgebungsvariablen **außerhalb** von Python erstellen, im Terminal (oder mit jeder anderen Methode) und sie dann **in Python** lesen. |
|
||||
|
|
||||
Zum Beispiel könnten Sie eine Datei `main.py` haben mit: |
|
||||
|
|
||||
```Python hl_lines="3" |
|
||||
import os |
|
||||
|
|
||||
name = os.getenv("MY_NAME", "World") |
|
||||
print(f"Hello {name} from Python") |
|
||||
``` |
|
||||
|
|
||||
/// tip | Tipp |
|
||||
|
|
||||
Das zweite Argument von [`os.getenv()`](https://docs.python.org/3.8/library/os.html#os.getenv) ist der Defaultwert, der zurückgegeben wird. |
|
||||
|
|
||||
Wenn er nicht angegeben wird, ist er standardmäßig `None`. Hier geben wir `"World"` als den zu verwendenden Defaultwert an. |
|
||||
|
|
||||
/// |
|
||||
|
|
||||
Dann könnten Sie das Python-Programm aufrufen: |
|
||||
|
|
||||
//// tab | Linux, macOS, Windows Bash |
|
||||
|
|
||||
<div class="termy"> |
|
||||
|
|
||||
```console |
|
||||
// Hier setzen wir die Umgebungsvariable noch nicht |
|
||||
$ python main.py |
|
||||
|
|
||||
// Da wir die Umgebungsvariable nicht gesetzt haben, erhalten wir den Defaultwert |
|
||||
|
|
||||
Hello World from Python |
|
||||
|
|
||||
// Aber wenn wir zuerst eine Umgebungsvariable erstellen |
|
||||
$ export MY_NAME="Wade Wilson" |
|
||||
|
|
||||
// Und dann das Programm erneut aufrufen |
|
||||
$ python main.py |
|
||||
|
|
||||
// Jetzt kann es die Umgebungsvariable lesen |
|
||||
|
|
||||
Hello Wade Wilson from Python |
|
||||
``` |
|
||||
|
|
||||
</div> |
|
||||
|
|
||||
//// |
|
||||
|
|
||||
//// tab | Windows PowerShell |
|
||||
|
|
||||
<div class="termy"> |
|
||||
|
|
||||
```console |
|
||||
// Hier setzen wir die Umgebungsvariable noch nicht |
|
||||
$ python main.py |
|
||||
|
|
||||
// Da wir die Umgebungsvariable nicht gesetzt haben, erhalten wir den Defaultwert |
|
||||
|
|
||||
Hello World from Python |
|
||||
|
|
||||
// Aber wenn wir zuerst eine Umgebungsvariable erstellen |
|
||||
$ $Env:MY_NAME = "Wade Wilson" |
|
||||
|
|
||||
// Und dann das Programm erneut aufrufen |
|
||||
$ python main.py |
|
||||
|
|
||||
// Jetzt kann es die Umgebungsvariable lesen |
|
||||
|
|
||||
Hello Wade Wilson from Python |
|
||||
``` |
|
||||
|
|
||||
</div> |
|
||||
|
|
||||
//// |
|
||||
|
|
||||
Da Umgebungsvariablen außerhalb des Codes gesetzt werden können, aber vom Code gelesen werden können und nicht mit den restlichen Dateien gespeichert (in `git` committet) werden müssen, werden sie häufig für Konfigurationen oder **Einstellungen** verwendet. |
|
||||
|
|
||||
Sie können auch eine Umgebungsvariable nur für einen **spezifischen Programmaufruf** erstellen, die nur für dieses Programm und nur für dessen Dauer verfügbar ist. |
|
||||
|
|
||||
Um dies zu tun, erstellen Sie sie direkt vor dem Programmaufruf, in derselben Zeile: |
|
||||
|
|
||||
<div class="termy"> |
|
||||
|
|
||||
```console |
|
||||
// Erstellen Sie eine Umgebungsvariable MY_NAME in der Zeile für diesen Programmaufruf |
|
||||
$ MY_NAME="Wade Wilson" python main.py |
|
||||
|
|
||||
// Jetzt kann es die Umgebungsvariable lesen |
|
||||
|
|
||||
Hello Wade Wilson from Python |
|
||||
|
|
||||
// Die Umgebungsvariable existiert danach nicht mehr |
|
||||
$ python main.py |
|
||||
|
|
||||
Hello World from Python |
|
||||
``` |
|
||||
|
|
||||
</div> |
|
||||
|
|
||||
/// tip | Tipp |
|
||||
|
|
||||
Sie können mehr darüber lesen auf [The Twelve-Factor App: Config](https://12factor.net/config). |
|
||||
|
|
||||
/// |
|
||||
|
|
||||
## Typen und Validierung { #types-and-validation } |
|
||||
|
|
||||
Diese Umgebungsvariablen können nur **Textstrings** handhaben, da sie extern zu Python sind und kompatibel mit anderen Programmen und dem Rest des Systems (und sogar mit verschiedenen Betriebssystemen, wie Linux, Windows, macOS) sein müssen. |
|
||||
|
|
||||
Das bedeutet, dass **jeder Wert**, der in Python von einer Umgebungsvariablen gelesen wird, **ein `str` sein wird**, und jede Konvertierung in einen anderen Typ oder jede Validierung muss im Code vorgenommen werden. |
|
||||
|
|
||||
Sie werden mehr darüber lernen, wie man Umgebungsvariablen zur Handhabung von **Anwendungseinstellungen** verwendet, im [Handbuch für fortgeschrittene Benutzer – Einstellungen und Umgebungsvariablen](./advanced/settings.md). |
|
||||
|
|
||||
## `PATH`-Umgebungsvariable { #path-environment-variable } |
|
||||
|
|
||||
Es gibt eine **spezielle** Umgebungsvariable namens **`PATH`**, die von den Betriebssystemen (Linux, macOS, Windows) verwendet wird, um Programme zu finden, die ausgeführt werden sollen. |
|
||||
|
|
||||
Der Wert der Variable `PATH` ist ein langer String, der aus Verzeichnissen besteht, die auf Linux und macOS durch einen Doppelpunkt `:` und auf Windows durch ein Semikolon `;` getrennt sind. |
|
||||
|
|
||||
Zum Beispiel könnte die `PATH`-Umgebungsvariable so aussehen: |
|
||||
|
|
||||
//// tab | Linux, macOS |
|
||||
|
|
||||
```plaintext |
|
||||
/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin |
|
||||
``` |
|
||||
|
|
||||
Das bedeutet, dass das System nach Programmen in den Verzeichnissen suchen sollte: |
|
||||
|
|
||||
* `/usr/local/bin` |
|
||||
* `/usr/bin` |
|
||||
* `/bin` |
|
||||
* `/usr/sbin` |
|
||||
* `/sbin` |
|
||||
|
|
||||
//// |
|
||||
|
|
||||
//// tab | Windows |
|
||||
|
|
||||
```plaintext |
|
||||
C:\Program Files\Python312\Scripts;C:\Program Files\Python312;C:\Windows\System32 |
|
||||
``` |
|
||||
|
|
||||
Das bedeutet, dass das System nach Programmen in den Verzeichnissen suchen sollte: |
|
||||
|
|
||||
* `C:\Program Files\Python312\Scripts` |
|
||||
* `C:\Program Files\Python312` |
|
||||
* `C:\Windows\System32` |
|
||||
|
|
||||
//// |
|
||||
|
|
||||
Wenn Sie einen **Befehl** im Terminal eingeben, **sucht** das Betriebssystem nach dem Programm in **jedem dieser Verzeichnisse**, die in der `PATH`-Umgebungsvariablen aufgeführt sind. |
|
||||
|
|
||||
Zum Beispiel, wenn Sie `python` im Terminal eingeben, sucht das Betriebssystem nach einem Programm namens `python` im **ersten Verzeichnis** in dieser Liste. |
|
||||
|
|
||||
Wenn es es findet, wird es **benutzt**. Andernfalls sucht es weiter in den **anderen Verzeichnissen**. |
|
||||
|
|
||||
### Python installieren und den `PATH` aktualisieren { #installing-python-and-updating-the-path } |
|
||||
|
|
||||
Wenn Sie Python installieren, könnten Sie gefragt werden, ob Sie die `PATH`-Umgebungsvariable aktualisieren möchten. |
|
||||
|
|
||||
//// tab | Linux, macOS |
|
||||
|
|
||||
Angenommen, Sie installieren Python und es landet in einem Verzeichnis `/opt/custompython/bin`. |
|
||||
|
|
||||
Wenn Sie erlauben, die `PATH`-Umgebungsvariable zu aktualisieren, fügt der Installer `/opt/custompython/bin` zur `PATH`-Umgebungsvariable hinzu. |
|
||||
|
|
||||
Das könnte so aussehen: |
|
||||
|
|
||||
```plaintext |
|
||||
/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/custompython/bin |
|
||||
``` |
|
||||
|
|
||||
Auf diese Weise, wenn Sie `python` im Terminal eingeben, findet das System das Python-Programm in `/opt/custompython/bin` (das letzte Verzeichnis) und verwendet dieses. |
|
||||
|
|
||||
//// |
|
||||
|
|
||||
//// tab | Windows |
|
||||
|
|
||||
Angenommen, Sie installieren Python und es landet in einem Verzeichnis `C:\opt\custompython\bin`. |
|
||||
|
|
||||
Wenn Sie erlauben, die `PATH`-Umgebungsvariable zu aktualisieren, fügt der Installer `C:\opt\custompython\bin` zur `PATH`-Umgebungsvariable hinzu. |
|
||||
|
|
||||
```plaintext |
|
||||
C:\Program Files\Python312\Scripts;C:\Program Files\Python312;C:\Windows\System32;C:\opt\custompython\bin |
|
||||
``` |
|
||||
|
|
||||
Auf diese Weise, wenn Sie `python` im Terminal eingeben, findet das System das Python-Programm in `C:\opt\custompython\bin` (das letzte Verzeichnis) und verwendet dieses. |
|
||||
|
|
||||
//// |
|
||||
|
|
||||
Also, wenn Sie tippen: |
|
||||
|
|
||||
<div class="termy"> |
|
||||
|
|
||||
```console |
|
||||
$ python |
|
||||
``` |
|
||||
|
|
||||
</div> |
|
||||
|
|
||||
//// tab | Linux, macOS |
|
||||
|
|
||||
Das System wird das `python`-Programm in `/opt/custompython/bin` **finden** und es ausführen. |
|
||||
|
|
||||
Es wäre ungefähr gleichbedeutend mit der Eingabe von: |
|
||||
|
|
||||
<div class="termy"> |
|
||||
|
|
||||
```console |
|
||||
$ /opt/custompython/bin/python |
|
||||
``` |
|
||||
|
|
||||
</div> |
|
||||
|
|
||||
//// |
|
||||
|
|
||||
//// tab | Windows |
|
||||
|
|
||||
Das System wird das `python`-Programm in `C:\opt\custompython\bin\python` **finden** und es ausführen. |
|
||||
|
|
||||
Es wäre ungefähr gleichbedeutend mit der Eingabe von: |
|
||||
|
|
||||
<div class="termy"> |
|
||||
|
|
||||
```console |
|
||||
$ C:\opt\custompython\bin\python |
|
||||
``` |
|
||||
|
|
||||
</div> |
|
||||
|
|
||||
//// |
|
||||
|
|
||||
Diese Informationen werden nützlich sein, wenn Sie über [Virtuelle Umgebungen](virtual-environments.md) lernen. |
|
||||
|
|
||||
## Fazit { #conclusion } |
|
||||
|
|
||||
Mit diesem Wissen sollten Sie ein grundlegendes Verständnis davon haben, was **Umgebungsvariablen** sind und wie man sie in Python verwendet. |
|
||||
|
|
||||
Sie können auch mehr darüber in der [Wikipedia zu Umgebungsvariablen](https://en.wikipedia.org/wiki/Environment_variable) lesen. |
|
||||
|
|
||||
In vielen Fällen ist es nicht sehr offensichtlich, wie Umgebungsvariablen nützlich und sofort anwendbar sein könnten. Aber sie tauchen immer wieder in vielen verschiedenen Szenarien auf, wenn Sie entwickeln, deshalb ist es gut, darüber Bescheid zu wissen. |
|
||||
|
|
||||
Zum Beispiel werden Sie diese Informationen im nächsten Abschnitt über [Virtuelle Umgebungen](virtual-environments.md) benötigen. |
|
||||
|
|||||
@ -1,864 +1,35 @@ |
|||||
# Virtuelle Umgebungen { #virtual-environments } |
# Virtuelle Umgebungen { #virtual-environments } |
||||
|
|
||||
Wenn Sie an Python-Projekten arbeiten, sollten Sie wahrscheinlich eine **virtuelle Umgebung** (oder einen ähnlichen Mechanismus) verwenden, um die <abbr title="Python Installationspakete">Packages</abbr>, die Sie für jedes Projekt installieren, zu isolieren. |
Wenn Sie mit Python-Projekten arbeiten, sollten Sie eine **virtuelle Umgebung** verwenden, um die für jedes Projekt installierten Packages zu isolieren. |
||||
|
|
||||
/// note | Hinweis |
Für FastAPI-Projekte empfehle ich die Verwendung von [uv](https://docs.astral.sh/uv/), um das Projekt, seine Abhängigkeiten und seine virtuelle Umgebung zu verwalten. |
||||
|
|
||||
Wenn Sie bereits über virtuelle Umgebungen Bescheid wissen, wie man sie erstellt und verwendet, möchten Sie diesen Abschnitt vielleicht überspringen. 🤓 |
|
||||
|
|
||||
/// |
|
||||
|
|
||||
/// tip | Tipp |
|
||||
|
|
||||
Eine **virtuelle Umgebung** unterscheidet sich von einer **Umgebungsvariable**. |
|
||||
|
|
||||
Eine **Umgebungsvariable** ist eine Variable im System, die von Programmen verwendet werden kann. |
|
||||
|
|
||||
Eine **virtuelle Umgebung** ist ein Verzeichnis mit einigen Dateien darin. |
|
||||
|
|
||||
/// |
|
||||
|
|
||||
/// note | Hinweis |
|
||||
|
|
||||
Diese Seite wird Ihnen beibringen, wie Sie **virtuelle Umgebungen** verwenden und wie sie funktionieren. |
|
||||
|
|
||||
Wenn Sie bereit sind, ein **Tool zu verwenden, das alles für Sie verwaltet** (einschließlich der Installation von Python), probieren Sie [uv](https://github.com/astral-sh/uv). |
|
||||
|
|
||||
/// |
|
||||
|
|
||||
## Ein Projekt erstellen { #create-a-project } |
## Ein Projekt erstellen { #create-a-project } |
||||
|
|
||||
Erstellen Sie zuerst ein Verzeichnis für Ihr Projekt. |
Installieren Sie `uv` mithilfe der [offiziellen Installationsanleitung](https://docs.astral.sh/uv/getting-started/installation/) und erstellen Sie dann ein Projekt: |
||||
|
|
||||
Was ich normalerweise mache, ist, dass ich ein Verzeichnis namens `code` in meinem Home/Benutzerverzeichnis erstelle. |
|
||||
|
|
||||
Und darin erstelle ich ein Verzeichnis pro Projekt. |
|
||||
|
|
||||
<div class="termy"> |
<div class="termy"> |
||||
|
|
||||
```console |
```console |
||||
// Gehe zum Home-Verzeichnis |
$ uv init awesome-project --bare |
||||
$ cd |
|
||||
// Erstelle ein Verzeichnis für alle Ihre Code-Projekte |
|
||||
$ mkdir code |
|
||||
// Gehe in dieses Code-Verzeichnis |
|
||||
$ cd code |
|
||||
// Erstelle ein Verzeichnis für dieses Projekt |
|
||||
$ mkdir awesome-project |
|
||||
// Gehe in dieses Projektverzeichnis |
|
||||
$ cd awesome-project |
$ cd awesome-project |
||||
|
$ uv add "fastapi[standard]" |
||||
``` |
``` |
||||
|
|
||||
</div> |
</div> |
||||
|
|
||||
## Eine virtuelle Umgebung erstellen { #create-a-virtual-environment } |
`uv` erstellt automatisch eine virtuelle Umgebung für das Projekt. Sie müssen selbst keine erstellen oder aktivieren. |
||||
|
|
||||
Wenn Sie zum **ersten Mal** an einem Python-Projekt arbeiten, erstellen Sie eine virtuelle Umgebung **<dfn title="es gibt andere Optionen, dies ist eine einfache Richtlinie">innerhalb Ihres Projekts</dfn>**. |
|
||||
|
|
||||
/// tip | Tipp |
|
||||
|
|
||||
Sie müssen dies nur **einmal pro Projekt** tun, nicht jedes Mal, wenn Sie daran arbeiten. |
|
||||
|
|
||||
/// |
|
||||
|
|
||||
//// tab | `venv` |
|
||||
|
|
||||
Um eine virtuelle Umgebung zu erstellen, können Sie das `venv`-Modul verwenden, das mit Python geliefert wird. |
|
||||
|
|
||||
<div class="termy"> |
|
||||
|
|
||||
```console |
|
||||
$ python -m venv .venv |
|
||||
``` |
|
||||
|
|
||||
</div> |
|
||||
|
|
||||
/// details | Was dieser Befehl bedeutet |
|
||||
|
|
||||
* `python`: das Programm namens `python` verwenden |
|
||||
* `-m`: ein Modul als Skript aufrufen, wir geben als nächstes an, welches Modul |
|
||||
* `venv`: das Modul namens `venv` verwenden, das normalerweise mit Python installiert wird |
|
||||
* `.venv`: die virtuelle Umgebung im neuen Verzeichnis `.venv` erstellen |
|
||||
|
|
||||
/// |
|
||||
|
|
||||
//// |
|
||||
|
|
||||
//// tab | `uv` |
|
||||
|
|
||||
Wenn Sie [`uv`](https://github.com/astral-sh/uv) installiert haben, können Sie es verwenden, um eine virtuelle Umgebung zu erstellen. |
|
||||
|
|
||||
<div class="termy"> |
|
||||
|
|
||||
```console |
|
||||
$ uv venv |
|
||||
``` |
|
||||
|
|
||||
</div> |
|
||||
|
|
||||
/// tip | Tipp |
|
||||
|
|
||||
Standardmäßig erstellt `uv` eine virtuelle Umgebung in einem Verzeichnis namens `.venv`. |
|
||||
|
|
||||
Aber Sie könnten es anpassen, indem Sie ein zusätzliches Argument mit dem Verzeichnisnamen übergeben. |
|
||||
|
|
||||
/// |
|
||||
|
|
||||
//// |
|
||||
|
|
||||
Dieser Befehl erstellt eine neue virtuelle Umgebung in einem Verzeichnis namens `.venv`. |
|
||||
|
|
||||
/// details | `.venv` oder ein anderer Name |
|
||||
|
|
||||
Sie könnten die virtuelle Umgebung in einem anderen Verzeichnis erstellen, aber es ist eine Konvention, sie `.venv` zu nennen. |
|
||||
|
|
||||
/// |
|
||||
|
|
||||
## Die virtuelle Umgebung aktivieren { #activate-the-virtual-environment } |
|
||||
|
|
||||
Aktivieren Sie die neue virtuelle Umgebung, damit jeder Python-Befehl, den Sie ausführen oder jedes Paket, das Sie installieren, diese Umgebung verwendet. |
|
||||
|
|
||||
/// tip | Tipp |
|
||||
|
|
||||
Tun Sie dies **jedes Mal**, wenn Sie eine **neue Terminalsitzung** starten, um an dem Projekt zu arbeiten. |
|
||||
|
|
||||
/// |
|
||||
|
|
||||
//// tab | Linux, macOS |
|
||||
|
|
||||
<div class="termy"> |
|
||||
|
|
||||
```console |
|
||||
$ source .venv/bin/activate |
|
||||
``` |
|
||||
|
|
||||
</div> |
|
||||
|
|
||||
//// |
|
||||
|
|
||||
//// tab | Windows PowerShell |
|
||||
|
|
||||
<div class="termy"> |
|
||||
|
|
||||
```console |
|
||||
$ .venv\Scripts\Activate.ps1 |
|
||||
``` |
|
||||
|
|
||||
</div> |
|
||||
|
|
||||
//// |
|
||||
|
|
||||
//// tab | Windows Bash |
|
||||
|
|
||||
Oder wenn Sie Bash für Windows verwenden (z. B. [Git Bash](https://gitforwindows.org/)): |
|
||||
|
|
||||
<div class="termy"> |
|
||||
|
|
||||
```console |
|
||||
$ source .venv/Scripts/activate |
|
||||
``` |
|
||||
|
|
||||
</div> |
|
||||
|
|
||||
//// |
|
||||
|
|
||||
/// tip | Tipp |
|
||||
|
|
||||
Jedes Mal, wenn Sie ein **neues Paket** in dieser Umgebung installieren, aktivieren Sie die Umgebung erneut. |
|
||||
|
|
||||
So stellen Sie sicher, dass, wenn Sie ein **Terminalprogramm (<abbr title="command line interface - Kommandozeileninterface">CLI</abbr>)** verwenden, das durch dieses Paket installiert wurde, Sie das aus Ihrer virtuellen Umgebung verwenden und nicht eines, das global installiert ist, wahrscheinlich mit einer anderen Version als der, die Sie benötigen. |
|
||||
|
|
||||
/// |
|
||||
|
|
||||
## Testen, ob die virtuelle Umgebung aktiv ist { #check-the-virtual-environment-is-active } |
|
||||
|
|
||||
Testen Sie, dass die virtuelle Umgebung aktiv ist (der vorherige Befehl funktioniert hat). |
|
||||
|
|
||||
/// tip | Tipp |
|
||||
|
|
||||
Dies ist **optional**, aber es ist eine gute Möglichkeit, **zu überprüfen**, ob alles wie erwartet funktioniert und Sie die beabsichtigte virtuelle Umgebung verwenden. |
|
||||
|
|
||||
/// |
|
||||
|
|
||||
//// tab | Linux, macOS, Windows Bash |
|
||||
|
|
||||
<div class="termy"> |
|
||||
|
|
||||
```console |
|
||||
$ which python |
|
||||
|
|
||||
/home/user/code/awesome-project/.venv/bin/python |
|
||||
``` |
|
||||
|
|
||||
</div> |
|
||||
|
|
||||
Wenn es das `python`-Binary in `.venv/bin/python` anzeigt, innerhalb Ihres Projekts (in diesem Fall `awesome-project`), dann hat es funktioniert. 🎉 |
|
||||
|
|
||||
//// |
|
||||
|
|
||||
//// tab | Windows PowerShell |
Führen Sie Befehle innerhalb der Projektumgebung mit `uv run` aus, zum Beispiel: |
||||
|
|
||||
<div class="termy"> |
<div class="termy"> |
||||
|
|
||||
```console |
```console |
||||
$ Get-Command python |
$ uv run fastapi dev |
||||
|
|
||||
C:\Users\user\code\awesome-project\.venv\Scripts\python |
|
||||
``` |
``` |
||||
|
|
||||
</div> |
</div> |
||||
|
|
||||
Wenn es das `python`-Binary in `.venv\Scripts\python` anzeigt, innerhalb Ihres Projekts (in diesem Fall `awesome-project`), dann hat es funktioniert. 🎉 |
## Mehr erfahren { #learn-more } |
||||
|
|
||||
//// |
|
||||
|
|
||||
## `pip` aktualisieren { #upgrade-pip } |
|
||||
|
|
||||
/// tip | Tipp |
|
||||
|
|
||||
Wenn Sie [`uv`](https://github.com/astral-sh/uv) verwenden, würden Sie das verwenden, um Dinge zu installieren anstelle von `pip`, sodass Sie `pip` nicht aktualisieren müssen. 😎 |
|
||||
|
|
||||
/// |
|
||||
|
|
||||
Wenn Sie `pip` verwenden, um Pakete zu installieren (es wird standardmäßig mit Python geliefert), sollten Sie es auf die neueste Version **aktualisieren**. |
|
||||
|
|
||||
Viele exotische Fehler beim Installieren eines Pakets werden einfach dadurch gelöst, dass zuerst `pip` aktualisiert wird. |
|
||||
|
|
||||
/// tip | Tipp |
|
||||
|
|
||||
Normalerweise würden Sie dies **einmal** tun, unmittelbar nachdem Sie die virtuelle Umgebung erstellt haben. |
|
||||
|
|
||||
/// |
|
||||
|
|
||||
Stellen Sie sicher, dass die virtuelle Umgebung aktiv ist (mit dem obigen Befehl) und führen Sie dann aus: |
|
||||
|
|
||||
<div class="termy"> |
|
||||
|
|
||||
```console |
|
||||
$ python -m pip install --upgrade pip |
|
||||
|
|
||||
---> 100% |
|
||||
``` |
|
||||
|
|
||||
</div> |
|
||||
|
|
||||
/// tip | Tipp |
|
||||
|
|
||||
Manchmal kann beim Versuch, `pip` zu aktualisieren, der Fehler **`No module named pip`** auftreten. |
|
||||
|
|
||||
Wenn das passiert, installieren und aktualisieren Sie `pip` mit dem folgenden Befehl: |
|
||||
|
|
||||
<div class="termy"> |
|
||||
|
|
||||
```console |
|
||||
$ python -m ensurepip --upgrade |
|
||||
|
|
||||
---> 100% |
|
||||
``` |
|
||||
|
|
||||
</div> |
|
||||
|
|
||||
Dieser Befehl installiert `pip`, falls es noch nicht installiert ist, und stellt außerdem sicher, dass die installierte Version von `pip` mindestens so aktuell ist wie die in `ensurepip` verfügbare. |
|
||||
|
|
||||
/// |
|
||||
|
|
||||
## `.gitignore` hinzufügen { #add-gitignore } |
|
||||
|
|
||||
Wenn Sie **Git** verwenden (was Sie sollten), fügen Sie eine `.gitignore`-Datei hinzu, um alles in Ihrem `.venv` von Git auszuschließen. |
|
||||
|
|
||||
/// tip | Tipp |
|
||||
|
|
||||
Wenn Sie [`uv`](https://github.com/astral-sh/uv) verwendet haben, um die virtuelle Umgebung zu erstellen, hat es dies bereits für Sie getan, Sie können diesen Schritt überspringen. 😎 |
|
||||
|
|
||||
/// |
|
||||
|
|
||||
/// tip | Tipp |
|
||||
|
|
||||
Tun Sie dies **einmal**, unmittelbar nachdem Sie die virtuelle Umgebung erstellt haben. |
|
||||
|
|
||||
/// |
|
||||
|
|
||||
<div class="termy"> |
|
||||
|
|
||||
```console |
|
||||
$ echo "*" > .venv/.gitignore |
|
||||
``` |
|
||||
|
|
||||
</div> |
|
||||
|
|
||||
/// details | Was dieser Befehl bedeutet |
|
||||
|
|
||||
* `echo "*"`: wird den Text `*` im Terminal „drucken“ (der nächste Teil ändert das ein wenig) |
|
||||
* `>`: alles, was durch den Befehl links von `>` im Terminal ausgegeben wird, sollte nicht gedruckt, sondern stattdessen in die Datei geschrieben werden, die rechts von `>` kommt |
|
||||
* `.gitignore`: der Name der Datei, in die der Text geschrieben werden soll |
|
||||
|
|
||||
Und `*` bedeutet für Git „alles“. Also wird alles im `.venv`-Verzeichnis ignoriert. |
|
||||
|
|
||||
Dieser Befehl erstellt eine Datei `.gitignore` mit dem Inhalt: |
|
||||
|
|
||||
```gitignore |
|
||||
* |
|
||||
``` |
|
||||
|
|
||||
/// |
|
||||
|
|
||||
## Pakete installieren { #install-packages } |
|
||||
|
|
||||
Nachdem Sie die Umgebung aktiviert haben, können Sie Pakete darin installieren. |
|
||||
|
|
||||
/// tip | Tipp |
|
||||
|
|
||||
Tun Sie dies **einmal**, wenn Sie die Pakete installieren oder aktualisieren, die Ihr Projekt benötigt. |
|
||||
|
|
||||
Wenn Sie eine Version aktualisieren oder ein neues Paket hinzufügen müssen, würden Sie **dies erneut tun**. |
|
||||
|
|
||||
/// |
|
||||
|
|
||||
### Pakete direkt installieren { #install-packages-directly } |
|
||||
|
|
||||
Wenn Sie es eilig haben und keine Datei verwenden möchten, um die Paketanforderungen Ihres Projekts zu deklarieren, können Sie sie direkt installieren. |
|
||||
|
|
||||
/// tip | Tipp |
|
||||
|
|
||||
Es ist eine (sehr) gute Idee, die Pakete und Versionen, die Ihr Programm benötigt, in einer Datei zu speichern (zum Beispiel `requirements.txt` oder `pyproject.toml`). |
|
||||
|
|
||||
/// |
|
||||
|
|
||||
//// tab | `pip` |
|
||||
|
|
||||
<div class="termy"> |
|
||||
|
|
||||
```console |
|
||||
$ pip install "fastapi[standard]" |
|
||||
|
|
||||
---> 100% |
|
||||
``` |
|
||||
|
|
||||
</div> |
|
||||
|
|
||||
//// |
|
||||
|
|
||||
//// tab | `uv` |
|
||||
|
|
||||
Wenn Sie [`uv`](https://github.com/astral-sh/uv) haben: |
|
||||
|
|
||||
<div class="termy"> |
|
||||
|
|
||||
```console |
|
||||
$ uv pip install "fastapi[standard]" |
|
||||
---> 100% |
|
||||
``` |
|
||||
|
|
||||
</div> |
|
||||
|
|
||||
//// |
|
||||
|
|
||||
### Installation von `requirements.txt` { #install-from-requirements-txt } |
|
||||
|
|
||||
Wenn Sie eine `requirements.txt` haben, können Sie diese nun verwenden, um deren Pakete zu installieren. |
|
||||
|
|
||||
//// tab | `pip` |
|
||||
|
|
||||
<div class="termy"> |
|
||||
|
|
||||
```console |
|
||||
$ pip install -r requirements.txt |
|
||||
---> 100% |
|
||||
``` |
|
||||
|
|
||||
</div> |
|
||||
|
|
||||
//// |
|
||||
|
|
||||
//// tab | `uv` |
|
||||
|
|
||||
Wenn Sie [`uv`](https://github.com/astral-sh/uv) haben: |
|
||||
|
|
||||
<div class="termy"> |
|
||||
|
|
||||
```console |
|
||||
$ uv pip install -r requirements.txt |
|
||||
---> 100% |
|
||||
``` |
|
||||
|
|
||||
</div> |
|
||||
|
|
||||
//// |
|
||||
|
|
||||
/// details | `requirements.txt` |
|
||||
|
|
||||
Eine `requirements.txt` mit einigen Paketen könnte folgendermaßen aussehen: |
|
||||
|
|
||||
```requirements.txt |
|
||||
fastapi[standard]==0.113.0 |
|
||||
pydantic==2.8.0 |
|
||||
``` |
|
||||
|
|
||||
/// |
|
||||
|
|
||||
## Ihr Programm ausführen { #run-your-program } |
|
||||
|
|
||||
Nachdem Sie die virtuelle Umgebung aktiviert haben, können Sie Ihr Programm ausführen, und es wird das Python innerhalb Ihrer virtuellen Umgebung mit den Paketen verwenden, die Sie dort installiert haben. |
|
||||
|
|
||||
<div class="termy"> |
|
||||
|
|
||||
```console |
|
||||
$ python main.py |
|
||||
|
|
||||
Hello World |
|
||||
``` |
|
||||
|
|
||||
</div> |
|
||||
|
|
||||
## Ihren Editor konfigurieren { #configure-your-editor } |
|
||||
|
|
||||
Sie würden wahrscheinlich einen Editor verwenden, stellen Sie sicher, dass Sie ihn so konfigurieren, dass er dieselbe virtuelle Umgebung verwendet, die Sie erstellt haben (er wird sie wahrscheinlich automatisch erkennen), sodass Sie Autovervollständigungen und Inline-Fehler erhalten können. |
|
||||
|
|
||||
Zum Beispiel: |
|
||||
|
|
||||
* [VS Code](https://code.visualstudio.com/docs/python/environments#_select-and-activate-an-environment) |
|
||||
* [PyCharm](https://www.jetbrains.com/help/pycharm/creating-virtual-environment.html) |
|
||||
|
|
||||
/// tip | Tipp |
|
||||
|
|
||||
Normalerweise müssen Sie dies nur **einmal** tun, wenn Sie die virtuelle Umgebung erstellen. |
|
||||
|
|
||||
/// |
|
||||
|
|
||||
## Die virtuelle Umgebung deaktivieren { #deactivate-the-virtual-environment } |
|
||||
|
|
||||
Sobald Sie mit der Arbeit an Ihrem Projekt fertig sind, können Sie die virtuelle Umgebung **deaktivieren**. |
|
||||
|
|
||||
<div class="termy"> |
|
||||
|
|
||||
```console |
|
||||
$ deactivate |
|
||||
``` |
|
||||
|
|
||||
</div> |
|
||||
|
|
||||
Auf diese Weise, wenn Sie `python` ausführen, wird nicht versucht, es aus dieser virtuellen Umgebung mit den dort installierten Paketen auszuführen. |
|
||||
|
|
||||
## Bereit zu arbeiten { #ready-to-work } |
|
||||
|
|
||||
Jetzt sind Sie bereit, mit Ihrem Projekt zu arbeiten. |
|
||||
|
|
||||
|
|
||||
|
|
||||
/// tip | Tipp |
|
||||
|
|
||||
Möchten Sie verstehen, was das alles oben bedeutet? |
|
||||
|
|
||||
Lesen Sie weiter. 👇🤓 |
|
||||
|
|
||||
/// |
|
||||
|
|
||||
## Warum virtuelle Umgebungen { #why-virtual-environments } |
|
||||
|
|
||||
Um mit FastAPI zu arbeiten, müssen Sie [Python](https://www.python.org/) installieren. |
|
||||
|
|
||||
Danach müssen Sie FastAPI und alle anderen **Pakete**, die Sie verwenden möchten, **installieren**. |
|
||||
|
|
||||
Um Pakete zu installieren, würden Sie normalerweise den `pip`-Befehl verwenden, der mit Python geliefert wird (oder ähnliche Alternativen). |
|
||||
|
|
||||
Wenn Sie jedoch `pip` direkt verwenden, werden die Pakete in Ihrer **globalen Python-Umgebung** (der globalen Installation von Python) installiert. |
|
||||
|
|
||||
### Das Problem { #the-problem } |
|
||||
|
|
||||
Was ist also das Problem beim Installieren von Paketen in der globalen Python-Umgebung? |
|
||||
|
|
||||
Irgendwann werden Sie wahrscheinlich viele verschiedene Programme schreiben, die von **verschiedenen Paketen** abhängen. Und einige dieser Projekte, an denen Sie arbeiten, werden von **verschiedenen Versionen** desselben Pakets abhängen. 😱 |
|
||||
|
|
||||
Zum Beispiel könnten Sie ein Projekt namens `philosophers-stone` erstellen, dieses Programm hängt von einem anderen Paket namens **`harry`, Version `1`** ab. Also müssen Sie `harry` installieren. |
|
||||
|
|
||||
```mermaid |
|
||||
flowchart LR |
|
||||
stone(philosophers-stone) -->|benötigt| harry-1[harry v1] |
|
||||
``` |
|
||||
|
|
||||
Dann erstellen Sie zu einem späteren Zeitpunkt ein weiteres Projekt namens `prisoner-of-azkaban`, und dieses Projekt hängt ebenfalls von `harry` ab, aber dieses Projekt benötigt **`harry` Version `3`**. |
|
||||
|
|
||||
```mermaid |
|
||||
flowchart LR |
|
||||
azkaban(prisoner-of-azkaban) --> |benötigt| harry-3[harry v3] |
|
||||
``` |
|
||||
|
|
||||
Aber jetzt ist das Problem, wenn Sie die Pakete global (in der globalen Umgebung) installieren anstatt in einer lokalen **virtuellen Umgebung**, müssen Sie wählen, welche Version von `harry` zu installieren ist. |
|
||||
|
|
||||
Wenn Sie `philosophers-stone` ausführen möchten, müssen Sie zuerst `harry` Version `1` installieren, zum Beispiel mit: |
|
||||
|
|
||||
<div class="termy"> |
|
||||
|
|
||||
```console |
|
||||
$ pip install "harry==1" |
|
||||
``` |
|
||||
|
|
||||
</div> |
|
||||
|
|
||||
Und dann hätten Sie `harry` Version `1` in Ihrer globalen Python-Umgebung installiert. |
|
||||
|
|
||||
```mermaid |
|
||||
flowchart LR |
|
||||
subgraph global[globale Umgebung] |
|
||||
harry-1[harry v1] |
|
||||
end |
|
||||
subgraph stone-project[philosophers-stone-Projekt] |
|
||||
stone(philosophers-stone) -->|benötigt| harry-1 |
|
||||
end |
|
||||
``` |
|
||||
|
|
||||
Aber dann, wenn Sie `prisoner-of-azkaban` ausführen möchten, müssen Sie `harry` Version `1` deinstallieren und `harry` Version `3` installieren (oder einfach die Version `3` installieren, was die Version `1` automatisch deinstallieren würde). |
|
||||
|
|
||||
<div class="termy"> |
|
||||
|
|
||||
```console |
|
||||
$ pip install "harry==3" |
|
||||
``` |
|
||||
|
|
||||
</div> |
|
||||
|
|
||||
Und dann hätten Sie `harry` Version `3` in Ihrer globalen Python-Umgebung installiert. |
|
||||
|
|
||||
Und wenn Sie versuchen, `philosophers-stone` erneut auszuführen, besteht die Möglichkeit, dass es **nicht funktioniert**, weil es `harry` Version `1` benötigt. |
|
||||
|
|
||||
```mermaid |
|
||||
flowchart LR |
|
||||
subgraph global[globale Umgebung] |
|
||||
harry-1[<strike>harry v1</strike>] |
|
||||
style harry-1 fill:#ccc,stroke-dasharray: 5 5 |
|
||||
harry-3[harry v3] |
|
||||
end |
|
||||
subgraph stone-project[philosophers-stone-Projekt] |
|
||||
stone(philosophers-stone) -.-x|⛔️| harry-1 |
|
||||
end |
|
||||
subgraph azkaban-project[prisoner-of-azkaban-Projekt] |
|
||||
azkaban(prisoner-of-azkaban) --> |benötigt| harry-3 |
|
||||
end |
|
||||
``` |
|
||||
|
|
||||
/// tip | Tipp |
|
||||
|
|
||||
Es ist sehr üblich in Python-Paketen, alles zu versuchen, **Breaking Changes** in **neuen Versionen** zu vermeiden, aber es ist besser, auf Nummer sicher zu gehen und neue Versionen absichtlich zu installieren und wenn Sie die Tests ausführen können, sicherzustellen, dass alles korrekt funktioniert. |
|
||||
|
|
||||
/// |
|
||||
|
|
||||
Stellen Sie sich das jetzt mit **vielen** anderen **Paketen** vor, von denen alle Ihre **Projekte abhängen**. Das ist sehr schwierig zu verwalten. Und Sie würden wahrscheinlich einige Projekte mit einigen **inkompatiblen Versionen** der Pakete ausführen und nicht wissen, warum etwas nicht funktioniert. |
|
||||
|
|
||||
Darüber hinaus könnte es je nach Ihrem Betriebssystem (z. B. Linux, Windows, macOS) bereits mit installiertem Python geliefert worden sein. Und in diesem Fall hatte es wahrscheinlich einige Pakete mit bestimmten Versionen **installiert**, die von Ihrem System benötigt werden. Wenn Sie Pakete in der globalen Python-Umgebung installieren, könnten Sie einige der Programme, die mit Ihrem Betriebssystem geliefert wurden, **kaputtmachen**. |
|
||||
|
|
||||
## Wo werden Pakete installiert { #where-are-packages-installed } |
|
||||
|
|
||||
Wenn Sie Python installieren, werden einige Verzeichnisse mit einigen Dateien auf Ihrem Rechner erstellt. |
|
||||
|
|
||||
Einige dieser Verzeichnisse sind dafür zuständig, alle Pakete, die Sie installieren, aufzunehmen. |
|
||||
|
|
||||
Wenn Sie ausführen: |
|
||||
|
|
||||
<div class="termy"> |
|
||||
|
|
||||
```console |
|
||||
// Führen Sie dies jetzt nicht aus, es ist nur ein Beispiel 🤓 |
|
||||
$ pip install "fastapi[standard]" |
|
||||
---> 100% |
|
||||
``` |
|
||||
|
|
||||
</div> |
|
||||
|
|
||||
Das lädt eine komprimierte Datei mit dem FastAPI-Code herunter, normalerweise von [PyPI](https://pypi.org/project/fastapi/). |
|
||||
|
|
||||
Es wird auch Dateien für andere Pakete **herunterladen**, von denen FastAPI abhängt. |
|
||||
|
|
||||
Dann wird es all diese Dateien **extrahieren** und sie in ein Verzeichnis auf Ihrem Rechner legen. |
|
||||
|
|
||||
Standardmäßig werden diese heruntergeladenen und extrahierten Dateien in das Verzeichnis gelegt, das mit Ihrer Python-Installation kommt, das ist die **globale Umgebung**. |
|
||||
|
|
||||
## Was sind virtuelle Umgebungen { #what-are-virtual-environments } |
|
||||
|
|
||||
Die Lösung für die Probleme, alle Pakete in der globalen Umgebung zu haben, besteht darin, eine **virtuelle Umgebung für jedes Projekt** zu verwenden, an dem Sie arbeiten. |
|
||||
|
|
||||
Eine virtuelle Umgebung ist ein **Verzeichnis**, sehr ähnlich zu dem globalen, in dem Sie die Pakete für ein Projekt installieren können. |
|
||||
|
|
||||
Auf diese Weise hat jedes Projekt seine eigene virtuelle Umgebung (`.venv`-Verzeichnis) mit seinen eigenen Paketen. |
|
||||
|
|
||||
```mermaid |
|
||||
flowchart TB |
|
||||
subgraph stone-project[philosophers-stone-Projekt] |
|
||||
stone(philosophers-stone) --->|benötigt| harry-1 |
|
||||
subgraph venv1[.venv] |
|
||||
harry-1[harry v1] |
|
||||
end |
|
||||
end |
|
||||
subgraph azkaban-project[prisoner-of-azkaban-Projekt] |
|
||||
azkaban(prisoner-of-azkaban) --->|benötigt| harry-3 |
|
||||
subgraph venv2[.venv] |
|
||||
harry-3[harry v3] |
|
||||
end |
|
||||
end |
|
||||
stone-project ~~~ azkaban-project |
|
||||
``` |
|
||||
|
|
||||
## Was bedeutet das Aktivieren einer virtuellen Umgebung { #what-does-activating-a-virtual-environment-mean } |
|
||||
|
|
||||
Wenn Sie eine virtuelle Umgebung aktivieren, zum Beispiel mit: |
|
||||
|
|
||||
//// tab | Linux, macOS |
|
||||
|
|
||||
<div class="termy"> |
|
||||
|
|
||||
```console |
|
||||
$ source .venv/bin/activate |
|
||||
``` |
|
||||
|
|
||||
</div> |
|
||||
|
|
||||
//// |
|
||||
|
|
||||
//// tab | Windows PowerShell |
|
||||
|
|
||||
<div class="termy"> |
|
||||
|
|
||||
```console |
|
||||
$ .venv\Scripts\Activate.ps1 |
|
||||
``` |
|
||||
|
|
||||
</div> |
|
||||
|
|
||||
//// |
|
||||
|
|
||||
//// tab | Windows Bash |
|
||||
|
|
||||
Oder wenn Sie Bash für Windows verwenden (z. B. [Git Bash](https://gitforwindows.org/)): |
|
||||
|
|
||||
<div class="termy"> |
|
||||
|
|
||||
```console |
|
||||
$ source .venv/Scripts/activate |
|
||||
``` |
|
||||
|
|
||||
</div> |
|
||||
|
|
||||
//// |
|
||||
|
|
||||
Dieser Befehl erstellt oder ändert einige [Umgebungsvariablen](environment-variables.md), die für die nächsten Befehle verfügbar sein werden. |
|
||||
|
|
||||
Eine dieser Variablen ist die `PATH`-Variable. |
|
||||
|
|
||||
/// tip | Tipp |
|
||||
|
|
||||
Sie können mehr über die `PATH`-Umgebungsvariable im Abschnitt [Umgebungsvariablen](environment-variables.md#path-environment-variable) erfahren. |
|
||||
|
|
||||
/// |
|
||||
|
|
||||
Das Aktivieren einer virtuellen Umgebung fügt deren Pfad `.venv/bin` (auf Linux und macOS) oder `.venv\Scripts` (auf Windows) zur `PATH`-Umgebungsvariable hinzu. |
|
||||
|
|
||||
Angenommen, die `PATH`-Variable sah vor dem Aktivieren der Umgebung so aus: |
|
||||
|
|
||||
//// tab | Linux, macOS |
|
||||
|
|
||||
```plaintext |
|
||||
/usr/bin:/bin:/usr/sbin:/sbin |
|
||||
``` |
|
||||
|
|
||||
Das bedeutet, dass das System nach Programmen sucht in: |
|
||||
|
|
||||
* `/usr/bin` |
|
||||
* `/bin` |
|
||||
* `/usr/sbin` |
|
||||
* `/sbin` |
|
||||
|
|
||||
//// |
|
||||
|
|
||||
//// tab | Windows |
|
||||
|
|
||||
```plaintext |
|
||||
C:\Windows\System32 |
|
||||
``` |
|
||||
|
|
||||
Das bedeutet, dass das System nach Programmen sucht in: |
|
||||
|
|
||||
* `C:\Windows\System32` |
|
||||
|
|
||||
//// |
|
||||
|
|
||||
Nach dem Aktivieren der virtuellen Umgebung würde die `PATH`-Variable folgendermaßen aussehen: |
|
||||
|
|
||||
//// tab | Linux, macOS |
|
||||
|
|
||||
```plaintext |
|
||||
/home/user/code/awesome-project/.venv/bin:/usr/bin:/bin:/usr/sbin:/sbin |
|
||||
``` |
|
||||
|
|
||||
Das bedeutet, dass das System nun zuerst nach Programmen sucht in: |
|
||||
|
|
||||
```plaintext |
|
||||
/home/user/code/awesome-project/.venv/bin |
|
||||
``` |
|
||||
|
|
||||
bevor es in den anderen Verzeichnissen sucht. |
|
||||
|
|
||||
Wenn Sie also `python` im Terminal eingeben, wird das System das Python-Programm in |
|
||||
|
|
||||
```plaintext |
|
||||
/home/user/code/awesome-project/.venv/bin/python |
|
||||
``` |
|
||||
|
|
||||
finden und dieses verwenden. |
|
||||
|
|
||||
//// |
|
||||
|
|
||||
//// tab | Windows |
|
||||
|
|
||||
```plaintext |
|
||||
C:\Users\user\code\awesome-project\.venv\Scripts;C:\Windows\System32 |
|
||||
``` |
|
||||
|
|
||||
Das bedeutet, dass das System nun zuerst nach Programmen sucht in: |
|
||||
|
|
||||
```plaintext |
|
||||
C:\Users\user\code\awesome-project\.venv\Scripts |
|
||||
``` |
|
||||
|
|
||||
bevor es in den anderen Verzeichnissen sucht. |
|
||||
|
|
||||
Wenn Sie also `python` im Terminal eingeben, wird das System das Python-Programm in |
|
||||
|
|
||||
```plaintext |
|
||||
C:\Users\user\code\awesome-project\.venv\Scripts\python |
|
||||
``` |
|
||||
|
|
||||
finden und dieses verwenden. |
|
||||
|
|
||||
//// |
|
||||
|
|
||||
Ein wichtiger Punkt ist, dass es den Pfad der virtuellen Umgebung am **Anfang** der `PATH`-Variable platziert. Das System wird es **vor** allen anderen verfügbaren Pythons finden. Auf diese Weise, wenn Sie `python` ausführen, wird das Python **aus der virtuellen Umgebung** verwendet anstelle eines anderen `python` (zum Beispiel, einem `python` aus einer globalen Umgebung). |
|
||||
|
|
||||
Das Aktivieren einer virtuellen Umgebung ändert auch ein paar andere Dinge, aber dies ist eines der wichtigsten Dinge, die es tut. |
|
||||
|
|
||||
## Testen einer virtuellen Umgebung { #checking-a-virtual-environment } |
|
||||
|
|
||||
Wenn Sie testen, ob eine virtuelle Umgebung aktiv ist, zum Beispiel mit: |
|
||||
|
|
||||
//// tab | Linux, macOS, Windows Bash |
|
||||
|
|
||||
<div class="termy"> |
|
||||
|
|
||||
```console |
|
||||
$ which python |
|
||||
|
|
||||
/home/user/code/awesome-project/.venv/bin/python |
|
||||
``` |
|
||||
|
|
||||
</div> |
|
||||
|
|
||||
//// |
|
||||
|
|
||||
//// tab | Windows PowerShell |
|
||||
|
|
||||
<div class="termy"> |
|
||||
|
|
||||
```console |
|
||||
$ Get-Command python |
|
||||
|
|
||||
C:\Users\user\code\awesome-project\.venv\Scripts\python |
|
||||
``` |
|
||||
|
|
||||
</div> |
|
||||
|
|
||||
//// |
|
||||
|
|
||||
bedeutet das, dass das `python`-Programm, das verwendet wird, das in der **virtuellen Umgebung** ist. |
|
||||
|
|
||||
Sie verwenden `which` auf Linux und macOS und `Get-Command` in Windows PowerShell. |
|
||||
|
|
||||
So funktioniert dieser Befehl: Er wird in der `PATH`-Umgebungsvariable nachsehen und **jeden Pfad in der Reihenfolge durchgehen**, um das Programm namens `python` zu finden. Sobald er es findet, wird er Ihnen **den Pfad** zu diesem Programm anzeigen. |
|
||||
|
|
||||
Der wichtigste Punkt ist, dass, wenn Sie `python` aufrufen, genau dieses „`python`“ ausgeführt wird. |
|
||||
|
|
||||
So können Sie überprüfen, ob Sie sich in der richtigen virtuellen Umgebung befinden. |
|
||||
|
|
||||
/// tip | Tipp |
|
||||
|
|
||||
Es ist einfach, eine virtuelle Umgebung zu aktivieren, ein Python zu bekommen und dann **zu einem anderen Projekt zu wechseln**. |
|
||||
|
|
||||
Und das zweite Projekt **würde nicht funktionieren**, weil Sie das **falsche Python** verwenden, aus einer virtuellen Umgebung für ein anderes Projekt. |
|
||||
|
|
||||
Es ist nützlich, überprüfen zu können, welches `python` verwendet wird. 🤓 |
|
||||
|
|
||||
/// |
|
||||
|
|
||||
## Warum eine virtuelle Umgebung deaktivieren { #why-deactivate-a-virtual-environment } |
|
||||
|
|
||||
Zum Beispiel könnten Sie an einem Projekt `philosophers-stone` arbeiten, diese virtuelle Umgebung **aktivieren**, Pakete installieren und mit dieser Umgebung arbeiten. |
|
||||
|
|
||||
Und dann möchten Sie an **einem anderen Projekt** `prisoner-of-azkaban` arbeiten. |
|
||||
|
|
||||
Sie gehen zu diesem Projekt: |
|
||||
|
|
||||
<div class="termy"> |
|
||||
|
|
||||
```console |
|
||||
$ cd ~/code/prisoner-of-azkaban |
|
||||
``` |
|
||||
|
|
||||
</div> |
|
||||
|
|
||||
Wenn Sie die virtuelle Umgebung für `philosophers-stone` nicht deaktivieren, wird beim Ausführen von `python` im Terminal versucht, das Python von `philosophers-stone` zu verwenden. |
|
||||
|
|
||||
<div class="termy"> |
|
||||
|
|
||||
```console |
|
||||
$ cd ~/code/prisoner-of-azkaban |
|
||||
|
|
||||
$ python main.py |
|
||||
|
|
||||
// Fehler beim Importieren von sirius, es ist nicht installiert 😱 |
|
||||
Traceback (most recent call last): |
|
||||
File "main.py", line 1, in <module> |
|
||||
import sirius |
|
||||
``` |
|
||||
|
|
||||
</div> |
|
||||
|
|
||||
Wenn Sie jedoch die virtuelle Umgebung deaktivieren und die neue für `prisoner-of-azkaban` aktivieren, wird beim Ausführen von `python` das Python aus der virtuellen Umgebung in `prisoner-of-azkaban` verwendet. |
|
||||
|
|
||||
<div class="termy"> |
|
||||
|
|
||||
```console |
|
||||
$ cd ~/code/prisoner-of-azkaban |
|
||||
|
|
||||
// Sie müssen nicht im alten Verzeichnis sein, um zu deaktivieren, Sie können dies überall tun, sogar nachdem Sie zum anderen Projekt gewechselt haben 😎 |
|
||||
$ deactivate |
|
||||
|
|
||||
// Die virtuelle Umgebung in prisoner-of-azkaban/.venv 🚀 aktivieren |
|
||||
$ source .venv/bin/activate |
|
||||
|
|
||||
// Jetzt, wenn Sie python ausführen, wird das Paket sirius in dieser virtuellen Umgebung gefunden ✨ |
|
||||
$ python main.py |
|
||||
|
|
||||
I solemnly swear 🐺 |
|
||||
``` |
|
||||
|
|
||||
</div> |
|
||||
|
|
||||
## Alternativen { #alternatives } |
|
||||
|
|
||||
Dies ist ein einfacher Leitfaden, um Ihnen den Einstieg zu erleichtern und Ihnen beizubringen, wie alles **unter der Haube** funktioniert. |
|
||||
|
|
||||
Es gibt viele **Alternativen** zur Verwaltung von virtuellen Umgebungen, Paketabhängigkeiten (Anforderungen), Projekten. |
|
||||
|
|
||||
Sobald Sie bereit sind und ein Tool verwenden möchten, das **das gesamte Projekt verwaltet**, Paketabhängigkeiten, virtuelle Umgebungen usw., würde ich Ihnen vorschlagen, [uv](https://github.com/astral-sh/uv) auszuprobieren. |
|
||||
|
|
||||
`uv` kann viele Dinge tun, es kann: |
|
||||
|
|
||||
* **Python für Sie installieren**, einschließlich verschiedener Versionen |
|
||||
* Die **virtuelle Umgebung** für Ihre Projekte verwalten |
|
||||
* **Pakete installieren** |
|
||||
* Paket**abhängigkeiten und Versionen** für Ihr Projekt verwalten |
|
||||
* Sicherstellen, dass Sie eine **exakte** Menge an Paketen und Versionen zur Installation haben, einschließlich ihrer Abhängigkeiten, damit Sie sicher sein können, dass Sie Ihr Projekt in der Produktionsumgebung genauso ausführen können wie auf Ihrem Rechner während der Entwicklung, dies wird **Locking** genannt |
|
||||
* Und viele andere Dinge |
|
||||
|
|
||||
## Fazit { #conclusion } |
|
||||
|
|
||||
Wenn Sie das alles gelesen und verstanden haben, wissen Sie jetzt **viel mehr** über virtuelle Umgebungen als viele Entwickler da draußen. 🤓 |
|
||||
|
|
||||
Das Wissen über diese Details wird in Zukunft wahrscheinlich nützlich sein, wenn Sie etwas debuggen, das komplex erscheint, aber Sie werden wissen, **wie alles unter der Haube funktioniert**. 😎 |
Lesen Sie den [Leitfaden zu virtuellen Umgebungen](https://tiangolo.com/guides/virtual-environments/), um zu erfahren, wie virtuelle Umgebungen unter der Haube funktionieren, einschließlich Aktivierung und dem alternativen `python -m venv`- und `pip`-Workflow. |
||||
|
|||||
Loading…
Reference in new issue