Browse Source

Update #13929

There are a few more changes here than necessary, because I created these translations from scratch without an existing translation and without wordlists in the German LLM, to learn which words the AI actually needs to have defined (less than expected). I then was too lazy to remove the not super necessary changes, :-D. But The translations are good, I manually checked them.

You may apply this commit on #13929. Regenerating it is not necessary.
pull/13929/head
Nils Lindemann 2 days ago
committed by Yurii Motov
parent
commit
11a66a9bae
  1. 100
      docs/de/docs/environment-variables.md
  2. 54
      docs/de/docs/fastapi-cli.md
  3. 4
      docs/de/docs/how-to/testing-database.md
  4. 36
      docs/de/docs/tutorial/cookie-param-models.md
  5. 68
      docs/de/docs/tutorial/cors.md
  6. 42
      docs/de/docs/tutorial/debugging.md
  7. 36
      docs/de/docs/tutorial/header-param-models.md
  8. 22
      docs/de/docs/tutorial/query-param-models.md
  9. 20
      docs/de/docs/tutorial/request-form-models.md
  10. 158
      docs/de/docs/tutorial/sql-databases.md
  11. 96
      docs/de/docs/virtual-environments.md

100
docs/de/docs/environment-variables.md

@ -2,15 +2,15 @@
/// tip | Tipp
Wenn Sie bereits wissen, was „Umgebungsvariablen“ sind und wie Sie sie verwenden, können Sie diesen Abschnitt überspringen.
Wenn Sie bereits wissen, was „Umgebungsvariablen“ sind und wie man sie verwendet, können Sie dies ü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.
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.
Umgebungsvariablen können nützlich sein, um **Einstellungen** der Anwendung zu handhaben, als Teil der **Installation** von Python usw.
## Env Vars erstellen und verwenden
## Erstellen und Verwenden von Umgebungsvariablen
Sie können Umgebungsvariablen in der **Shell (Terminal)** erstellen und verwenden, ohne Python zu benötigen:
@ -19,10 +19,10 @@ Sie können Umgebungsvariablen in der **Shell (Terminal)** erstellen und verwend
<div class="termy">
```console
// Sie könnten eine Env Var MY_NAME erstellen mit
// Sie können eine Umgebungsvariable MY_NAME erstellen mit
$ export MY_NAME="Wade Wilson"
// Dann könnten Sie es mit anderen Programmen verwenden, wie
// Dann können Sie sie mit anderen Programmen verwenden, etwa
$ echo "Hello $MY_NAME"
Hello Wade Wilson
@ -37,10 +37,10 @@ Hello Wade Wilson
<div class="termy">
```console
// Erstellen Sie eine Env Var MY_NAME
// Erstellen Sie eine Umgebungsvariable MY_NAME
$ $Env:MY_NAME = "Wade Wilson"
// Verwenden Sie es mit anderen Programmen, wie
// Verwenden Sie sie mit anderen Programmen, etwa
$ echo "Hello $Env:MY_NAME"
Hello Wade Wilson
@ -50,9 +50,9 @@ Hello Wade Wilson
////
## Env Vars in Python lesen
## Umgebungsvariablen 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**.
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:
@ -67,28 +67,28 @@ print(f"Hello {name} from Python")
Das zweite Argument von <a href="https://docs.python.org/3.8/library/os.html#os.getenv" class="external-link" target="_blank">`os.getenv()`</a> 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.
Wenn er nicht angegeben wird, ist er standardmäßig `None`. Hier geben wir `"World"` als den zu verwendenden Defaultwert an.
///
Dann könnten Sie dieses Python-Programm aufrufen:
Dann könnten Sie das Python-Programm aufrufen:
//// tab | Linux, macOS, Windows Bash
<div class="termy">
```console
// Hier setzen wir die Env Var noch nicht
// Hier setzen wir die Umgebungsvariable noch nicht
$ python main.py
// Da wir die Env Var nicht gesetzt haben, erhalten wir den Defaultwert
// 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 das Programm dann erneut aufrufen
// Und dann das Programm erneut aufrufen
$ python main.py
// Jetzt kann es die Umgebungsvariable lesen
@ -105,17 +105,17 @@ Hello Wade Wilson from Python
<div class="termy">
```console
// Hier setzen wir die Env Var noch nicht
// Hier setzen wir die Umgebungsvariable noch nicht
$ python main.py
// Da wir die Env Var nicht gesetzt haben, erhalten wir den Defaultwert
// Da wir die Umgebungsvariable nicht gesetzt haben, erhalten wir den Defaultwert
Hello World from Python
// Aber wenn wir zunächst eine Umgebungsvariable erstellen
// Aber wenn wir zuerst eine Umgebungsvariable erstellen
$ $Env:MY_NAME = "Wade Wilson"
// Und das Programm dann erneut aufrufen
// Und dann das Programm erneut aufrufen
$ python main.py
// Jetzt kann es die Umgebungsvariable lesen
@ -127,23 +127,23 @@ 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.
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 eine **spezifische Programmausführung** erstellen, die nur für dieses Programm und nur für dessen Dauer verfügbar ist.
Sie können auch eine Umgebungsvariable nur für einen **spezifischen Programmauruf** 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:
Um dies zu tun, erstellen Sie sie direkt vor dem Programmaufruf, in derselben Zeile:
<div class="termy">
```console
// Erstellen Sie eine Env Var MY_NAME in derselben Zeile für diesen Programmaufruf
// Erstellen Sie eine Umgebungsvariable MY_NAME in der Zeile für diesen Programmauruf
$ 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
// Die Umgebungsvariable existiert danach nicht mehr
$ python main.py
Hello World from Python
@ -153,23 +153,23 @@ Hello World from Python
/// tip | Tipp
Sie können mehr darüber in <a href="https://12factor.net/config" class="external-link" target="_blank">The Twelve-Factor App: Config</a> lesen.
Sie können mehr darüber lesen auf <a href="https://12factor.net/config" class="external-link" target="_blank">The Twelve-Factor App: Config</a>.
///
## 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.
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 aus einer Umgebungsvariablen gelesen wird, **ein `str`** sein wird. Jede Umwandlung in einen anderen Typ oder jede Validierung muss im Code erfolgen.
Das bedeutet, dass **jeder Wert**, der in Python von einer Umgebungsvariable 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 Umgebungsvariablen zur Handhabung von **Anwendungseinstellungen** verwendet werden, im [Handbuch für fortgeschrittene Benutzer - Einstellungen und Umgebungsvariablen](./advanced/settings.md){.internal-link target=_blank}.
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){.internal-link target=_blank}.
## `PATH`-Umgebungsvariable
## `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.
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:
@ -179,7 +179,7 @@ Zum Beispiel könnte die `PATH`-Umgebungsvariable so aussehen:
/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin
```
Das bedeutet, dass das System in den Verzeichnissen nach Programmen suchen sollte:
Das bedeutet, dass das System nach Programmen in den Verzeichnissen suchen sollte:
* `/usr/local/bin`
* `/usr/bin`
@ -195,7 +195,7 @@ Das bedeutet, dass das System in den Verzeichnissen nach Programmen suchen sollt
C:\Program Files\Python312\Scripts;C:\Program Files\Python312;C:\Windows\System32
```
Das bedeutet, dass das System in den Verzeichnissen nach Programmen suchen sollte:
Das bedeutet, dass das System nach Programmen in den Verzeichnissen suchen sollte:
* `C:\Program Files\Python312\Scripts`
* `C:\Program Files\Python312`
@ -203,13 +203,13 @@ Das bedeutet, dass das System in den Verzeichnissen nach Programmen suchen sollt
////
Wenn Sie einen **Befehl** im Terminal eingeben, sucht das Betriebssystem das Programm in **jedem dieser Verzeichnisse**, die in der `PATH`-Umgebungsvariable aufgeführt sind.
Wenn Sie einen **Befehl** im Terminal eingeben, **sucht** das Betriebssystem nach dem 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**.
Wenn es es findet, wird es **benutzt**. Andernfalls sucht es weiter in den **anderen Verzeichnissen**.
### Python installieren und die `PATH` aktualisieren
### Installation von Python und Aktualisierung des `PATH`
Wenn Sie Python installieren, könnten Sie gefragt werden, ob Sie die `PATH`-Umgebungsvariable aktualisieren möchten.
@ -217,33 +217,33 @@ Wenn Sie Python installieren, könnten Sie gefragt werden, ob Sie die `PATH`-Umg
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.
Wenn Sie erlauben, die `PATH` Umgebungsvariable zu aktualisieren, fügt der Installer `/opt/custompython/bin` zur `PATH` Umgebungsvariable hinzu.
Es könnte dann so aussehen:
Das könnte 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.
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 endet in einem Verzeichnis `C:\opt\custompython\bin`.
Angenommen, Sie installieren Python und es landet 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.
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 wird das System, wenn Sie `python` im Terminal eingeben, das Python-Programm in `C:\opt\custompython\bin` (dem letzten Verzeichnis) finden und dieses verwenden.
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.
////
Wenn Sie also eingeben:
Also, wenn Sie tippen:
<div class="termy">
@ -255,9 +255,9 @@ $ python
//// tab | Linux, macOS
Das System wird das `python`-Programm in `/opt/custompython/bin` finden und es ausführen.
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:
Es wäre ungefähr gleichbedeutend mit der Eingabe von:
<div class="termy">
@ -271,9 +271,9 @@ $ /opt/custompython/bin/python
//// tab | Windows
Das System wird das `python`-Programm in `C:\opt\custompython\bin\python` finden und es ausführen.
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:
Es wäre ungefähr gleichbedeutend mit der Eingabe von:
<div class="termy">
@ -285,14 +285,14 @@ $ 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.
Diese Informationen werden nützlich sein, wenn Sie ü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.
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 im <a href="https://en.wikipedia.org/wiki/Environment_variable" class="external-link" target="_blank">Wikipedia-Artikel zu Umgebungsvariablen</a> lesen.
Sie können auch mehr darüber in der <a href="https://en.wikipedia.org/wiki/Environment_variable" class="external-link" target="_blank">Wikipedia zu Umgebungsvariablen</a> 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.
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.

54
docs/de/docs/fastapi-cli.md

