diff --git a/docs/de/docs/environment-variables.md b/docs/de/docs/environment-variables.md
new file mode 100644
index 000000000..52b7e33f9
--- /dev/null
+++ b/docs/de/docs/environment-variables.md
@@ -0,0 +1,298 @@
+# Umgebungsvariablen
+
+/// tip | Tipp
+
+Wenn Sie bereits wissen, was „Umgebungsvariablen“ sind und wie Sie sie verwenden, können Sie diesen Abschnitt überspringen.
+
+///
+
+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.
+
+Umgebungsvariablen können nützlich sein, um Anwendungs-**Einstellungen** zu handhaben, als Teil der **Installation** von Python, usw.
+
+## Env Vars erstellen und verwenden
+
+Sie können Umgebungsvariablen in der **Shell (Terminal)** erstellen und verwenden, ohne Python zu benötigen:
+
+//// tab | Linux, macOS, Windows Bash
+
+
+
+```console
+// Sie könnten eine Env Var MY_NAME erstellen mit
+$ export MY_NAME="Wade Wilson"
+
+// Dann könnten Sie es mit anderen Programmen verwenden, wie
+$ echo "Hello $MY_NAME"
+
+Hello Wade Wilson
+```
+
+
+
+////
+
+//// tab | Windows PowerShell
+
+
+
+```console
+// Erstellen Sie eine Env Var MY_NAME
+$ $Env:MY_NAME = "Wade Wilson"
+
+// Verwenden Sie es mit anderen Programmen, wie
+$ echo "Hello $Env:MY_NAME"
+
+Hello Wade Wilson
+```
+
+
+
+////
+
+## Env Vars in Python lesen
+
+Sie können Umgebungsvariablen auch **außerhalb** von Python, im Terminal (oder mit jeder anderen Methode) erstellen und 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()` ist der Defaultwert, der zurückgegeben wird.
+
+Wenn keiner angegeben wird, ist es `None` standardmäßig; hier geben wir `"World"` als den zu verwendenden Defaultwert an.
+
+///
+
+Dann könnten Sie dieses Python-Programm aufrufen:
+
+//// tab | Linux, macOS, Windows Bash
+
+
+
+```console
+// Hier setzen wir die Env Var noch nicht
+$ python main.py
+
+// Da wir die Env Var nicht gesetzt haben, erhalten wir den Defaultwert
+
+Hello World from Python
+
+// Aber wenn wir zuerst eine Umgebungsvariable erstellen
+$ export MY_NAME="Wade Wilson"
+
+// Und das Programm dann erneut aufrufen
+$ python main.py
+
+// Jetzt kann es die Umgebungsvariable lesen
+
+Hello Wade Wilson from Python
+```
+
+
+
+////
+
+//// tab | Windows PowerShell
+
+
+
+```console
+// Hier setzen wir die Env Var noch nicht
+$ python main.py
+
+// Da wir die Env Var nicht gesetzt haben, erhalten wir den Defaultwert
+
+Hello World from Python
+
+// Aber wenn wir zunächst eine Umgebungsvariable erstellen
+$ $Env:MY_NAME = "Wade Wilson"
+
+// Und das Programm dann erneut aufrufen
+$ python main.py
+
+// Jetzt kann es die Umgebungsvariable lesen
+
+Hello Wade Wilson from Python
+```
+
+
+
+////
+
+Da Umgebungsvariablen außerhalb des Codes gesetzt werden können, aber vom Code gelesen werden können und nicht mit den restlichen Dateien gespeichert werden müssen (über `git`), ist es üblich, sie für Konfigurationen oder **Einstellungen** zu verwenden.
+
+Sie können auch eine Umgebungsvariable nur für eine **spezifische Programmausführung** 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 Programm selbst, in derselben Zeile:
+
+
+
+```console
+// Erstellen Sie eine Env Var MY_NAME in derselben Zeile für diesen Programmaufruf
+$ MY_NAME="Wade Wilson" python main.py
+
+// Jetzt kann es die Umgebungsvariable lesen
+
+Hello Wade Wilson from Python
+
+// Die Env Var existiert danach nicht mehr
+$ python main.py
+
+Hello World from Python
+```
+
+
+
+/// tip | Tipp
+
+Sie können mehr darüber in The Twelve-Factor App: Config lesen.
+
+///
+
+## Typen und Validierung
+
+Diese Umgebungsvariablen können nur **Textstrings** handhaben, da sie extern zu Python sind und mit anderen Programmen und dem Rest des Systems (und sogar mit verschiedenen Betriebssystemen wie Linux, Windows, macOS) kompatibel sein müssen.
+
+Das bedeutet, dass **jeder Wert**, der in Python aus einer Umgebungsvariablen gelesen wird, **ein `str`** sein wird. Jede Umwandlung in einen anderen Typ oder jede Validierung muss im Code erfolgen.
+
+Sie werden mehr darüber lernen, wie Umgebungsvariablen zur Handhabung von **Anwendungseinstellungen** verwendet werden, im [Handbuch für fortgeschrittene Benutzer - Einstellungen und Umgebungsvariablen](./advanced/settings.md){.internal-link target=_blank}.
+
+## `PATH`-Umgebungsvariable
+
+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 Variablen `PATH` ist ein langer String, der aus durch Doppelpunkte `:` getrennten Verzeichnissen unter Linux und macOS besteht und unter Windows durch Semikolons `;` getrennt wird.
+
+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 in den Verzeichnissen nach Programmen 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 in den Verzeichnissen nach Programmen suchen sollte:
+
+* `C:\Program Files\Python312\Scripts`
+* `C:\Program Files\Python312`
+* `C:\Windows\System32`
+
+////
+
+Wenn Sie einen **Befehl** im Terminal eingeben, sucht das Betriebssystem das Programm in **jedem dieser Verzeichnisse**, die in der `PATH`-Umgebungsvariable 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.
+
+Findet es das Programm, wird es **verwendet**. Andernfalls sucht es weiter in den **anderen Verzeichnissen**.
+
+### Python installieren und die `PATH` aktualisieren
+
+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 ja sagen, um die `PATH`-Umgebungsvariable zu aktualisieren, wird der Installer `/opt/custompython/bin` zur `PATH`-Umgebungsvariable hinzufügen.
+
+Es könnte dann so aussehen:
+
+```plaintext
+/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/custompython/bin
+```
+
+Auf diese Weise wird das System, wenn Sie `python` im Terminal eingeben, das Python-Programm in `/opt/custompython/bin` (dem letzten Verzeichnis) finden und dieses verwenden.
+
+////
+
+//// tab | Windows
+
+Angenommen, Sie installieren Python und es endet in einem Verzeichnis `C:\opt\custompython\bin`.
+
+Wenn Sie ja sagen, um die `PATH`-Umgebungsvariable zu aktualisieren, wird der Installer `C:\opt\custompython\bin` zur `PATH` hinzugefügt.
+
+```plaintext
+C:\Program Files\Python312\Scripts;C:\Program Files\Python312;C:\Windows\System32;C:\opt\custompython\bin
+```
+
+Auf diese Weise wird das System, wenn Sie `python` im Terminal eingeben, das Python-Programm in `C:\opt\custompython\bin` (dem letzten Verzeichnis) finden und dieses verwenden.
+
+////
+
+Wenn Sie also eingeben:
+
+
+
+```console
+$ python
+```
+
+
+
+//// tab | Linux, macOS
+
+Das System wird das `python`-Programm in `/opt/custompython/bin` finden und es ausführen.
+
+Es wäre ungefähr so, als würden Sie eingeben:
+
+
+
+```console
+$ /opt/custompython/bin/python
+```
+
+
+
+////
+
+//// tab | Windows
+
+Das System wird das `python`-Programm in `C:\opt\custompython\bin\python` finden und es ausführen.
+
+Es wäre ungefähr so, als würden Sie eingeben:
+
+
+
+```console
+$ C:\opt\custompython\bin\python
+```
+
+
+
+////
+
+Diese Informationen werden nützlich sein, wenn Sie mehr über [Virtuelle Umgebungen](virtual-environments.md){.internal-link target=_blank} lernen.
+
+## Fazit
+
+Mit diesem Wissen sollten Sie nun ein grundlegendes Verständnis darüber haben, was **Umgebungsvariablen** sind und wie Sie sie in Python verwenden können.
+
+Sie können auch mehr darüber im Wikipedia-Artikel zu Umgebungsvariablen lesen.
+
+In vielen Fällen ist es nicht sehr offensichtlich, wie Umgebungsvariablen sofort nützlich und anwendbar sein können. Aber sie tauchen in vielen verschiedenen Szenarien beim Entwickeln auf, daher ist es gut, sie zu kennen.
+
+Zum Beispiel werden Sie diese Informationen im nächsten Abschnitt über [Virtuelle Umgebungen](virtual-environments.md) benötigen.
diff --git a/docs/de/docs/fastapi-cli.md b/docs/de/docs/fastapi-cli.md
new file mode 100644
index 000000000..b6f474047
--- /dev/null
+++ b/docs/de/docs/fastapi-cli.md
@@ -0,0 +1,75 @@
+# FastAPI CLI
+
+**FastAPI CLI** ist ein Befehlszeilenprogramm, mit dem Sie Ihre FastAPI-Anwendung bedienen, Ihr FastAPI-Projekt verwalten und mehr tun können.
+
+Wenn Sie FastAPI installieren (z. B. mit `pip install "fastapi[standard]"`), wird ein Package namens `fastapi-cli` eingeschlossen, dieses Package stellt den `fastapi`-Befehl im Terminal bereit.
+
+Um Ihre FastAPI-Anwendung zur Entwicklung auszuführen, können Sie den Befehl `fastapi dev` verwenden:
+
+
+
+```console
+$ fastapi dev main.py
+
+ FastAPI Entwicklungsserver wird gestartet 🚀
+
+ Suche nach Package-Dateistruktur in Verzeichnissen mit
+ __init__.py Dateien
+ Import aus /home/user/code/awesomeapp
+
+ module 🐍 main.py
+
+ code Das FastAPI-Anwendungsobjekt wird aus dem Modul mit dem
+ folgenden Code importiert:
+
+ from main import app
+
+ app Verwenden des Import Strings: main:app
+
+ server Server gestartet unter http://127.0.0.1:8000
+ server Dokumentation unter http://127.0.0.1:8000/docs
+
+ tip Läuft im Entwicklungsmodus, für die Produktion verwenden Sie:
+ fastapi run
+
+ Logs:
+
+ INFO Es wird auf Änderungen in diesen Verzeichnissen geachtet:
+ ['/home/user/code/awesomeapp']
+ INFO Uvicorn läuft auf http://127.0.0.1:8000 (Drücken Sie STRG+C zum
+ Beenden)
+ INFO Reloader-Prozess wurde gestartet [383138] unter Verwendung von WatchFiles
+ INFO Server-Prozess gestartet [383153]
+ INFO Warten auf den Start der Anwendung.
+ INFO Anwendungsstart vollständig.
+```
+
+
+
+Das Befehlszeilenprogramm namens `fastapi` ist **FastAPI CLI**.
+
+FastAPI CLI nimmt den Pfad zu Ihrem Python-Programm (z. B. `main.py`) entgegen und erkennt automatisch die `FastAPI`-Instanz (gewöhnlich `app` genannt), bestimmt den korrekten Importprozess und bedient sie dann.
+
+Für die Produktion würden Sie stattdessen `fastapi run` verwenden. 🚀
+
+Intern verwendet **FastAPI CLI** Uvicorn, einen leistungsfähigen, produktionsbereiten, ASGI-Server. 😎
+
+## `fastapi dev`
+
+Das Ausführen von `fastapi dev` startet den Entwicklungsmodus.
+
+Standardmäßig ist **auto-reload** aktiviert, was den Server automatisch neu lädt, wenn Sie Änderungen an Ihrem Code vornehmen. Dies ist ressourcenintensiv und könnte weniger stabil sein als wenn es deaktiviert ist. Sie sollten es nur zur Entwicklung verwenden. Es hört auch auf die IP-Adresse `127.0.0.1`, welche die IP für Ihren Rechner ist, um nur mit sich selbst zu kommunizieren (`localhost`).
+
+## `fastapi run`
+
+Das Ausführen von `fastapi run` startet FastAPI standardmäßig im Produktionsmodus.
+
+Standardmäßig ist **auto-reload** deaktiviert. Es hört auch auf die IP-Adresse `0.0.0.0`, was alle verfügbaren IP-Adressen bedeutet, so dass es für jeden zugänglich ist, der mit dem Rechner kommunizieren kann. So würden Sie es normalerweise in der Herstellung betreiben, zum Beispiel in einem Container.
+
+In den meisten Fällen hätten (und sollten) Sie einen „Termination Proxy“, der HTTPS für Sie oben handhabt; dies hängt davon ab, wie Sie Ihre Anwendung bereitstellen, Ihr Anbieter könnte dies für Sie tun, oder Sie müssen es selbst einrichten.
+
+/// tip | Tipp
+
+Sie können mehr darüber in der [Deployment-Dokumentation](deployment/index.md){.internal-link target=_blank} erfahren.
+
+///
diff --git a/docs/de/docs/how-to/testing-database.md b/docs/de/docs/how-to/testing-database.md
new file mode 100644
index 000000000..c556fbf31
--- /dev/null
+++ b/docs/de/docs/how-to/testing-database.md
@@ -0,0 +1,7 @@
+# Testen einer Datenbank
+
+Sie können mehr über Datenbanken, SQL und SQLModel in den SQLModel-Dokumentationen lernen. 🤓
+
+Es gibt ein Mini-Tutorial zur Verwendung von SQLModel mit FastAPI. ✨
+
+Dieses Tutorial enthält einen Abschnitt über das Testen von SQL-Datenbanken. 😎
diff --git a/docs/de/docs/tutorial/cookie-param-models.md b/docs/de/docs/tutorial/cookie-param-models.md
new file mode 100644
index 000000000..31f21775b
--- /dev/null
+++ b/docs/de/docs/tutorial/cookie-param-models.md
@@ -0,0 +1,76 @@
+# Cookie-Parameter-Modelle
+
+Wenn Sie eine Gruppe von **Cookies** haben, die zusammengehören, können Sie ein **Pydantic-Modell** erstellen, um sie zu deklarieren. 🍪
+
+Dies ermöglicht es Ihnen, das **Modell** an **mehreren Stellen wiederzuverwenden** und auch Validierungen und Metadaten für alle Parameter auf einmal zu deklarieren. 😎
+
+/// note | Hinweis
+
+Dies wird seit der FastAPI-Version `0.115.0` unterstützt. 🤓
+
+///
+
+/// tip | Tipp
+
+Diese Technik funktioniert genauso für `Query`, `Cookie` und `Header`. 😎
+
+///
+
+## Cookies mit einem Pydantic-Modell
+
+Deklarieren Sie die benötigten **Cookie**-Parameter in einem **Pydantic-Modell**, und deklarieren Sie dann den Parameter als `Cookie`:
+
+{* ../../docs_src/cookie_param_models/tutorial001_an_py310.py hl[9:12,16] *}
+
+**FastAPI** wird die Daten für **jedes Feld** aus den in der Anfrage erhaltenen **Cookies** extrahieren und Ihnen das von Ihnen definierte Pydantic-Modell bereitstellen.
+
+## Überprüfen Sie die Dokumentation
+
+Sie können die definierten Cookies in der Docs-Oberfläche unter `/docs` sehen:
+
+
+
+
+
+```console
+$ python myapp.py
+```
+
+
+
+aufgerufen wird, aber nicht ausgeführt wird, wenn eine andere Datei sie importiert, wie in:
+
+```Python
+from myapp import app
+```
+
+#### Mehr Details
+
+Angenommen, Ihre Datei heißt `myapp.py`.
+
+Wenn Sie sie mit:
+
+
+
+```console
+$ python myapp.py
+```
+
+
+
+ausführen, hat die interne Variable `__name__` in Ihrer Datei, die automatisch von Python erstellt wird, den Wert der Zeichenkette `"__main__"`.
+
+Also wird der Abschnitt:
+
+```Python
+ uvicorn.run(app, host="0.0.0.0", port=8000)
+```
+
+ausgeführt.
+
+---
+
+Das wird nicht passieren, wenn Sie dieses Modul (Datei) importieren.
+
+Wenn Sie also eine andere Datei `importer.py` mit folgendem Inhalt haben:
+
+```Python
+from myapp import app
+
+# Weiterer Code
+```
+
+wird in diesem Fall die automatisch erstellte Variable innerhalb von `myapp.py` nicht den Wert `"__main__"` für die Variable `__name__` haben.
+
+Daher wird die Zeile:
+
+```Python
+ uvicorn.run(app, host="0.0.0.0", port=8000)
+```
+
+nicht ausgeführt.
+
+/// info | Hinweis
+
+Für weitere Informationen schauen Sie in die offiziellen Python-Dokumentationen.
+
+///
+
+## Führen Sie Ihren Code mit Ihrem Debugger aus
+
+Da Sie den Uvicorn-Server direkt aus Ihrem Code heraus ausführen, können Sie Ihr Python-Programm (Ihre FastAPI-Anwendung) direkt aus dem Debugger aufrufen.
+
+---
+
+Zum Beispiel können Sie in Visual Studio Code:
+
+* Zum "Debug"-Panel gehen.
+* "Konfiguration hinzufügen..." wählen.
+* "Python" auswählen.
+* Den Debugger mit der Option "`Python: Current File (Integrated Terminal)`" ausführen.
+
+Damit wird dann der Server mit Ihrem **FastAPI**-Code gestartet, an Ihren Breakpoints angehalten usw.
+
+So könnte es aussehen:
+
+
+
+---
+
+Wenn Sie Pycharm verwenden, können Sie:
+
+* Das "Run"-Menü öffnen.
+* Die Option "Debug..." auswählen.
+* Es erscheint ein Kontextmenü.
+* Die Datei zum Debuggen auswählen (in diesem Fall `main.py`).
+
+Damit wird dann der Server mit Ihrem **FastAPI**-Code gestartet, an Ihren Breakpoints angehalten usw.
+
+So könnte es aussehen:
+
+
diff --git a/docs/de/docs/tutorial/header-param-models.md b/docs/de/docs/tutorial/header-param-models.md
new file mode 100644
index 000000000..08c011be0
--- /dev/null
+++ b/docs/de/docs/tutorial/header-param-models.md
@@ -0,0 +1,72 @@
+# Header-Parameter-Modelle
+
+Wenn Sie eine Gruppe von verwandten **Header-Parametern** haben, können Sie ein **Pydantic-Modell** erstellen, um diese zu deklarieren.
+
+Dies ermöglicht es Ihnen, das **Modell wiederzuverwenden** in **mehreren Stellen** und auch Validierungen und Metadaten für alle Parameter auf einmal zu deklarieren. 😎
+
+/// note | Hinweis
+
+Dies wird seit FastAPI-Version `0.115.0` unterstützt. 🤓
+
+///
+
+## Header-Parameter mit einem Pydantic-Modell
+
+Deklarieren Sie die **Header-Parameter**, die Sie benötigen, in einem **Pydantic-Modell** und dann den Parameter als `Header`:
+
+{* ../../docs_src/header_param_models/tutorial001_an_py310.py hl[9:14,18] *}
+
+**FastAPI** wird die Daten für **jedes Feld** aus den **Headers** in der Anfrage **extrahieren** und Ihnen das definierte Pydantic-Modell übergeben.
+
+## Überprüfen Sie die Dokumentation
+
+Sie können die erforderlichen Headers in der Dokumentationsoberfläche unter `/docs` sehen:
+
+
+
+
+
+
+
+
+
+```console
+$ pip install sqlmodel
+---> 100%
+```
+
+
+
+## Erstellen Sie die Anwendung mit einem einzigen Modell
+
+Wir erstellen zuerst die einfachste erste Version der Anwendung mit einem einzigen **SQLModel**-Modell.
+
+Später werden wir sie verbessern, indem wir die Sicherheit und die Vielseitigkeit mit **mehreren Modellen** weiter unten erhöhen. 🤓
+
+### Modelle erstellen
+
+Importieren Sie `SQLModel` und erstellen Sie ein Datenbankmodell:
+
+{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[1:11] hl[7:11] *}
+
+Die `Hero`-Klasse ist einem Pydantic-Modell sehr ähnlich (tatsächlich ist sie darunter tatsächlich *ein Pydantic-Modell*).
+
+Es gibt einige Unterschiede:
+
+* `table=True` sagt SQLModel, dass dies ein *Tabellenmodell* ist, es soll eine **Tabelle** in der SQL-Datenbank darstellen, es ist nicht nur ein *Datenmodell* (wie es jede andere reguläre Pydantic-Klasse wäre).
+
+* `Field(primary_key=True)` sagt SQLModel, dass die `id` der **Primärschlüssel** in der SQL-Datenbank ist (Sie können mehr über SQL-Primärschlüssel in den SQLModel-Dokumentationen erfahren).
+
+ Durch das Festlegen des Typs als `int | None` wird SQLModel wissen, dass diese Spalte ein `INTEGER` in der SQL-Datenbank sein sollte und dass sie `NULLABLE` sein sollte.
+
+* `Field(index=True)` sagt SQLModel, dass es einen **SQL-Index** für diese Spalte erstellen soll, der schnellere Lookups in der Datenbank ermöglicht, wenn Daten durch diese Spalte gefiltert gelesen werden.
+
+ SQLModel wird verstehen, dass etwas, das als `str` deklariert ist, eine SQL-Spalte des Typs `TEXT` (oder `VARCHAR`, abhängig von der Datenbank) sein wird.
+
+### Erstellen Sie einen Engine
+
+Eine SQLModel `engine` (darunter ist es tatsächlich eine SQLAlchemy `engine`) ist das, was die **Verbindungen** zur Datenbank hält.
+
+Sie würden **ein einzelnes `engine`-Objekt** für Ihren gesamten Code verwenden, um sich mit demselben Datenbank zu verbinden.
+
+{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[14:18] hl[14:15,17:18] *}
+
+Die Verwendung von `check_same_thread=False` erlaubt FastAPI, dieselbe SQLite-Datenbank in verschiedenen Threads zu verwenden. Dies ist notwendig, da **eine einzige Anfrage** **mehr als einen Thread** verwenden könnte (zum Beispiel in Abhängigkeiten).
+
+Keine Sorge, mit der Art und Weise, wie der Code strukturiert ist, werden wir sicherstellen, dass wir **eine einzige SQLModel-Session pro Anfrage** später verwenden, dies ist tatsächlich das, was `check_same_thread` zu erreichen versucht.
+
+### Erstellen Sie die Tabellen
+
+Dann fügen wir eine Funktion hinzu, die `SQLModel.metadata.create_all(engine)` verwendet, um die **Tabellen für alle Tabellenmodelle** zu erstellen.
+
+{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[21:22] hl[21:22] *}
+
+### Erstellen Sie eine Session-Abhängigkeit
+
+Eine **`Session`** speichert die **Objekte im Speicher** und verfolgt alle notwendigen Änderungen in den Daten, dann **verwendet sie die `engine`**, um mit der Datenbank zu kommunizieren.
+
+Wir werden eine FastAPI **Abhängigkeit** mit `yield` erstellen, die eine neue `Session` für jede Anfrage bereitstellt. Dies ist das, was sicherstellt, dass wir eine einzige Session pro Anfrage verwenden. 🤓
+
+Dann erstellen wir eine `Annotated` Abhängigkeit `SessionDep`, um den Rest des Codes zu vereinfachen, der diese Abhängigkeit nutzen wird.
+
+{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[25:30] hl[25:27,30] *}
+
+### Erstellen Sie die Datenbanktabellen beim Start
+
+Wir werden die Datenbanktabellen erstellen, wenn die Anwendung startet.
+
+{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[32:37] hl[35:37] *}
+
+Hier erstellen wir die Tabellen bei einem Anwendungsstart-Event.
+
+Für die Produktion würden Sie wahrscheinlich ein Migrationsskript verwenden, das ausgeführt wird, bevor Sie Ihre App starten. 🤓
+
+/// tip | Tipp
+
+SQLModel wird Migrationstools mit Alembic bereitstellen, aber vorerst können Sie Alembic direkt verwenden.
+
+///
+
+### Erstellen Sie einen Helden
+
+Da jedes SQLModel-Modell auch ein Pydantic-Modell ist, können Sie es in denselben **Typ-Annotationen** verwenden, die Sie für Pydantic-Modelle verwenden könnten.
+
+Wenn Sie beispielsweise einen Parameter vom Typ `Hero` deklarieren, wird er aus dem **JSON-Body** gelesen.
+
+Auf die gleiche Weise können Sie ihn als Rückgabewert der Funktion deklarieren, und dann wird die Form der Daten in der automatischen API-Dokumentations-UI angezeigt.
+
+{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[40:45] hl[40:45] *}
+
+Hier verwenden wir die `SessionDep`-Abhängigkeit (eine `Session`), um den neuen `Hero` zum `Session`-Objekt hinzuzufügen, die Änderungen in der Datenbank zu übermitteln, die Daten im `hero` zu aktualisieren und dann zurückzugeben.
+
+### Helden lesen
+
+Wir können **Helden** aus der Datenbank mit `select()` lesen. Wir können ein `limit` und `offset` einfügen, um die Ergebnisse zu paginieren.
+
+{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[48:55] hl[51:52,54] *}
+
+### Einen Helden lesen
+
+Wir können einen einzelnen **Helden** lesen.
+
+{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[58:63] hl[60] *}
+
+### Einen Helden löschen
+
+Wir können auch einen **Helden** löschen.
+
+{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[66:73] hl[71] *}
+
+### Führen Sie die App aus
+
+Sie können die App ausführen:
+
+
+
+```console
+$ fastapi dev main.py
+
+INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
+```
+
+
+
+Gehen Sie dann zur `/docs` UI, Sie werden sehen, dass **FastAPI** diese **Modelle** verwendet, um die API zu **dokumentieren**, und es wird sie verwenden, um die Daten zu **serialisieren** und zu **validieren**.
+
+
+
+
+
+```console
+$ fastapi dev main.py
+
+INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
+```
+
+
+
+Wenn Sie zur `/docs` API UI gehen, werden Sie sehen, dass diese jetzt aktualisiert wurde. Sie wird nicht erwarten, die `id` vom Client zu erhalten, wenn sie einen Helden erstellt, usw.
+
+
+
+
+
+```console
+// Gehen Sie zum Home-Verzeichnis
+$ cd
+// Erstellen Sie ein Verzeichnis für all Ihre Code-Projekte
+$ mkdir code
+// Betreten Sie dieses Code-Verzeichnis
+$ cd code
+// Erstellen Sie ein Verzeichnis für dieses Projekt
+$ mkdir awesome-project
+// Betreten Sie dieses Projektverzeichnis
+$ cd awesome-project
+```
+
+
+
+## Eine virtuelle Umgebung erstellen
+
+Wenn Sie zum **ersten Mal** an einem Python-Projekt arbeiten, erstellen Sie eine virtuelle Umgebung **innerhalb Ihres Projekts**.
+
+/// tip | Tipp
+
+Sie müssen dies **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.
+
+
+
+```console
+$ python -m venv .venv
+```
+
+
+
+/// 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` installiert haben, können Sie es verwenden, um eine virtuelle Umgebung zu erstellen.
+
+
+
+```console
+$ uv venv
+```
+
+
+
+/// 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 gibt eine Konvention, sie `.venv` zu nennen.
+
+///
+
+## Die virtuelle Umgebung aktivieren
+
+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
+
+
+
+```console
+$ source .venv/bin/activate
+```
+
+
+
+////
+
+//// tab | Windows PowerShell
+
+
+
+```console
+$ .venv\Scripts\Activate.ps1
+```
+
+
+
+////
+
+//// tab | Windows Bash
+
+Oder wenn Sie Bash für Windows verwenden (z.B. Git Bash):
+
+
+
+```console
+$ source .venv/Scripts/activate
+```
+
+
+
+////
+
+/// 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 (CLI)** 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.
+
+///
+
+## Überprüfen, ob die virtuelle Umgebung aktiv ist
+
+Überprüfen 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 virtuelle Umgebung verwenden, die Sie beabsichtigt haben.
+
+///
+
+//// tab | Linux, macOS, Windows Bash
+
+
+
+```console
+$ which python
+
+/home/user/code/awesome-project/.venv/bin/python
+```
+
+
+
+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
+
+
+
+```console
+$ Get-Command python
+
+C:\Users\user\code\awesome-project\.venv\Scripts\python
+```
+
+
+
+Wenn es das `python`-Binary in `.venv\Scripts\python` anzeigt, innerhalb Ihres Projekts (in diesem Fall `awesome-project`), dann hat es funktioniert. 🎉
+
+////
+
+## `pip` aktualisieren
+
+/// tip | Tipp
+
+Wenn Sie `uv` verwenden, würden Sie es verwenden, um Dinge zu installieren anstelle von `pip`, sodass Sie nicht `pip` 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 **upgraden**.
+
+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:
+
+
+
+```console
+$ python -m pip install --upgrade pip
+
+---> 100%
+```
+
+
+
+## `.gitignore` hinzufügen
+
+Wenn Sie **Git** verwenden (Sie sollten es tun), fügen Sie eine `.gitignore`-Datei hinzu, um alles in Ihrem `.venv` von Git auszuschließen.
+
+/// tip | Tipp
+
+Wenn Sie `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.
+
+///
+
+
+
+```console
+$ echo "*" > .venv/.gitignore
+```
+
+
+
+/// 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
+
+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
+
+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`
+
+
+
+```console
+$ pip install "fastapi[standard]"
+
+---> 100%
+```
+
+
+
+////
+
+//// tab | `uv`
+
+Wenn Sie `uv` haben:
+
+
+
+```console
+$ uv pip install "fastapi[standard]"
+---> 100%
+```
+
+
+
+////
+
+### Installation von `requirements.txt`
+
+Wenn Sie eine `requirements.txt` haben, können Sie diese nun verwenden, um deren Pakete zu installieren.
+
+//// tab | `pip`
+
+
+
+```console
+$ pip install -r requirements.txt
+---> 100%
+```
+
+
+
+////
+
+//// tab | `uv`
+
+Wenn Sie `uv` haben:
+
+
+
+```console
+$ uv pip install -r requirements.txt
+---> 100%
+```
+
+
+
+////
+
+/// 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
+
+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 dort installierten Paketen verwenden.
+
+
+
+```console
+$ python main.py
+
+Hello World
+```
+
+
+
+## Ihren Editor konfigurieren
+
+Sie würden wahrscheinlich einen Editor verwenden, stellen Sie sicher, dass Sie ihn so konfigurieren, dass er die gleiche virtuelle Umgebung verwendet, die Sie erstellt haben (es wird sie wahrscheinlich automatisch erkennen), sodass Sie Autovervollständigungen und Inline-Fehler erhalten können.
+
+Zum Beispiel:
+
+* VS Code
+* PyCharm
+
+/// tip | Tipp
+
+Normalerweise müssen Sie dies nur **einmal** tun, wenn Sie die virtuelle Umgebung erstellen.
+
+///
+
+## Die virtuelle Umgebung deaktivieren
+
+Sobald Sie mit der Arbeit an Ihrem Projekt fertig sind, können Sie die virtuelle Umgebung **deaktivieren**.
+
+
+
+```console
+$ deactivate
+```
+
+
+
+Auf diese Weise, wenn Sie `python` ausführen, wird es nicht versuchen, es aus dieser virtuellen Umgebung mit den dort installierten Paketen auszuführen.
+
+## Bereit zu arbeiten
+
+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
+
+Um mit FastAPI zu arbeiten, müssen Sie Python 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
+
+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) -->|erfordert| 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) --> |erfordert| 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:
+
+
+
+```console
+$ pip install "harry==1"
+```
+
+
+
+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) -->|erfordert| 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, würde die Version `1` automatisch deinstallieren).
+
+
+
+```console
+$ pip install "harry==3"
+```
+
+
+
+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[harry v1]
+ 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) --> |erfordert| harry-3
+ end
+```
+
+/// tip | Tipp
+
+Es ist sehr häufig in Python-Paketen, 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 sie zu testen, um 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
+
+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:
+
+
+
+```console
+// Führen Sie dies jetzt nicht aus, es ist nur ein Beispiel 🤓
+$ pip install "fastapi[standard]"
+---> 100%
+```
+
+
+
+Das lädt eine komprimierte Datei mit dem FastAPI-Code herunter, normalerweise von PyPI.
+
+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 geliefert wird, das ist die **globale Umgebung**.
+
+## Was sind virtuelle Umgebungen
+
+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**, das der globalen Umgebung sehr ähnlich ist, 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) --->|erfordert| harry-1
+ subgraph venv1[.venv]
+ harry-1[harry v1]
+ end
+ end
+ subgraph azkaban-project[prisoner-of-azkaban Projekt]
+ azkaban(prisoner-of-azkaban) --->|erfordert| harry-3
+ subgraph venv2[.venv]
+ harry-3[harry v3]
+ end
+ end
+ stone-project ~~~ azkaban-project
+```
+
+## Was bedeutet das Aktivieren einer virtuellen Umgebung
+
+Wenn Sie eine virtuelle Umgebung aktivieren, zum Beispiel mit:
+
+//// tab | Linux, macOS
+
+
+
+```console
+$ source .venv/bin/activate
+```
+
+
+
+////
+
+//// tab | Windows PowerShell
+
+
+
+```console
+$ .venv\Scripts\Activate.ps1
+```
+
+
+
+////
+
+//// tab | Windows Bash
+
+Oder wenn Sie Bash für Windows verwenden (z.B. Git Bash):
+
+
+
+```console
+$ source .venv/Scripts/activate
+```
+
+
+
+////
+
+Dieser Befehl erstellt oder modifiziert einige [Umgebungsvariablen](environment-variables.md){.internal-link target=_blank}, 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){.internal-link target=_blank} erfahren.
+
+///
+
+Das Aktivieren einer virtuellen Umgebung fügt ihren 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.
+
+## Überprüfung einer virtuellen Umgebung
+
+Wenn Sie überprüfen, ob eine virtuelle Umgebung aktiv ist, zum Beispiel mit:
+
+//// tab | Linux, macOS, Windows Bash
+
+
+
+```console
+$ which python
+
+/home/user/code/awesome-project/.venv/bin/python
+```
+
+
+
+////
+
+//// tab | Windows PowerShell
+
+
+
+```console
+$ Get-Command python
+
+C:\Users\user\code\awesome-project\.venv\Scripts\python
+```
+
+
+
+////
+
+Das bedeutet, 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.
+
+Der Befehl funktioniert so, dass er in der `PATH`-Umgebungsvariable nachgeht und durch **jeden Pfad in der Reihenfolge** geht, um nach dem Programm namens `python` zu suchen. Sobald er es findet, zeigt er Ihnen den Pfad zu diesem Programm.
+
+Das Wichtigste 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, eine Python-Version zu erhalten 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
+
+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:
+
+
+
+```console
+$ cd ~/code/prisoner-of-azkaban
+```
+
+
+
+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.
+
+
+
+```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
+ import sirius
+```
+
+
+
+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.
+
+
+
+```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 zu einem anderen Projekt gewechselt haben 😎
+$ deactivate
+
+// Aktivieren Sie die virtuelle Umgebung in prisoner-of-azkaban/.venv 🚀
+$ source .venv/bin/activate
+
+// Jetzt, wenn Sie python ausführen, wird das Paket sirius in dieser virtuellen Umgebung gefunden ✨
+$ python main.py
+
+Ich schwöre feierlich 🐺
+```
+
+
+
+## Alternativen
+
+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 virtueller Umgebungen, Paketabhängigkeiten (Anforderungen), Projekte.
+
+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 auszuprobieren.
+
+`uv` kann viele Dinge tun, es kann:
+
+* **Python installieren** für Sie, 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 **Sperren** genannt
+* Und viele andere Dinge
+
+## Fazit
+
+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 wahrscheinlich nützlich in einer zukünftigen Zeit sein, wenn Sie etwas entwickeln, das komplex erscheint, aber Sie werden wissen, **wie alles unter der Haube funktioniert**. 😎