@ -1,72 +1,72 @@
# FastAPI CLI
**FastAPI CLI** ist ein Befehlszeilenprogramm, mit dem Sie Ihre FastAPI-Anwendung bedienen, Ihr FastAPI-Projekt verwalten und mehr tun können.
**FastAPI CLI** ist ein Kommandozeilenprogramm, mit dem Sie Ihre FastAPI-App ausliefern, Ihr FastAPI-Projekt verwalten und mehr.
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.
Wenn Sie FastAPI installieren (z. B. mit `pip install "fastapi[standard]"`), wird ein Package namens `fastapi-cli` mitgeliefert, das den Befehl `fastapi` im Terminal bereitstellt.
Um Ihre FastAPI-Anwendung zur Entwicklung auszuführen, können Sie den Befehl `fastapi dev` verwenden:
Um Ihre FastAPI-App für die Entwicklung auszuführen, können Sie den Befehl `fastapi dev` verwenden:
<div class="termy">
```console
$ <font color="#4E9A06">fastapi</font> dev <u style="text-decoration-style:solid">main.py</u>
<span style="background-color:#009485"><font color="#D3D7CF"> FastAPI </font></span> Entwicklungsserver wird gestartet 🚀
<span style="background-color:#009485"><font color="#D3D7CF"> FastAPI </font></span> Starting development server 🚀
Suche nach Package-Dateistruktur in Verzeichnissen mit
<font color="#3465A4">__init__.py</font> Dateien
Import aus <font color="#75507B">/home/user/code/</font><font color="#AD7FA8">awesomeapp</font>
Searching for package file structure from directories with
<font color="#3465A4">__init__.py</font> files
Importing from <font color="#75507B">/home/user/code/</font><font color="#AD7FA8">awesomeapp</font>
<span style="background-color:#007166"><font color="#D3D7CF"> module </font></span> 🐍 main.py
<span style="background-color:#007166"><font color="#D3D7CF"> code </font></span> Das FastAPI-Anwendungsobjekt wird aus dem Modul mit dem
folgenden Code importiert:
<span style="background-color:#007166"><font color="#D3D7CF"> code </font></span> Importing the FastAPI app object from the module with the
following code:
<u style="text-decoration-style:solid">from </u><u style="text-decoration-style:solid"><b>main</b></u><u style="text-decoration-style:solid"> import </u><u style="text-decoration-style:solid"><b>app</b></u>
<span style="background-color:#007166"><font color="#D3D7CF"> app </font></span> Verwenden des Import Strings: <font color="#3465A4">main:app</font>
<span style="background-color:#007166"><font color="#D3D7CF"> app </font></span> Using import string: <font color="#3465A4">main:app</font>
<span style="background-color:#007166"><font color="#D3D7CF"> server </font></span> Server gestartet unter <font color="#729FCF"><u style="text-decoration-style:solid">http://127.0.0.1:8000</u></font>
<span style="background-color:#007166"><font color="#D3D7CF"> server </font></span> Dokumentation unter <font color="#729FCF"><u style="text-decoration-style:solid">http://127.0.0.1:8000/docs</u></font>
<span style="background-color:#007166"><font color="#D3D7CF"> server </font></span> Server started at <font color="#729FCF"><u style="text-decoration-style:solid">http://127.0.0.1:8000</u></font>
<span style="background-color:#007166"><font color="#D3D7CF"> server </font></span> Documentation at <font color="#729FCF"><u style="text-decoration-style:solid">http://127.0.0.1:8000/docs</u></font>
<span style="background-color:#007166"><font color="#D3D7CF"> tip </font></span> Läuft im Entwicklungsmodus, für die Produktion verwenden Sie:
<span style="background-color:#007166"><font color="#D3D7CF"> tip </font></span> Running in development mode, for production use:
<b>fastapi run</b>
Logs:
<span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span> Es wird auf Änderungen in diesen Verzeichnissen geachtet:
<span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span> Will watch for changes in these directories:
<b>[</b><font color="#4E9A06">&apos;/home/user/code/awesomeapp&apos;</font><b>]</b>
<span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span> Uvicorn läuft auf <font color="#729FCF"><u style="text-decoration-style:solid">http://127.0.0.1:8000</u></font> <b>(</b>Drücken Sie STRG+C zum
Beenden<b>)</b>
<span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span> Reloader-Prozess wurde gestartet <b>[</b><font color="#34E2E2"><b>383138</b></font><b>]</b> unter Verwendung von WatchFiles
<span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span> Server-Prozess gestartet <b>[</b><font color="#34E2E2"><b>383153</b></font><b>]</b>
<span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span> Warten auf den Start der Anwendung.
<span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span> Anwendungsstart vollständig.
<span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span> Uvicorn running on <font color="#729FCF"><u style="text-decoration-style:solid">http://127.0.0.1:8000</u></font> <b>(</b>Press CTRL+C to
quit<b>)</b>
<span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span> Started reloader process <b>[</b><font color="#34E2E2"><b>383138</b></font><b>]</b> using WatchFiles
<span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span> Started server process <b>[</b><font color="#34E2E2"><b>383153</b></font><b>]</b>
<span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span> Waiting for application startup.
<span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span> Application startup complete.
```
</div>
Das Befehlszeilenprogramm namens `fastapi` ist **FastAPI CLI**.
Das Kommandozeilenprogramm namens `fastapi` ist die **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.
FastAPI-CLI nimmt den Pfad zu Ihrem Python-Programm (z. B. `main.py`), erkennt automatisch die `FastAPI`-Instanz (häufig `app` genannt), bestimmt den korrekten Importprozess und liefert diese dann aus.
Für die Produktion würden Sie stattdessen `fastapi run` verwenden. 🚀
Intern verwendet **FastAPI CLI** <a href="https://www.uvicorn.org" class="external-link" target="_blank">Uvicorn</a>, einen leistungsfähigen, produktionsbereiten, ASGI-Server. 😎
Intern verwendet die **FastAPI CLI** <a href="https://www.uvicorn.org" class="external-link" target="_blank">Uvicorn</a>, einen leistungsstarken, produktionsreifen, ASGI-Server. 😎
## `fastapi dev`
Das Ausführen von `fastapi dev` startet den Entwicklungsmodus.
Das Ausführen von `fastapi dev` startet den Entwicklermodus.
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`).
Standardmäßig ist **Autoreload** aktiviert, das 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 für die Entwicklung verwenden. Es horcht auch auf der IP-Adresse `127.0.0.1`, die die IP für Ihre Maschine 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.
Standardmäßig ist **Autoreload** deaktiviert. Es horcht auch auf der IP-Adresse `0.0.0.0`, was alle verfügbaren IP-Adressen bedeutet, so wird es öffentlich zugänglich für jeden, der mit der Maschine kommunizieren kann. So würden Sie es normalerweise in der Produktion ausführen, beispielsweise 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.
In den meisten Fällen würden (und sollten) Sie einen „Terminierungsproxy“ haben, der HTTPS für Sie verwaltet. Dies hängt davon ab, wie Sie Ihre Anwendung bereitstellen. Ihr Anbieter könnte dies für Sie erledigen, oder Sie müssen es selbst einrichten.
/// tip | Tipp

4
docs/de/docs/how-to/testing-database.md

@ -1,7 +1,7 @@
# Testen einer Datenbank
Sie können mehr über Datenbanken, SQL und SQLModel in den <a href="https://sqlmodel.tiangolo.com/" class="external-link" target="_blank">SQLModel-Dokumentationen</a> lernen. 🤓
Sie können sich über Datenbanken, SQL und SQLModel in der <a href="https://sqlmodel.tiangolo.com/" class="external-link" target="_blank">SQLModel-Dokumentation</a> informieren. 🤓
Es gibt ein Mini-<a href="https://sqlmodel.tiangolo.com/tutorial/fastapi/" class="external-link" target="_blank">Tutorial zur Verwendung von SQLModel mit FastAPI</a>. ✨
Es gibt ein kurzes <a href="https://sqlmodel.tiangolo.com/tutorial/fastapi/" class="external-link" target="_blank">Tutorial zur Verwendung von SQLModel mit FastAPI</a>. ✨
Dieses Tutorial enthält einen Abschnitt über das <a href="https://sqlmodel.tiangolo.com/tutorial/fastapi/tests/" class="external-link" target="_blank">Testen von SQL-Datenbanken</a>. 😎

36
docs/de/docs/tutorial/cookie-param-models.md

@ -1,62 +1,62 @@
# Cookie-Parameter-Modelle
Wenn Sie eine Gruppe von **Cookies** haben, die zusammengehören, können Sie ein **Pydantic-Modell** erstellen, um sie zu deklarieren. 🍪
Wenn Sie eine Gruppe von **Cookies** haben, die zusammengehören, können Sie ein **Pydantic-Modell** erstellen, um diese 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. 😎
Damit können Sie das Modell an **mehreren Stellen wiederverwenden** und auch Validierungen und Metadaten für alle Parameter gleichzeitig deklarieren. 😎
/// note | Hinweis
Dies wird seit der FastAPI-Version `0.115.0` unterstützt. 🤓
Dies wird seit FastAPI Version `0.115.0` unterstützt. 🤓
///
/// tip | Tipp
Diese Technik funktioniert genauso für `Query`, `Cookie` und `Header`. 😎
Diese gleiche Technik gilt 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`:
Deklarieren Sie die **Cookie**-Parameter, die Sie benötigen, 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.
**FastAPI** wird die Daten für **jedes Feld** aus den im Request empfangenen **Cookies** **extrahieren** und Ihnen das von Ihnen definierte Pydantic-Modell bereitstellen.
## Überprüfen Sie die Dokumentation
## Die Dokumentation überprüfen
Sie können die definierten Cookies in der Docs-Oberfläche unter `/docs` sehen:
Sie können die definierten Cookies in der Dokumentationsoberfläche unter `/docs` sehen:
<div class="screenshot">
<img src="/img/tutorial/cookie-param-models/image01.png">
</div>
/// info | Hinweis
/// info | Info
Berücksichtigen Sie, dass **Browser Cookies** auf spezielle Weise und im Hintergrund handhaben und sie **JavaScript** nicht leicht erlauben, diese zu berühren.
Bitte beachten Sie, dass Browser Cookies auf spezielle Weise und im Hintergrund bearbeiten, sodass sie **nicht** leicht **JavaScript** erlauben, diese zu berühren.
Wenn Sie zur **API-Dokumentations-Oberfläche** unter `/docs` gehen, können Sie die **Dokumentation** für Cookies für Ihre *Pfadoperationen* sehen.
Wenn Sie zur **API-Dokumentationsoberfläche** unter `/docs` gehen, können Sie die **Dokumentation** für Cookies für Ihre *Pfadoperationen* sehen.
Aber selbst wenn Sie die **Daten ausfüllen** und auf "Ausführen" klicken, werden die Cookies nicht gesendet, da die Docs-Oberfläche mit **JavaScript** arbeitet, und Sie erhalten eine **Fehlermeldung**, als ob Sie keine Werte eingegeben hätten.
Aber selbst wenn Sie die **Daten ausfüllen** und auf „Ausführen“ klicken, werden aufgrund der Tatsache, dass die Dokumentationsoberfläche mit **JavaScript** arbeitet, die Cookies nicht gesendet, und Sie werden eine **Fehlermeldung** sehen, als ob Sie keine Werte eingegeben hätten.
///
## Zusätzliche Cookies verbieten
In einigen speziellen Anwendungsfällen (vermutlich nicht sehr häufig) möchten Sie möglicherweise die Cookies, die Sie erhalten möchten, **einschränken**.
In einigen speziellen Anwendungsfällen (wahrscheinlich nicht sehr häufig) möchten Sie möglicherweise die Cookies, die Sie empfangen möchten, **einschränken**.
Ihre API hat jetzt die Macht, ihre eigene <abbr title="Das ist ein Scherz, nur für den Fall. Es hat nichts mit Cookie-Zustimmungen zu tun, aber es ist witzig, dass selbst die API die armen Cookies jetzt ablehnen kann. Haben Sie einen Cookie. 🍪">Cookie-Zustimmung</abbr> zu kontrollieren. 🤪🍪
Ihre API hat jetzt die Macht, ihre eigene <abbr title="Das ist ein Scherz, nur für den Fall. Es hat nichts mit Cookie-Einwilligungen zu tun, aber es ist witzig, dass selbst die API jetzt die armen Cookies ablehnen kann. Haben Sie einen Keks. 🍪">Cookie-Einwilligung</abbr> zu kontrollieren. 🤪🍪
Sie können die Modellkonfiguration von Pydantic verwenden, um alle `extra` Felder zu `verbieten`:
Sie können die Modellkonfiguration von Pydantic verwenden, um `extra` Felder zu verbieten (`forbid`):
{* ../../docs_src/cookie_param_models/tutorial002_an_py39.py hl[10] *}
Wenn ein Client versucht, einige **zusätzliche Cookies** zu senden, erhält er eine **Error-Response**.
Arme Cookie-Banner mit all ihrer Mühe, Ihre Zustimmung für die <abbr title="Das ist ein weiterer Scherz. Achtung: Nehmen Sie mich nicht zu ernst. Haben Sie einen Kaffee zu Ihrem Cookie. ☕">API zu bekommen, um sie abzulehnen</abbr>. 🍪
Arme Cookie-Banner, wie sie sich mühen, Ihre Einwilligung zu erhalten, dass die <abbr title="Das ist ein weiterer Scherz. Beachten Sie mich nicht. Trinken Sie einen Kaffee zu Ihrem Keks. ☕">API sie ablehnen darf</abbr>. 🍪
Wenn der Client beispielsweise versucht, ein `santa_tracker`-Cookie mit dem Wert `good-list-please` zu senden, erhält der Client eine **Error-Response**, die ihm mitteilt, dass das `santa_tracker`-<abbr title="Santa lehnt den Mangel an Cookies ab. 🎅 Okay, keine Cookie-Witze mehr.">Cookie nicht erlaubt</abbr> ist:
Wenn der Client beispielsweise versucht, ein `santa_tracker`-Cookie mit einem Wert von `good-list-please` zu senden, erhält der Client eine **Error-Response**, die ihm mitteilt, dass das `santa_tracker` <abbr title="Santa beschwert sich über den Mangel an Cookies. 🎅 Okay, keine Cookie-Witze mehr.">Cookie nicht erlaubt ist</abbr>:
```json
{
@ -73,4 +73,4 @@ Wenn der Client beispielsweise versucht, ein `santa_tracker`-Cookie mit dem Wert
## Zusammenfassung
Sie können **Pydantic-Modelle** verwenden, um <abbr title="Nehmen Sie sich einen letzten Cookie, bevor Sie gehen. 🍪">**Cookies**</abbr> in **FastAPI** zu deklarieren. 😎
Sie können **Pydantic-Modelle** verwenden, um <abbr title="Nehmen Sie einen letzten Keks, bevor Sie gehen. 🍪">**Cookies**</abbr> in **FastAPI** zu deklarieren. 😎

68
docs/de/docs/tutorial/cors.md

@ -1,88 +1,88 @@
# CORS (Cross-Origin Resource Sharing)
<a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS" class="external-link" target="_blank">CORS oder „Cross-Origin Resource Sharing“</a> bezieht sich auf die Situationen, in denen ein Frontend, das in einem Browser läuft, JavaScript-Code enthält, der mit einem Backend kommuniziert, und das Backend sich in einem anderen „Ursprung“ als das Frontend befindet.
<a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS" class="external-link" target="_blank">CORS oder „Cross-Origin Resource Sharing“</a> (deutsch: Ursprungsübergreifende Ressourcenfreigabe) bezieht sich auf Situationen, in denen ein Frontend, das in einem Browser läuft, JavaScript-Code enthält, der mit einem Backend kommuniziert, und das Backend sich in einem anderen „Origin“ als das Frontend befindet.
## Ursprung
## Origin
Ein Ursprung ist die Kombination aus Protokoll (`http`, `https`), Domain (`myapp.com`, `localhost`, `localhost.tiangolo.com`) und Port (`80`, `443`, `8080`).
Ein Origin (deutsch: Ursprung) ist die Kombination aus Protokoll (`http`, `https`), Domain (`myapp.com`, `localhost`, `localhost.tiangolo.com`) und Port (`80`, `443`, `8080`).
Also sind all diese unterschiedliche Ursprünge:
Alle folgenden sind also unterschiedliche Origins:
* `http://localhost`
* `https://localhost`
* `http://localhost:8080`
Auch wenn sie alle auf `localhost` sind, verwenden sie unterschiedliche Protokolle oder Ports, also sind sie verschiedene „Ursprünge“.
Auch wenn sie alle in `localhost` sind, verwenden sie unterschiedliche Protokolle oder Ports, daher sind sie unterschiedliche „Origins“.
## Schritte
Nehmen wir also an, Sie haben ein Frontend, das in Ihrem Browser unter `http://localhost:8080` läuft, und dessen JavaScript versucht, mit einem Backend zu kommunizieren, das unter `http://localhost` läuft (da wir keinen Port angeben, nimmt der Browser den Defaultport `80` an).
Angenommen, Sie haben ein Frontend, das in Ihrem Browser unter `http://localhost:8080` läuft, und dessen JavaScript versucht, mit einem Backend zu kommunizieren, das unter `http://localhost` läuft (da wir keinen Port angegeben haben, geht der Browser vom Default-Port `80` aus).
Dann wird der Browser einen HTTP `OPTIONS`-Request an das `:80`-Backend senden, und wenn das Backend die entsprechenden Header sendet, die die Kommunikation von diesem anderen Ursprung (`http://localhost:8080`) autorisieren, dann lässt der `:8080`-Browser das JavaScript im Frontend seine Anfrage an das `:80`-Backend senden.
Dann wird der Browser ein HTTP-`OPTIONS`-Request an das `:80`-Backend senden, und wenn das Backend die entsprechenden Header sendet, die die Kommunikation von diesem anderen Origin (`http://localhost:8080`) autorisieren, lässt der `:8080`-Browser das JavaScript im Frontend seinen Request an das `:80`-Backend senden.
Um dies zu erreichen, muss das `:80`-Backend eine Liste von „erlaubten Ursprüngen“ haben.
Um dies zu erreichen, muss das `:80`-Backend eine Liste von „erlaubten Origins“ haben.
In diesem Fall müsste die Liste `http://localhost:8080` enthalten, damit das `:8080`-Frontend korrekt funktioniert.
## Wildcards
Es ist auch möglich, die Liste als `"*"` (ein „Wildcard“) anzugeben, um zu sagen, dass alle erlaubt sind.
Es ist auch möglich, die Liste als `"*"` (ein „Wildcard“) zu deklarieren, um anzuzeigen, dass alle erlaubt sind.
Aber das wird nur bestimmte Arten der Kommunikation erlauben, alles ausschließend, was Anmeldeinformationen umfasst: Cookies, Authorization-Header wie diejenigen, die mit Bearer-Tokens verwendet werden, usw.
Aber das erlaubt nur bestimmte Arten der Kommunikation und schließt alles aus, was Anmeldeinformationen beinhaltet: Cookies, Autorisierungsheader wie die, die mit Bearer Tokens verwendet werden, usw.
Daher ist es besser, die erlaubten Ursprünge explizit anzugeben, damit alles korrekt funktioniert.
Um sicherzustellen, dass alles korrekt funktioniert, ist es besser, die erlaubten Origins explizit anzugeben.
## Verwenden Sie `CORSMiddleware`
## `CORSMiddleware` verwenden
Sie können es in Ihrer **FastAPI**-Anwendung mit der `CORSMiddleware` konfigurieren.
Sie können das in Ihrer **FastAPI**-Anwendung mit der `CORSMiddleware` konfigurieren.
* Importieren Sie `CORSMiddleware`.
* Erstellen Sie eine Liste der erlaubten Ursprünge (als Strings).
* Fügen Sie es Ihrer **FastAPI**-Anwendung als „Middleware“ hinzu.
* Erstellen Sie eine Liste der erlaubten Origins (als Strings).
* Fügen Sie es als „Middleware“ zu Ihrer **FastAPI**-Anwendung hinzu.
Sie können auch angeben, ob Ihr Backend Folgendes zulässt:
Sie können auch angeben, ob Ihr Backend erlaubt:
* Anmeldeinformationen (Authorization-Header, Cookies, usw.).
* Bestimmte HTTP-Methoden (`POST`, `PUT`) oder alle mit dem Wildcard `"*"`.
* Bestimmte HTTP-Header oder alle mit dem Wildcard `"*"`.
* Anmeldeinformationen (Autorisierungsheader, Cookies, usw.).
* Bestimmte HTTP-Methoden (`POST`, `PUT`) oder alle mit der Wildcard `"*"`.
* Bestimmte HTTP-Header oder alle mit der Wildcard `"*"`.
{* ../../docs_src/cors/tutorial001.py hl[2,6:11,13:19] *}
Die von der `CORSMiddleware`-Implementierung verwendeten Defaultparameter sind standardmäßig restriktiv, daher müssen Sie bestimmte Ursprünge, Methoden oder Header explizit aktivieren, damit Browser sie in einem Cross-Domain-Kontext verwenden können.
Die von der `CORSMiddleware`-Implementierung verwendeten Defaultparameter sind standardmäßig restriktiv, daher müssen Sie bestimmte Origins, Methoden oder Header ausdrücklich aktivieren, damit Browser sie in einem Cross-Domain-Kontext verwenden dürfen.
Die folgenden Argumente werden unterstützt:
* `allow_origins` - Eine Liste von Ursprüngen, die Cross-Origin-Requests durchführen dürfen. Z.B. `['https://example.org', 'https://www.example.org']`. Sie können `['*']` verwenden, um jeden Ursprung zuzulassen.
* `allow_origin_regex` - Ein Regex-String, der mit Ursprüngen übereinstimmen muss, die Cross-Origin-Requests durchführen dürfen. z.B. `'https://.*\.example\.org'`.
* `allow_methods` - Eine Liste von HTTP-Methoden, die für Cross-Origin-Requests erlaubt sein sollten. Standardmäßig `['GET']`. Sie können `['*']` verwenden, um alle Standardmethoden zuzulassen.
* `allow_headers` - Eine Liste von HTTP-Anfrage-Headern, die für Cross-Origin-Requests unterstützt werden sollten. Standardmäßig `[]`. Sie können `['*']` verwenden, um alle Header zuzulassen. Die Header `Accept`, `Accept-Language`, `Content-Language` und `Content-Type` sind immer für <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#simple_requests" class="external-link" rel="noopener" target="_blank">einfache CORS-Anfragen</a> erlaubt.
* `allow_credentials` - Zeigt an, dass Cookies für Cross-Origin-Requests unterstützt werden sollten. Standardmäßig `False`.
* `allow_origins` - Eine Liste von Origins, die Cross-Origin-Requests machen dürfen. z.B. `['https://example.org', 'https://www.example.org']`. Sie können `['*']` verwenden, um jedes Origin zuzulassen.
* `allow_origin_regex` - Ein Regex-String zum Abgleichen gegen Origins, die Cross-Origin-Requests machen dürfen. z.B. `'https://.*\.example\.org'`.
* `allow_methods` - Eine Liste von HTTP-Methoden, die für Cross-Origin-Requests erlaubt sein sollen. Standardmäßig `['GET']`. Sie können `['*']` verwenden, um alle Standardmethoden zu erlauben.
* `allow_headers` - Eine Liste von HTTP-Requestheadern, die für Cross-Origin-Requests unterstützt werden sollten. Standardmäßig `[]`. Sie können `['*']` verwenden, um alle Header zu erlauben. Die Header `Accept`, `Accept-Language`, `Content-Language` und `Content-Type` sind immer für <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#simple_requests" class="external-link" rel="noopener" target="_blank">einfache CORS-Requests</a> erlaubt.
* `allow_credentials` - Anzeigen, dass Cookies für Cross-Origin-Requests unterstützt werden sollten. Standardmäßig `False`.
Keiner der `allow_origins`, `allow_methods` und `allow_headers` kann auf `['*']` gesetzt werden, wenn `allow_credentials` auf `True` gesetzt ist. Alle müssen <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#credentialed_requests_and_wildcards" class="external-link" rel="noopener" target="_blank">explizit angegeben</a> werden.
Keines der `allow_origins`, `allow_methods` und `allow_headers` kann auf `['*']` gesetzt werden, wenn `allow_credentials` auf `True` gesetzt ist. Alle müssen <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#credentialed_requests_and_wildcards" class="external-link" rel="noopener" target="_blank">explizit angegeben</a> werden.
* `expose_headers` - Gibt an, welche Response-Header dem Browser zugänglich gemacht werden sollen. Standardmäßig `[]`.
* `max_age` - Legt eine maximale Zeit in Sekunden fest, wie lange Browser CORS-Responses cachen dürfen. Standardmäßig `600`.
* `expose_headers` - Angabe der Responseheader, auf die der Browser zugreifen können soll. Standardmäßig `[]`.
* `max_age` - Legt eine maximale Zeit in Sekunden fest, die Browser CORS-Responses zwischenspeichern dürfen. Standardmäßig `600`.
Die Middleware antwortet auf zwei besondere Arten von HTTP-Requests...
### CORS Preflight-Anfragen
### CORS-Preflight-Requests
Dies sind alle `OPTIONS`-Requests mit `Origin`- und `Access-Control-Request-Method`-Headern.
In diesem Fall wird die Middleware den eingehenden Request abfangen und mit den entsprechenden CORS-Headern antworten und entweder eine `200`- oder `400`-Response zu Informationszwecken senden.
In diesem Fall wird die Middleware den eingehenden Request abfangen und mit entsprechenden CORS-Headern, und entweder einer `200`- oder `400`-Response zu Informationszwecken antworten.
### Einfache Anfragen
### Einfache Requests
Jede Anfrage mit einem `Origin`-Header. In diesem Fall wird die Middleware den Request normal durchlassen, aber die entsprechenden CORS-Header zur Response hinzufügen.
Jeder Request mit einem `Origin`-Header. In diesem Fall wird die Middleware den Request wie gewohnt durchlassen, aber entsprechende CORS-Header in die Response aufnehmen.
## Weitere Informationen
Für weitere Informationen über <abbr title="Cross-Origin Resource Sharing">CORS</abbr> lesen Sie die <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS" class="external-link" target="_blank">Mozilla CORS Dokumentation</a>.
Weitere Informationen zu <abbr title="Cross-Origin Resource Sharing">CORS</abbr> finden Sie in der <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS" class="external-link" target="_blank">Mozilla CORS-Dokumentation</a>.
/// note | Technische Details
Sie könnten auch `from starlette.middleware.cors import CORSMiddleware` verwenden.
**FastAPI** bietet mehrere Middlewares in `fastapi.middleware` an, lediglich als Bequemlichkeit für Sie, den Entwickler. Aber die meisten der verfügbaren Middlewares stammen direkt von Starlette.
**FastAPI** bietet mehrere Middlewares in `fastapi.middleware` nur als Komfort für Sie, den Entwickler. Aber die meisten der verfügbaren Middlewares stammen direkt von Starlette.
///

42
docs/de/docs/tutorial/debugging.md

@ -2,7 +2,7 @@
Sie können den Debugger in Ihrem Editor verbinden, zum Beispiel mit Visual Studio Code oder PyCharm.
## Aufruf von `uvicorn`
## `uvicorn` aufrufen
Importieren und führen Sie `uvicorn` direkt in Ihrer FastAPI-Anwendung aus:
@ -10,7 +10,7 @@ Importieren und führen Sie `uvicorn` direkt in Ihrer FastAPI-Anwendung aus:
### Über `__name__ == "__main__"`
Der Hauptzweck von `__name__ == "__main__"` ist, dass bestimmter Code ausgeführt wird, wenn Ihre Datei mit:
Der Hauptzweck von `__name__ == "__main__"` ist, dass Code ausgeführt wird, wenn Ihre Datei mit folgendem Befehl aufgerufen wird:
<div class="termy">
@ -20,17 +20,17 @@ $ python myapp.py
</div>
aufgerufen wird, aber nicht ausgeführt wird, wenn eine andere Datei sie importiert, wie in:
aber nicht ausgeführt wird, wenn eine andere Datei sie importiert, wie in diesem Fall:
```Python
from myapp import app
```
#### Mehr Details
#### Weitere Details
Angenommen, Ihre Datei heißt `myapp.py`.
Wenn Sie sie mit:
Wenn Sie sie mit folgendem Befehl ausführen:
<div class="termy">
@ -40,9 +40,9 @@ $ python myapp.py
</div>
ausführen, hat die interne Variable `__name__` in Ihrer Datei, die automatisch von Python erstellt wird, den Wert der Zeichenkette `"__main__"`.
dann hat in Ihrer Datei die interne Variable `__name__`, die automatisch von Python erstellt wird, den Wert des Strings `"__main__"`.
Also wird der Abschnitt:
Daher wird der Abschnitt:
```Python
uvicorn.run(app, host="0.0.0.0", port=8000)
@ -52,17 +52,17 @@ ausgeführt.
---
Das wird nicht passieren, wenn Sie dieses Modul (Datei) importieren.
Dies wird nicht passieren, wenn Sie das Modul (die Datei) importieren.
Wenn Sie also eine andere Datei `importer.py` mit folgendem Inhalt haben:
Wenn Sie also eine weitere Datei `importer.py` mit folgendem Inhalt haben:
```Python
from myapp import app
# Weiterer Code
# Hier mehr Code
```
wird in diesem Fall die automatisch erstellte Variable innerhalb von `myapp.py` nicht den Wert `"__main__"` für die Variable `__name__` haben.
wird in diesem Fall in `myapp.py` die automatisch erstellte Variable `__name__` nicht den Wert `"__main__"` haben.
Daher wird die Zeile:
@ -72,26 +72,26 @@ Daher wird die Zeile:
nicht ausgeführt.
/// info | Hinweis
/// info | Info
Für weitere Informationen schauen Sie in die <a href="https://docs.python.org/3/library/__main__.html" class="external-link" target="_blank">offiziellen Python-Dokumentationen</a>.
Für weitere Informationen besuchen Sie bitte <a href="https://docs.python.org/3/library/__main__.html" class="external-link" target="_blank">die offizielle Python-Dokumentation</a>.
///
## Führen Sie Ihren Code mit Ihrem Debugger aus
## Ihren Code mit Ihrem Debugger ausführen
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.
Da Sie den Uvicorn-Server direkt aus Ihrem Code 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.
* "Konfiguration hinzufügen..." auswä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.
Der Server wird dann mit Ihrem **FastAPI**-Code gestartet, an Ihren Haltepunkten angehalten, usw.
So könnte es aussehen:
@ -101,12 +101,12 @@ So könnte es aussehen:
Wenn Sie Pycharm verwenden, können Sie:
* Das "Run"-Menü öffnen.
* Das Menü "Run" öffnen.
* Die Option "Debug..." auswählen.
* Es erscheint ein Kontextmenü.
* Die Datei zum Debuggen auswählen (in diesem Fall `main.py`).
* Ein Kontextmenü wird angezeigt.
* Die zu debuggende Datei auswählen (in diesem Fall `main.py`).
Damit wird dann der Server mit Ihrem **FastAPI**-Code gestartet, an Ihren Breakpoints angehalten usw.
Der Server wird dann mit Ihrem **FastAPI**-Code gestartet, an Ihren Haltepunkten angehalten, usw.
So könnte es aussehen:

36
docs/de/docs/tutorial/header-param-models.md

@ -1,42 +1,42 @@
# Header-Parameter-Modelle
Wenn Sie eine Gruppe von verwandten **Header-Parametern** haben, können Sie ein **Pydantic-Modell** erstellen, um diese zu deklarieren.
Wenn Sie eine Gruppe verwandter **Header-Parameter** 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. 😎
Dadurch können Sie das **Modell an mehreren Stellen wiederverwenden** und auch Validierungen und Metadaten für alle Parameter gleichzeitig deklarieren. 😎
/// note | Hinweis
Dies wird seit FastAPI-Version `0.115.0` unterstützt. 🤓
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`:
Deklarieren Sie die erforderlichen **Header-Parameter** 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.
**FastAPI** wird die Daten für **jedes Feld** aus den **Headern** des Requests extrahieren und Ihnen das von Ihnen definierte Pydantic-Modell geben.
## Überprüfen Sie die Dokumentation
## Die Dokumentation überprüfen
Sie können die erforderlichen Headers in der Dokumentationsoberfläche unter `/docs` sehen:
Sie können die erforderlichen Header in der Dokumentationsoberfläche unter `/docs` sehen:
<div class="screenshot">
<img src="/img/tutorial/header-param-models/image01.png">
</div>
## Zusätzliche Headers verbieten
## Zusätzliche Header verbieten
In einigen speziellen Anwendungsfällen (wahrscheinlich nicht sehr häufig) möchten Sie möglicherweise die **Headers einschränken**, die Sie empfangen möchten.
In einigen speziellen Anwendungsfällen (wahrscheinlich nicht sehr häufig) möchten Sie möglicherweise die **Header einschränken**, die Sie erhalten möchten.
Sie können die Modellkonfiguration von Pydantic verwenden, um `zusätzliche` Felder zu `verbieten`:
Sie können Pydantics Modellkonfiguration verwenden, um `extra` Felder zu verbieten (`forbid`):
{* ../../docs_src/header_param_models/tutorial002_an_py310.py hl[10] *}
Wenn ein Client versucht, einige **zusätzliche Headers** zu senden, erhalten sie eine **Error-Response**.
Wenn ein Client versucht, einige **zusätzliche Header** zu senden, erhält er eine **Error-Response**.
Zum Beispiel, wenn der Client versucht, einen `tool`-Header mit dem Wert `plumbus` zu senden, erhalten sie eine **Error-Response**, die ihnen mitteilt, dass der Header-Parameter `tool` nicht erlaubt ist:
Zum Beispiel, wenn der Client versucht, einen `tool`-Header mit einem Wert von `plumbus` zu senden, erhält er eine **Error-Response**, die ihm mitteilt, dass der Header-Parameter `tool` nicht erlaubt ist:
```json
{
@ -51,22 +51,22 @@ Zum Beispiel, wenn der Client versucht, einen `tool`-Header mit dem Wert `plumbu
}
```
## Automatische Konvertierung von Unterstrichen deaktivieren
## Automatische Umwandlung von Unterstrichen deaktivieren
Genauso wie bei regulären Header-Parametern, werden bei der Verwendung von Unterstrich-Zeichen in den Parameternamen diese **automatisch in Bindestriche umgewandelt**.
Ähnlich wie bei regulären Header-Parametern werden bei der Verwendung von Unterstrichen in den Parameternamen diese **automatisch in Bindestriche umgewandelt**.
Zum Beispiel, wenn Sie einen Header-Parameter `save_data` im Code haben, wird der erwartete HTTP-Header `save-data` sein, und er wird auch so in der Dokumentation erscheinen.
Wenn Sie beispielsweise einen Header-Parameter `save_data` im Code haben, wird der erwartete HTTP-Header `save-data` sein, und er wird auch so in der Dokumentation angezeigt.
Wenn Sie aus irgendeinem Grund diese automatische Konvertierung deaktivieren müssen, können Sie dies auch für Pydantic-Modelle für Header-Parameter tun.
Falls Sie aus irgendeinem Grund diese automatische Umwandlung deaktivieren müssen, können Sie dies auch für Pydantic-Modelle für Header-Parameter tun.
{* ../../docs_src/header_param_models/tutorial003_an_py310.py hl[19] *}
/// warning | Achtung
Bevor Sie `convert_underscores` auf `False` setzen, bedenken Sie, dass einige HTTP-Proxies und Server die Verwendung von Headers mit Unterstrichen nicht zulassen.
Bevor Sie `convert_underscores` auf `False` setzen, bedenken Sie, dass einige HTTP-Proxies und -Server die Verwendung von Headers mit Unterstrichen nicht zulassen.
///
## Zusammenfassung
Sie können **Pydantic-Modelle** verwenden, um **Headers** in **FastAPI** zu deklarieren. 😎
Sie können **Pydantic-Modelle** verwenden, um **Header** in **FastAPI** zu deklarieren. 😎

22
docs/de/docs/tutorial/query-param-models.md

@ -1,26 +1,26 @@
# Query-Parameter-Modelle
Wenn Sie eine Gruppe von **Query-Parametern** haben, die in Zusammenhang stehen, können Sie ein **Pydantic-Modell** erstellen, um sie zu deklarieren.
Wenn Sie eine Gruppe von **Query-Parametern** haben, die miteinander in Beziehung stehen, können Sie ein **Pydantic-Modell** erstellen, um diese zu deklarieren.
Dadurch können Sie das **Modell** an **mehreren Stellen wiederverwenden** und auch Validierungen und Metadaten für alle Parameter auf einmal deklarieren. 😎
Dadurch können Sie das **Modell an mehreren Stellen wiederverwenden** und gleichzeitig Validierungen und Metadaten für alle Parameter auf einmal deklarieren. 😎
/// note | Hinweis
Dies wird seit FastAPI-Version `0.115.0` unterstützt. 🤓
Dies wird seit FastAPI Version `0.115.0` unterstützt. 🤓
///
## Query-Parameter mit einem Pydantic-Modell
Deklarieren Sie die benötigten **Query-Parameter** in einem **Pydantic-Modell** und deklarieren Sie dann den Parameter als `Query`:
Deklarieren Sie die benötigten **Query-Parameter** in einem **Pydantic-Modell** und dann den Parameter als `Query`:
{* ../../docs_src/query_param_models/tutorial001_an_py310.py hl[9:13,17] *}
**FastAPI** wird die Daten für **jedes Feld** aus den **Query-Parametern** der Anfrage **extrahieren** und Ihnen das von Ihnen definierte Pydantic-Modell übergeben.
**FastAPI** wird die Daten für **jedes Feld** aus den **Query-Parametern** der Anfrage extrahieren und Ihnen das definierte Pydantic-Modell bereitstellen.
## Überprüfen Sie die Dokumentation
## Die Dokumentation überprüfen
Sie können die Query-Parameter in der Dokumentationsoberfläche unter `/docs` sehen:
Sie können die Query-Parameter in der Dokumentations-Oberfläche unter `/docs` einsehen:
<div class="screenshot">
<img src="/img/tutorial/query-param-models/image01.png">
@ -28,21 +28,21 @@ Sie können die Query-Parameter in der Dokumentationsoberfläche unter `/docs` s
## Zusätzliche Query-Parameter verbieten
In einigen speziellen Anwendungsfällen (wahrscheinlich nicht sehr häufig) möchten Sie möglicherweise die Query-Parameter, die Sie empfangen möchten, **einschränken**.
In einigen speziellen Anwendungsfällen (wahrscheinlich nicht sehr häufig) möchten Sie möglicherweise die Query-Parameter, die Sie empfangen möchten, **beschränken**.
Sie können die Modellkonfiguration von Pydantic verwenden, um `extra` Felder zu `verbieten`:
Sie können die Modellkonfiguration von Pydantic verwenden, um jegliche `extra` Felder zu `verbieten`:
{* ../../docs_src/query_param_models/tutorial002_an_py310.py hl[10] *}
Wenn ein Client versucht, einige **zusätzliche** Daten in den **Query-Parametern** zu senden, erhält er eine **Error-Response**.
Wenn der Client beispielsweise versucht, einen `tool` Query-Parameter mit einem Wert von `plumbus` zu senden, wie:
Wenn der Client beispielsweise versucht, einen `tool` Query-Parameter mit dem Wert `plumbus` zu senden, wie:
```http
https://example.com/items/?limit=10&tool=plumbus
```
wird er eine **Error-Response** erhalten, die ihm mitteilt, dass der Query-Parameter `tool` nicht erlaubt ist:
erhält er eine **Error-Response**, die ihm mitteilt, dass der Query-Parameter `tool` nicht erlaubt ist:
```json
{

20
docs/de/docs/tutorial/request-form-models.md

@ -2,11 +2,11 @@
Sie können **Pydantic-Modelle** verwenden, um **Formularfelder** in FastAPI zu deklarieren.
/// info | Hinweis
/// info | Info
Um Formulare zu verwenden, installieren Sie zuerst <a href="https://github.com/Kludex/python-multipart" class="external-link" target="_blank">`python-multipart`</a>.
Stellen Sie sicher, dass Sie eine [virtuelle Umgebung](../virtual-environments.md){.internal-link target=_blank} erstellen, diese aktivieren und dann das Paket installieren, zum Beispiel:
Stellen Sie sicher, dass Sie eine [virtuelle Umgebung](../virtual-environments.md){.internal-link target=_blank} erstellen, sie aktivieren und es dann installieren, zum Beispiel:
```console
$ pip install python-multipart
@ -22,15 +22,15 @@ Dies wird seit FastAPI Version `0.113.0` unterstützt. 🤓
## Pydantic-Modelle für Formulare
Sie müssen lediglich ein **Pydantic-Modell** mit den Feldern deklarieren, die Sie als **Formularfelder** empfangen möchten, und dann den Parameter als `Form` deklarieren:
Sie müssen nur ein **Pydantic-Modell** mit den Feldern deklarieren, die Sie als **Formularfelder** erhalten möchten, und dann den Parameter als `Form` deklarieren:
{* ../../docs_src/request_form_models/tutorial001_an_py39.py hl[9:11,15] *}
**FastAPI** wird die Daten für **jedes Feld** aus den **Formulardaten** in der Anfrage **extrahieren** und Ihnen das von Ihnen definierte Pydantic-Modell zurückgeben.
**FastAPI** wird die Daten für **jedes Feld** aus den **Formulardaten** in der Anfrage **extrahieren** und Ihnen das von Ihnen definierte Pydantic-Modell übergeben.
## Überprüfen Sie die Dokumentation
## Die Dokumentation überprüfen
Sie können dies in der Dokumentationsoberfläche unter `/docs` überprüfen:
Sie können dies in der Dokumentations-UI unter `/docs` überprüfen:
<div class="screenshot">
<img src="/img/tutorial/request-form-models/image01.png">
@ -38,7 +38,7 @@ Sie können dies in der Dokumentationsoberfläche unter `/docs` überprüfen:
## Zusätzliche Formularfelder verbieten
In einigen besonderen Anwendungsfällen (wahrscheinlich nicht sehr häufig) möchten Sie möglicherweise die Formularfelder auf nur die im Pydantic-Modell deklarierten Felder **beschränken**. Und jegliche **zusätzlichen** Felder **verbieten**.
In einigen speziellen Anwendungsfällen (wahrscheinlich nicht sehr häufig) möchten Sie möglicherweise die Formularfelder auf nur diejenigen beschränken, die im Pydantic-Modell deklariert sind, und jegliche **zusätzlichen** Felder **verbieten**.
/// note | Hinweis
@ -46,19 +46,19 @@ Dies wird seit FastAPI Version `0.114.0` unterstützt. 🤓
///
Sie können die Modellkonfiguration von Pydantic verwenden, um `extra` Felder zu `verbieten`:
Sie können die Modellkonfiguration von Pydantic verwenden, um jegliche `extra` Felder zu `verbieten`:
{* ../../docs_src/request_form_models/tutorial002_an_py39.py hl[12] *}
Wenn ein Client versucht, einige zusätzliche Daten zu senden, erhält er eine **Error-Response**.
Zum Beispiel, wenn der Client versucht, die folgenden Formularfelder zu senden:
Zum Beispiel, wenn der Client versucht, folgende Formularfelder zu senden:
* `username`: `Rick`
* `password`: `Portal Gun`
* `extra`: `Mr. Poopybutthole`
Er wird eine Fehlerantwort erhalten, die ihm mitteilt, dass das Feld `extra` nicht erlaubt ist:
erhält er eine Error-Response, die ihm mitteilt, dass das Feld `extra` nicht erlaubt ist:
```json
{

158
docs/de/docs/tutorial/sql-databases.md

@ -1,6 +1,6 @@
# SQL (Relationale) Datenbanken
**FastAPI** erfordert nicht, dass Sie eine SQL (relationale) Datenbank verwenden. Aber Sie können **jede beliebige Datenbank** verwenden, die Sie möchten.
**FastAPI** erfordert nicht, dass Sie eine SQL (relationale) Datenbank verwenden. Sondern Sie können **jede beliebige Datenbank** verwenden, die Sie möchten.
Hier werden wir ein Beispiel mit <a href="https://sqlmodel.tiangolo.com/" class="external-link" target="_blank">SQLModel</a> sehen.
@ -18,9 +18,9 @@ Da SQLModel auf SQLAlchemy basiert, können Sie problemlos **jede von SQLAlchemy
* MySQL
* SQLite
* Oracle
* Microsoft SQL Server usw.
* Microsoft SQL Server, usw.
In diesem Beispiel verwenden wir **SQLite**, da es eine einzige Datei verwendet und Python integrierte Unterstützung bietet. Sie können dieses Beispiel kopieren und direkt so ausführen.
In diesem Beispiel verwenden wir **SQLite**, da es eine einzelne Datei verwendet und Python integrierte Unterstützung bietet. Sie können also dieses Beispiel kopieren und direkt ausführen.
Später, für Ihre Produktionsanwendung, möchten Sie möglicherweise einen Datenbankserver wie **PostgreSQL** verwenden.
@ -30,9 +30,9 @@ Es gibt einen offiziellen Projektgenerator mit **FastAPI** und **PostgreSQL**, e
///
Dies ist ein sehr einfaches und kurzes Tutorial. Wenn Sie mehr über Datenbanken im Allgemeinen, über SQL oder fortgeschrittenere Funktionen erfahren möchten, gehen Sie zu den <a href="https://sqlmodel.tiangolo.com/" class="external-link" target="_blank">SQLModel-Dokumentationen</a>.
Dies ist ein sehr einfaches und kurzes Tutorial. Wenn Sie mehr über Datenbanken im Allgemeinen, über SQL oder fortgeschrittenere Funktionen erfahren möchten, besuchen Sie die <a href="https://sqlmodel.tiangolo.com/" class="external-link" target="_blank">SQLModel-Dokumentation</a>.
## Installieren Sie `SQLModel`
## `SQLModel` installieren
Stellen Sie zunächst sicher, dass Sie Ihre [virtuelle Umgebung](../virtual-environments.md){.internal-link target=_blank} erstellen, sie aktivieren und dann `sqlmodel` installieren:
@ -45,11 +45,11 @@ $ pip install sqlmodel
</div>
## Erstellen Sie die Anwendung mit einem einzigen Modell
## Die App mit einem einzelnen Modell erstellen
Wir erstellen zuerst die einfachste erste Version der Anwendung mit einem einzigen **SQLModel**-Modell.
Wir erstellen zuerst die einfachste erste Version der App 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. 🤓
Später werden wir sie verbessern, indem wir unter der Haube **mehrere Modelle** verwenden, um Sicherheit und Vielseitigkeit zu erhöhen. 🤓
### Modelle erstellen
@ -57,45 +57,45 @@ 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*).
Die `Hero`-Klasse ist einem Pydantic-Modell sehr ähnlich (faktisch ist sie darunter tatsächlich *ein Pydantic-Modell*).
Es gibt einige Unterschiede:
Es gibt ein paar 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).
* `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 der SQLModel-Dokumentation 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.
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.
* `Field(index=True)` sagt SQLModel, dass es einen **SQL-Index** für diese Spalte erstellen soll, was schnelleres Suchen in der Datenbank ermöglicht, wenn Daten mittels dieser Spalte gefiltert 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.
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 Engine erstellen
Eine SQLModel `engine` (darunter ist es tatsächlich eine SQLAlchemy `engine`) ist das, was die **Verbindungen** zur Datenbank hält.
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.
Sie hätten **ein einziges `engine`-Objekt** für Ihren gesamten Code, um sich mit derselben 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).
Die Verwendung von `check_same_thread=False` erlaubt FastAPI, dieselbe SQLite-Datenbank in verschiedenen Threads zu verwenden. Dies ist notwendig, da **eine einzelne 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.
Keine Sorge, so wie der Code strukturiert ist, werden wir später sicherstellen, dass wir **eine einzige SQLModel-*Session* pro Anfrage** verwenden, das ist eigentlich das, was `check_same_thread` erreichen möchte.
### Erstellen Sie die Tabellen
### Die Tabellen erstellen
Dann fügen wir eine Funktion hinzu, die `SQLModel.metadata.create_all(engine)` verwendet, um die **Tabellen für alle Tabellenmodelle** zu erstellen.
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-Abhängigkeit erstellen
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.
Eine **`Session`** (deutsch: Sitzung) speichert die **Objekte im Speicher** und verfolgt alle Änderungen, die an den Daten vorgenommen werden müssen, 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. 🤓
Wir werden eine FastAPI **Abhängigkeit** mit `yield` erstellen, die eine neue `Session` für jede Anfrage bereitstellt. Das ist es, 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.
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] *}
@ -111,41 +111,41 @@ Für die Produktion würden Sie wahrscheinlich ein Migrationsskript verwenden, d
/// tip | Tipp
SQLModel wird Migrationstools mit Alembic bereitstellen, aber vorerst können Sie <a href="https://alembic.sqlalchemy.org/en/latest/" class="external-link" target="_blank">Alembic</a> direkt verwenden.
SQLModel wird Migrationstools haben, die Alembic wrappen, aber im Moment können Sie <a href="https://alembic.sqlalchemy.org/en/latest/" class="external-link" target="_blank">Alembic</a> direkt verwenden.
///
### Erstellen Sie einen Helden
### Einen Helden erstellen
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.
Auf die gleiche Weise können Sie es als **Rückgabetyp** der Funktion deklarieren, und dann wird die Form der Daten in der automatischen API-Dokumentation 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.
Hier verwenden wir die `SessionDep`-Abhängigkeit (eine `Session`), um den neuen `Hero` zur `Session`-Instanz hinzuzufügen, die Änderungen an der Datenbank zu committen, die Daten im `hero` zu aktualisieren und ihn anschließend 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.
Wir können `Hero`s aus der Datenbank mit einem `select()` **lesen**. Wir können ein `limit` und `offset` hinzufü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.
Wir können einen einzelnen `Hero` **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.
Wir können auch einen `Hero` **löschen**.
{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[66:73] hl[71] *}
### Führen Sie die App aus
### Die App ausführen
Sie können die App ausführen:
@ -159,21 +159,21 @@ $ fastapi dev main.py
</div>
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**.
Gehen Sie dann zur `/docs`-UI, Sie werden sehen, dass **FastAPI** diese **Modelle** verwendet, um die API zu **dokumentieren**, und es wird sie auch verwenden, um die Daten zu **serialisieren** und zu **validieren**.
<div class="screenshot">
<img src="/img/tutorial/sql-databases/image01.png">
</div>
## Aktualisieren Sie die App mit mehreren Modellen
## Die App mit mehreren Modellen aktualisieren
Jetzt lassen Sie uns diese App ein wenig **umstellen**, um die **Sicherheit** und **Vielseitigkeit** zu erhöhen.
Jetzt lassen Sie uns diese App ein wenig **refaktorisieren**, um die **Sicherheit** und **Vielseitigkeit** zu erhöhen.
Wenn Sie die vorherige App überprüfen, können Sie in der UI sehen, dass sie dem Client erlaubt, die `id` des zu erstellenden `Hero` zu entscheiden. 😱
Wenn Sie die vorherige App überprüfen, können Sie in der UI sehen, dass sie bis jetzt dem Client erlaubt, die `id` des zu erstellenden `Hero` zu bestimmen. 😱
Das sollten wir nicht zulassen, sie könnten eine `id` überschreiben, die wir bereits in der DB zugewiesen haben. Das Festlegen der `id` sollte vom **Backend** oder der **Datenbank**, **nicht vom Client** erfolgen.
Das sollten wir nicht zulassen, sie könnten eine `id` überschreiben, die wir bereits in der DB zugewiesen haben. Die Entscheidung über die `id` sollte vom **Backend** oder der **Datenbank** getroffen werden, **nicht vom Client**.
Darüber hinaus erstellen wir einen `secret_name` für den Helden, aber bisher geben wir ihn überall zurück, das ist nicht sehr **geheim**... 😅
Außerdem erstellen wir einen `secret_name` für den Helden, aber bisher geben wir ihn überall zurück, das ist nicht sehr **geheim**... 😅
Wir werden diese Dinge beheben, indem wir ein paar **zusätzliche Modelle** hinzufügen. Hier wird SQLModel glänzen. ✨
@ -187,7 +187,7 @@ Mit SQLModel können wir **Vererbung** verwenden, um **doppelte Felder** in alle
#### `HeroBase` - die Basisklasse
Beginnen wir mit einem `HeroBase`-Modell, das alle **Felder, die von allen Modellen gemeinsam genutzt werden**, enthält:
Fangen wir mit einem `HeroBase`-Modell an, das alle **Felder hat, die von allen Modellen geteilt werden**:
* `name`
* `age`
@ -196,12 +196,12 @@ Beginnen wir mit einem `HeroBase`-Modell, das alle **Felder, die von allen Model
#### `Hero` - das *Tabellenmodell*
Dann erstellen wir `Hero`, das eigentliche *Tabellenmodell*, mit den **zusätzlichen Feldern**, die nicht immer in den anderen Modellen sind:
Dann erstellen wir `Hero`, das tatsächliche *Tabellenmodell*, mit den **zusätzlichen Feldern**, die nicht immer in den anderen Modellen enthalten sind:
* `id`
* `secret_name`
Da `Hero` von `HeroBase` erbt, hat es **auch** die **Felder**, die in `HeroBase` deklariert sind, sodass alle Felder für `Hero` sind:
Da `Hero` von `HeroBase` erbt, hat es **auch** die **Felder**, die in `HeroBase` deklariert sind, also sind alle Felder von `Hero`:
* `id`
* `name`
@ -212,23 +212,23 @@ Da `Hero` von `HeroBase` erbt, hat es **auch** die **Felder**, die in `HeroBase`
#### `HeroPublic` - das öffentliche *Datenmodell*
Als nächstes erstellen wir ein `HeroPublic`-Modell, dies ist das, das **an die API-Clients zurückgegeben** wird.
Als nächstes erstellen wir ein `HeroPublic`-Modell, das an die API-Clients **zurückgegeben** wird.
Es hat dieselben Felder wie `HeroBase`, also wird es `secret_name` nicht enthalten.
Es hat dieselben Felder wie `HeroBase`, sodass es `secret_name` nicht enthält.
Endlich ist die Identität unserer Helden geschützt! 🥷
Es erklärt auch `id: int` neu. Indem wir dies tun, schließen wir einen **Vertrag** mit den API-Clients ab, sodass sie immer erwarten können, dass die `id` vorhanden ist und ein `int` ist (sie wird niemals `None` sein).
Es deklariert auch `id: int` erneut. Indem wir dies tun, machen wir einen **Vertrag** mit den API-Clients, damit sie immer damit rechnen können, dass die `id` vorhanden ist und ein `int` ist (sie wird niemals `None` sein).
/// tip | Tipp
Dass das Rückgabemodell sicherstellt, dass ein Wert immer verfügbar ist und immer `int` ist (nicht `None`), ist sehr nützlich für die API-Clients, sie können viel einfacheren Code schreiben, wenn sie diese Sicherheit haben.
Es ist sehr nützlich für die API-Clients, wenn das Rückgabemodell sicherstellt, dass ein Wert immer verfügbar und immer `int` (nicht `None`) ist, sie können viel einfacheren Code schreiben, wenn sie diese Sicherheit haben.
Auch **automatisch generierte Clients** werden einfachere Schnittstellen haben, sodass die Entwickler, die mit Ihrer API kommunizieren, eine viel bessere Zeit haben können, mit Ihrer API zu arbeiten. 😎
Auch **automatisch generierte Clients** werden einfachere Schnittstellen haben, damit die Entwickler, die mit Ihrer API kommunizieren, viel mehr Freude an der Arbeit mit Ihrer API haben können. 😎
///
Alle Felder in `HeroPublic` sind die gleichen wie in `HeroBase`, mit `id` als `int` (nicht `None`):
Alle Felder in `HeroPublic` sind dieselben wie in `HeroBase`, mit `id`, das als `int` (nicht `None`) deklariert ist:
* `id`
* `name`
@ -236,19 +236,19 @@ Alle Felder in `HeroPublic` sind die gleichen wie in `HeroBase`, mit `id` als `i
{* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[7:18] hl[17:18] *}
#### `HeroCreate` - das *Datenmodell* um einen Helden zu erstellen
#### `HeroCreate` - das *Datenmodell* zum Erstellen eines Helden
Jetzt erstellen wir ein `HeroCreate`-Modell, das die Daten von den Clients **validieren** wird.
Nun erstellen wir ein `HeroCreate`-Modell, das die Daten der Clients **validiert**.
Es hat die gleichen Felder wie `HeroBase`, und es hat auch `secret_name`.
Es hat dieselben Felder wie `HeroBase`, und es hat auch `secret_name`.
Jetzt, wenn die Clients **einen neuen Helden erstellen**, senden sie den `secret_name`, er wird in der Datenbank gespeichert, aber diese geheimen Namen werden in der API nicht an die Clients zurückgegeben.
Wenn die Clients **einen neuen Helden erstellen**, senden sie jetzt den `secret_name`, er wird in der Datenbank gespeichert, aber diese geheimen Namen werden den API-Clients nicht zurückgegeben.
/// tip | Tipp
So würden Sie **Passwörter** behandeln. Sie empfangen sie, aber geben sie nicht in der API zurück.
So würden Sie **Passwörter** handhaben. Empfangen Sie sie, aber geben Sie sie nicht in der API zurück.
Sie würden auch **die Werte der Passwörter hashieren**, bevor Sie sie speichern, **niemals im Klartext speichern**.
Sie würden auch die Werte der Passwörter **hashen**, bevor Sie sie speichern, und sie **niemals im Klartext** speichern.
///
@ -260,15 +260,15 @@ Die Felder von `HeroCreate` sind:
{* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[7:22] hl[21:22] *}
#### `HeroUpdate` - das *Datenmodell* um einen Helden zu aktualisieren
#### `HeroUpdate` - das *Datenmodell* zum Aktualisieren eines Helden
Wir hatten keine Möglichkeit, **einen Helden zu aktualisieren** in der vorherigen Version der App, aber jetzt mit **mehreren Modellen**, können wir es. 🎉
In der vorherigen Version der App hatten wir keine Möglichkeit, einen Helden **zu aktualisieren**, aber jetzt mit **mehreren Modellen** können wir es. 🎉
Das `HeroUpdate` *Datenmodell* ist etwas Besonderes, es hat **alle gleichen Felder**, die benötigt werden, um einen neuen Helden zu erstellen, aber alle Felder sind **optional** (sie haben alle einen Defaultwert). Auf diese Weise, wenn Sie einen Helden aktualisieren, können Sie nur die Felder senden, die Sie aktualisieren möchten.
Das `HeroUpdate`-*Datenmodell* ist etwas Besonderes, es hat **die selben Felder**, die benötigt werden, um einen neuen Helden zu erstellen, aber alle Felder sind **optional** (sie haben alle einen Defaultwert). Auf diese Weise, wenn Sie einen Helden aktualisieren, können Sie nur die Felder senden, die Sie aktualisieren möchten.
Da sich alle **Felder wirklich ändern** (der Typ enthält nun `None` und sie haben jetzt einen Defaultwert von `None`), müssen wir sie **neu deklarieren**.
Da sich tatsächlich **alle Felder ändern** (der Typ enthält jetzt `None` und sie haben jetzt einen Standardwert von `None`), müssen wir sie erneut **deklarieren**.
Wir müssen nicht wirklich von `HeroBase` erben, da wir alle Felder neu deklarieren. Ich lasse es einfach nur aus Gründen der Konsistenz erben, aber das ist nicht notwendig. Es ist mehr eine Frage des persönlichen Geschmacks. 🤷
Wir müssen wirklich nicht von `HeroBase` erben, weil wir alle Felder neu deklarieren. Ich lasse es aus Konsistenzgründen erben, aber das ist nicht notwendig. Es ist mehr eine Frage des persönlichen Geschmacks. 🤷
Die Felder von `HeroUpdate` sind:
@ -278,15 +278,15 @@ Die Felder von `HeroUpdate` sind:
{* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[7:28] hl[25:28] *}
### Erstellen mit `HeroCreate` und Rückgabe eines `HeroPublic`
### Mit `HeroCreate` erstellen und ein `HeroPublic` zurückgeben
Jetzt, da wir **mehrere Modelle** haben, können wir die Teile der App aktualisieren, die sie verwenden.
Nun, da wir **mehrere Modelle** haben, können wir die Teile der App aktualisieren, die sie verwenden.
Wir empfangen in der Anfrage ein `HeroCreate` *Datenmodell*, und daraus erstellen wir ein `Hero` *Tabellenmodell*.
Wir empfangen im Request ein `HeroCreate`-*Datenmodell* und daraus erstellen wir ein `Hero`-*Tabellenmodell*.
Dieses neue *Tabellenmodell* `Hero` wird die Felder haben, die vom Client gesendet wurden, und wird auch eine `id` haben, die von der Datenbank generiert wird.
Dieses neue *Tabellenmodell* `Hero` wird die vom Client gesendeten Felder haben und zusätzlich eine `id`, die von der Datenbank generiert wird.
Dann geben wir das gleiche *Tabellenmodell* `Hero` wie aus der Funktion aus zurück. Aber da wir das `response_model` mit dem `HeroPublic` *Datenmodell* deklarieren, wird **FastAPI** `HeroPublic` verwenden, um die Daten zu validieren und zu serialisieren.
Dann geben wir das gleiche *Tabellenmodell* `Hero` von der Funktion zurück. Aber da wir das `response_model` mit dem `HeroPublic`-*Datenmodell* deklarieren, wird **FastAPI** `HeroPublic` verwenden, um die Daten zu validieren und zu serialisieren.
{* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[56:62] hl[56:58] *}
@ -294,45 +294,45 @@ Dann geben wir das gleiche *Tabellenmodell* `Hero` wie aus der Funktion aus zur
Jetzt verwenden wir `response_model=HeroPublic` anstelle der **Rückgabetyp-Annotation** `-> HeroPublic`, weil der Wert, den wir zurückgeben, tatsächlich *kein* `HeroPublic` ist.
Hätten wir `-> HeroPublic` deklariert, würde Ihr Editor und Linter (berechtigterweise) meckern, dass Sie ein `Hero` statt eines `HeroPublic` zurückgeben.
Wenn wir `-> HeroPublic` deklariert hätten, würden Ihr Editor und Linter (zu Recht) reklamieren, dass Sie ein `Hero` anstelle eines `HeroPublic` zurückgeben.
Durch die Deklaration in `response_model` sagen wir **FastAPI**, dass es sein Ding machen soll, ohne die Typ-Annotationen und die Hilfe Ihres Editors und anderer Tools zu stören.
Durch die Deklaration in `response_model` sagen wir **FastAPI**, dass es seine Aufgabe erledigen soll, ohne die Typannotationen und die Hilfe von Ihrem Editor und anderen Tools zu beeinträchtigen.
///
### Helden mit `HeroPublic` lesen
Wir können dasselbe wie zuvor tun, um **Helden zu lesen**, erneut verwenden wir `response_model=list[HeroPublic]`, um sicherzustellen, dass die Daten korrekt validiert und serialisiert werden.
Wir können dasselbe wie zuvor tun, um `Hero`s zu **lesen**, und erneut verwenden wir `response_model=list[HeroPublic]`, um sicherzustellen, dass die Daten ordnungsgemäß validiert und serialisiert werden.
{* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[65:72] hl[65] *}
### Einen Helden mit `HeroPublic` lesen
### Einen einzelnen Helden mit `HeroPublic` lesen
Wir können einen einzelnen **Helden** lesen:
Wir können einen einzelnen Helden **lesen**:
{* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[75:80] hl[77] *}
### Update einen Helden mit `HeroUpdate`
### Einen Helden mit `HeroUpdate` aktualisieren
Wir können einen **Helden aktualisieren**. Dafür verwenden wir eine HTTP `PATCH`-Operation.
Wir können einen Helden **aktualisieren**. Dafür verwenden wir eine HTTP-`PATCH`-Operation.
Und im Code erhalten wir ein `dict` mit allen Daten, die vom Client gesendet wurden, **nur die Daten, die vom Client gesendet wurden**, ohne Werte, die nur für die Defaultwerte vorhanden wären. Dazu verwenden wir `exclude_unset=True`. Dies ist der Haupttrick. 🪄
Und im Code erhalten wir ein `dict` mit allen Daten, die vom Client gesendet wurden, **nur die Daten, die vom Client gesendet wurden**, unter Ausschluss von Werten, die dort nur als Defaultwerte vorhanden wären. Um dies zu tun, verwenden wir `exclude_unset=True`. Das ist der Haupttrick. 🪄
Dann verwenden wir `hero_db.sqlmodel_update(hero_data)`, um das `hero_db` mit den Daten von `hero_data` zu aktualisieren.
Dann verwenden wir `hero_db.sqlmodel_update(hero_data)`, um die `hero_db` mit den Daten aus `hero_data` zu aktualisieren.
{* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[83:93] hl[83:84,88:89] *}
### Einen Helden erneut löschen
### Einen Helden wieder löschen
Das **Löschen** eines Helden bleibt weitgehend gleich.
Das **Löschen** eines Helden bleibt ziemlich gleich.
Wir werden das Verlangen, alles in diesem Fall umzugestalten, nicht befriedigen. 😅
Wir werden dieses Mal nicht dem Wunsch nachgeben, alles zu refaktorisieren. 😅
{* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[96:103] hl[101] *}
### Führen Sie die App erneut aus
Sie können die App noch einmal ausführen:
Sie können die App erneut ausführen:
<div class="termy">
@ -344,7 +344,7 @@ $ fastapi dev main.py
</div>
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.
Wenn Sie zur `/docs`-API-UI gehen, werden Sie sehen, dass sie jetzt aktualisiert ist und nicht mehr erwarten wird, die `id` vom Client beim Erstellen eines Helden zu erhalten, usw.
<div class="screenshot">
<img src="/img/tutorial/sql-databases/image02.png">
@ -354,4 +354,4 @@ Wenn Sie zur `/docs` API UI gehen, werden Sie sehen, dass diese jetzt aktualisie
Sie können <a href="https://sqlmodel.tiangolo.com/" class="external-link" target="_blank">**SQLModel**</a> verwenden, um mit einer SQL-Datenbank zu interagieren und den Code mit *Datenmodellen* und *Tabellenmodellen* zu vereinfachen.
Sie können viel mehr in den **SQLModel**-Dokumentationen lernen, es gibt ein längeres Mini <a href="https://sqlmodel.tiangolo.com/tutorial/fastapi/" class="external-link" target="_blank">Tutorial über die Verwendung von SQLModel mit **FastAPI**</a>. 🚀
Sie können viel mehr in der **SQLModel**-Dokumentation lernen, es gibt ein längeres Mini-<a href="https://sqlmodel.tiangolo.com/tutorial/fastapi/" class="external-link" target="_blank">Tutorial zur Verwendung von SQLModel mit **FastAPI**</a>. 🚀

96
docs/de/docs/virtual-environments.md

@ -1,8 +1,8 @@
# Virtuelle Umgebungen
Wenn Sie an Python-Projekten arbeiten, sollten Sie wahrscheinlich eine **virtuelle Umgebung** (oder einen ähnlichen Mechanismus) verwenden, um die Pakete, die Sie für jedes Projekt installieren, zu isolieren.
Wenn Sie an Python-Projekten arbeiten, sollten Sie wahrscheinlich eine **virtuelle Umgebung** (oder einen ähnlichen Mechanismus) verwenden, um die Pakete(englisch: Packages), die Sie für jedes Projekt installieren, zu isolieren.
/// info | Hinweis
/// info | Info
Wenn Sie bereits über virtuelle Umgebungen Bescheid wissen, wie man sie erstellt und verwendet, möchten Sie diesen Abschnitt vielleicht überspringen. 🤓
@ -18,7 +18,7 @@ Eine **virtuelle Umgebung** ist ein Verzeichnis mit einigen Dateien darin.
///
/// info | Hinweis
/// info | Info
Diese Seite wird Ihnen beibringen, wie Sie **virtuelle Umgebungen** verwenden und wie sie funktionieren.
@ -28,7 +28,7 @@ Wenn Sie bereit sind, ein **Tool zu verwenden, das alles für Sie verwaltet** (e
## Ein Projekt erstellen
Zuerst erstellen Sie ein Verzeichnis für Ihr Projekt.
Erstellen Sie zuerst ein Verzeichnis für Ihr Projekt.
Was ich normalerweise mache, ist, dass ich ein Verzeichnis namens `code` in meinem Home/Benutzerverzeichnis erstelle.
@ -37,15 +37,15 @@ Und darin erstelle ich ein Verzeichnis pro Projekt.
<div class="termy">
```console
// Gehen Sie zum Home-Verzeichnis
// Zum Home-Verzeichnis wechseln
$ cd
// Erstellen Sie ein Verzeichnis für all Ihre Code-Projekte
// Ein Verzeichnis für alle Ihre Codeprojekte erstellen
$ mkdir code
// Betreten Sie dieses Code-Verzeichnis
// In dieses Codeverzeichnis gehen
$ cd code
// Erstellen Sie ein Verzeichnis für dieses Projekt
// Ein Verzeichnis für dieses Projekt erstellen
$ mkdir awesome-project
// Betreten Sie dieses Projektverzeichnis
// In dieses Projektverzeichnis gehen
$ cd awesome-project
```
@ -53,11 +53,11 @@ $ cd awesome-project
## Eine virtuelle Umgebung erstellen
Wenn Sie zum **ersten Mal** an einem Python-Projekt arbeiten, erstellen Sie eine virtuelle Umgebung **<abbr title="es gibt andere Optionen, dies ist eine einfache Richtlinie">innerhalb Ihres Projekts</abbr>**.
Wenn Sie zum **ersten Mal** an einem Python-Projekt arbeiten, erstellen Sie eine virtuelle Umgebung **<abbr title="Es gibt andere Optionen, dies ist eine einfache Richtlinie">innerhalb Ihres Projekts</abbr>**.
/// tip | Tipp
Sie müssen dies **einmal pro Projekt** tun, nicht jedes Mal, wenn Sie daran arbeiten.
Sie müssen dies nur **einmal pro Projekt** tun, nicht jedes Mal, wenn Sie daran arbeiten.
///
@ -110,7 +110,7 @@ Dieser Befehl erstellt eine neue virtuelle Umgebung in einem Verzeichnis namens
/// 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.
Sie könnten die virtuelle Umgebung in einem anderen Verzeichnis erstellen, aber es ist eine Konvention, sie `.venv` zu nennen.
///
@ -166,7 +166,7 @@ $ source .venv/Scripts/activate
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="Befehlszeilenschnittstelle">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.
So stellen Sie sicher, dass, wenn Sie ein **Terminalprogramm (<abbr title="Command Line Interface">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.
///
@ -176,7 +176,7 @@ So stellen Sie sicher, dass, wenn Sie ein **Terminalprogramm (<abbr title="Befeh
/// 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.
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.
///
@ -216,11 +216,11 @@ Wenn es das `python`-Binary in `.venv\Scripts\python` anzeigt, innerhalb Ihres P
/// tip | Tipp
Wenn Sie <a href="https://github.com/astral-sh/uv" class="external-link" target="_blank">`uv`</a> verwenden, würden Sie es verwenden, um Dinge zu installieren anstelle von `pip`, sodass Sie nicht `pip` aktualisieren müssen. 😎
Wenn Sie <a href="https://github.com/astral-sh/uv" class="external-link" target="_blank">`uv`</a> 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 **upgraden**.
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.
@ -244,11 +244,11 @@ $ python -m pip install --upgrade pip
## `.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.
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 <a href="https://github.com/astral-sh/uv" class="external-link" target="_blank">`uv`</a> verwendet haben, um die virtuelle Umgebung zu erstellen, hat es dies bereits für Sie getan; Sie können diesen Schritt überspringen. 😎
Wenn Sie <a href="https://github.com/astral-sh/uv" class="external-link" target="_blank">`uv`</a> verwendet haben, um die virtuelle Umgebung zu erstellen, hat es dies bereits für Sie getan, Sie können diesen Schritt überspringen. 😎
///
@ -268,11 +268,11 @@ $ echo "*" > .venv/.gitignore
/// details | Was dieser Befehl bedeutet
* `echo "*"`: wird den Text `*` im Terminal "drucken" (der nächste Teil ändert das ein wenig)
* `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.
Und `*` bedeutet für Git „alles“. Also wird alles im `.venv`-Verzeichnis ignoriert.
Dieser Befehl erstellt eine Datei `.gitignore` mit dem Inhalt:
@ -378,7 +378,7 @@ 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.
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">
@ -392,7 +392,7 @@ 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.
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 (er wird sie wahrscheinlich automatisch erkennen), sodass Sie Autovervollständigungen und Inline-Fehler erhalten können.
Zum Beispiel:
@ -417,9 +417,9 @@ $ deactivate
</div>
Auf diese Weise, wenn Sie `python` ausführen, wird es nicht versuchen, es aus dieser virtuellen Umgebung mit den dort installierten Paketen auszuführen.
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
## Bereit zu arbeit
Jetzt sind Sie bereit, mit Ihrem Projekt zu arbeiten.
@ -451,14 +451,14 @@ Zum Beispiel könnten Sie ein Projekt namens `philosophers-stone` erstellen, die
```mermaid
flowchart LR
stone(philosophers-stone) -->|erfordert| harry-1[harry v1]
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) --> |erfordert| harry-3[harry v3]
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.
@ -481,11 +481,11 @@ flowchart LR
harry-1[harry v1]
end
subgraph stone-project[philosophers-stone Projekt]
stone(philosophers-stone) -->|erfordert| harry-1
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, würde die Version `1` automatisch deinstallieren).
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">
@ -510,13 +510,13 @@ flowchart LR
stone(philosophers-stone) -.-x|⛔️| harry-1
end
subgraph azkaban-project[prisoner-of-azkaban Projekt]
azkaban(prisoner-of-azkaban) --> |erfordert| harry-3
azkaban(prisoner-of-azkaban) --> |benötigt| 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.
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.
///
@ -548,26 +548,26 @@ Es wird auch Dateien für andere Pakete **herunterladen**, von denen FastAPI abh
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**.
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
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.
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) --->|erfordert| harry-1
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) --->|erfordert| harry-3
azkaban(prisoner-of-azkaban) --->|benötigt| harry-3
subgraph venv2[.venv]
harry-3[harry v3]
end
@ -617,17 +617,17 @@ $ 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.
Dieser Befehl erstellt oder ändert 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.
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.
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:
@ -712,7 +712,7 @@ Ein wichtiger Punkt ist, dass es den Pfad der virtuellen Umgebung am **Anfang**
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
## Überprüfen einer virtuellen Umgebung
Wenn Sie überprüfen, ob eine virtuelle Umgebung aktiv ist, zum Beispiel mit:
@ -748,15 +748,15 @@ Das bedeutet, dass das `python`-Programm, das verwendet wird, das in der **virtu
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.
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.
Das Wichtigste ist, dass, wenn Sie `python` aufrufen, genau dieses "`python`" ausgeführt wird.
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, eine Python-Version zu erhalten und dann **zu einem anderen Projekt zu wechseln**.
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.
@ -804,16 +804,16 @@ Wenn Sie jedoch die virtuelle Umgebung deaktivieren und die neue für `prisoner-
```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 😎
// 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
// Aktivieren Sie die virtuelle Umgebung in prisoner-of-azkaban/.venv 🚀
// 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
Ich schwöre feierlich 🐺
I solemnly swear 🐺
```
</div>
@ -822,21 +822,21 @@ Ich schwöre feierlich 🐺
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.
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, <a href="https://github.com/astral-sh/uv" class="external-link" target="_blank">uv</a> auszuprobieren.
`uv` kann viele Dinge tun, es kann:
* **Python installieren** für Sie, einschließlich verschiedener Versionen
* **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 **Sperren** genannt
* 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
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**. 😎
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**. 😎

Loading…
Cancel
Save