Come closer to tiangolo#9530

docs/de/docs/tutorial/first-steps.md

@@ -1,12 +1,12 @@
 # Erste Schritte
 
-Das einfachste FastAPI-Programm könnte wie folgt aussehen:
+Die einfachste FastAPI-Datei könnte wie folgt aussehen:
 
 ```Python
 {!../../../docs_src/first_steps/tutorial001.py!}
 ```
 
-Kopieren Sie das in eine Datei `main.py`.
+Kopieren Sie dies in eine Datei `main.py`.
 
 Starten Sie den Live-Server:
 
@@ -27,7 +27,7 @@ $ uvicorn main:app --reload
 !!! note "Hinweis"
     Der Befehl `uvicorn main:app` bezieht sich auf:
 
-    * `main`: die Datei `main.py` (ein sogenanntes Python-"Modul").
+    * `main`: die Datei `main.py` (das sogenannte Python-"Modul").
     * `app`: das Objekt, welches in der Datei `main.py` mit der Zeile `app = FastAPI()` erzeugt wurde.
     * `--reload`: lässt den Server nach Codeänderungen neu starten. Verwenden Sie das nur während der Entwicklung.
 
@@ -41,9 +41,9 @@ Diese Zeile zeigt die URL, unter der Ihre Anwendung auf Ihrem lokalen Computer b
 
 ### Testen Sie es
 
-Öffnen Sie <a href="http://127.0.0.1:8000" class="external-link" target="_blank">http://127.0.0.1:8000</a> in Ihrem Browser.
+Öffnen Sie Ihren Browser unter <a href="http://127.0.0.1:8000" class="external-link" target="_blank">http://127.0.0.1:8000.</a>
 
-Sie sehen die JSON-Antwort:
+Sie werden folgende JSON-Antwort sehen:
 
 ```JSON
 {"message": "Hello World"}
@@ -53,53 +53,53 @@ Sie sehen die JSON-Antwort:
 
 Gehen Sie als Nächstes zu <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs </a>.
 
-Sie sehen die automatisch erzeugte, interaktive API-Dokumentation (bereitgestellt durch <a href="https://github.com/swagger-api/swagger-ui" class="external-link" target="_blank">Swagger UI</a>):
+Sie werden die automatisch erzeugte, interaktive API-Dokumentation sehen (bereitgestellt durch <a href="https://github.com/swagger-api/swagger-ui" class="external-link" target="_blank">Swagger UI</a>):
 
 ![Swagger UI](https://fastapi.tiangolo.com/img/index/index-01-swagger-ui-simple.png)
 
 ### Alternative API-Dokumentation
 
 Als Nächstes gehen Sie zu <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a>.
 
-Dort sehen Sie die alternative, automatisch erstellte Dokumentation (bereitgestellt durch <a href="https://github.com/Rebilly/ReDoc" class="external-link" target="_blank">ReDoc</a>):
+Dort sehen Sie die alternative, automatische Dokumentation (bereitgestellt durch <a href="https://github.com/Rebilly/ReDoc" class="external-link" target="_blank">ReDoc</a>):
 
 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-02-redoc-simple.png)
 
 ### OpenAPI
 
-**FastAPI** generiert ein "Schema" für Ihre API unter Verwendung des **OpenAPI**-Standards zur Definition von APIs.
+**FastAPI** generiert ein "Schema" mit all Ihren APIs unter Verwendung des **OpenAPI**-Standards zur Definition von APIs.
 
 #### "Schema"
 
-Ein "Schema" ist eine Definition oder Beschreibung von etwas. Nicht der Code, der es implementiert, sondern nur eine abstrakte Beschreibung.
+Ein "Schema" ist eine Definition oder Beschreibung von etwas. Nicht der eigentliche Code, der es implementiert, sondern lediglich eine abstrakte Beschreibung.
 
 #### API-"Schema"
 
 In diesem Fall ist  <a href="https://github.com/OAI/OpenAPI-Specification" class="external-link" target="_blank">OpenAPI</a> eine Spezifikation, die vorschreibt, wie ein Schema für Ihre API zu definieren ist.
 
-Diese Schema-Definition enthält Ihre API-Pfade, die möglichen Parameter, welche diese entgegennehmen, usw.
+Diese Schemadefinition enthält Ihre API-Pfade, die möglichen Parameter, welche diese entgegennehmen, usw.
 
 #### Daten-"Schema"
 
 Der Begriff "Schema" kann sich auch auf die Form von Daten beziehen, wie z.B. einen JSON-Inhalt.
 
 In diesem Fall sind die JSON-Attribute und deren Datentypen, usw. gemeint.
 
-#### OpenAPI und JSON Schemata
+#### OpenAPI und JSON Schema
 
 OpenAPI definiert ein API-Schema für Ihre API. Dieses Schema enthält Definitionen (oder "Schemata") der Daten, die von Ihrer API unter Verwendung von **JSON Schema**, dem Standard für JSON-Datenschemata, gesendet und empfangen werden.
 
-#### Betrachten Sie die `openapi.json`
+#### Überprüfen Sie die `openapi.json`
 
 Falls Sie wissen möchten, wie das rohe OpenAPI-Schema aussieht: FastAPI generiert automatisch ein JSON (Schema) mit den Beschreibungen Ihrer gesamten API.
 
-Sie können es direkt ansehen unter: <a href="http://127.0.0.1:8000/openapi.json" class="external-link" target="_blank">http://127.0.0.1:8000/openapi.json </a>.
+Sie können es direkt einsehen unter: <a href="http://127.0.0.1:8000/openapi.json" class="external-link" target="_blank">http://127.0.0.1:8000/openapi.json</a>.
 
-Es wird ein JSON angezeigt, welches ungefähr so aussieht (Ausschnitt):
+Es wird ein JSON angezeigt, welches ungefähr so aussieht:
 
 ```JSON
 {
-    "openapi": "3.0.2",
+    "openapi": "3.1.0",
     "info": {
         "title": "FastAPI",
         "version": "0.1.0"
@@ -122,36 +122,36 @@ Es wird ein JSON angezeigt, welches ungefähr so aussieht (Ausschnitt):
 
 Das OpenAPI-Schema ist die Grundlage für die beiden enthaltenen interaktiven Dokumentationssysteme.
 
-Es gibt Dutzende Alternativen, alle basierend auf OpenAPI. Sie können jede dieser Alternativen problemlos zu Ihrer Anwendung hinzufügen, die Sie mit **FastAPI** erstellt haben.
+Es gibt Dutzende Alternativen, die alle auf OpenAPI basieren. Sie können jede dieser Alternativen problemlos zu Ihrer mit **FastAPI** erstellten Anwendung hinzufügen.
 
-Ebenfalls können Sie es verwenden, um automatisch Code zu generieren, für Clients, die mit Ihrer API kommunizieren. Zum Beispiel für Frontend-, Mobil- oder IoT-Anwendungen.
+Ebenfalls können Sie es verwenden, um automatisch Code für Clients zu generieren, die mit Ihrer API kommunizieren. Zum Beispiel für Frontend-, Mobil- oder IoT-Anwendungen.
 
-## Rekapitulation, Schritt für Schritt
+## Rückblick, Schritt für Schritt
 
 ### Schritt 1: Importieren von `FastAPI`
 
 ```Python hl_lines="1"
 {!../../../docs_src/first_steps/tutorial001.py!}
 ```
 
-`FastAPI` ist eine Python-Klasse, die alle Funktionalität für Ihre API bereitstellt.
+`FastAPI` ist eine Python-Klasse, die die gesamte Funktionalität für Ihre API bereitstellt.
 
 !!! note "Technische Details"
     `FastAPI`  ist eine Klasse, die direkt von `Starlette` erbt.
 
-    Sie können alle Funktionalitäten von <a href="https://www.starlette.io/" class="external-link" target="_blank">Starlette</a> auch mit `FastAPI` nutzen.
+    Sie können alle <a href="https://www.starlette.io/" class="external-link" target="_blank">Starlette</a> Funktionalitäten auch mit `FastAPI` nutzen.
 
 ### Schritt 2: Erzeugen einer `FastAPI`-"Instanz"
 
 ```Python hl_lines="3"
 {!../../../docs_src/first_steps/tutorial001.py!}
 ```
 
-Hier ist die `app`-Variable eine "Instanz" der Klasse `FastAPI`.
+In diesem Beispiel ist die `app` Variable eine "Instanz" der Klasse `FastAPI`.
 
-Dies wird der Einstiegspunkt jeder Interaktion sein, um ihre ganze API zu erstellen.
+Dies wird der Hauptinteraktionspunkt für die Erstellung all Ihrer APIs sein.
 
-Diese `app` ist die gleiche, auf die sich `uvicorn` im Kommando bezieht:
+Diese `app` ist dieselbe, auf die sich der Befehl `uvicorn` bezieht:
 
 <div class="termy">
 
@@ -169,7 +169,7 @@ Wenn Sie Ihre Anwendung wie folgt erstellen:
 {!../../../docs_src/first_steps/tutorial002.py!}
 ```
 
-Und das in eine Datei `main.py` einfügen, dann würden Sie `uvicorn` wie folgt aufrufen:
+Und in eine Datei `main.py` einfügen, dann würden Sie `uvicorn` wie folgt aufrufen:
 
 <div class="termy">
 
@@ -187,13 +187,13 @@ $ uvicorn main:my_awesome_api --reload
 
 "Pfad" bezieht sich hier auf den letzten Teil der URL, beginnend mit dem ersten `/`.
 
-Sprich, in einer URL wie:
+In einer URL wie:
 
 ```
 https://example.com/items/foo
 ```
 
-... wäre der Pfad:
+... wäre der Pfad also:
 
 ```
 /items/foo
@@ -202,7 +202,7 @@ https://example.com/items/foo
 !!! info
     Ein "Pfad" wird häufig auch als "Endpunkt" oder "Route" bezeichnet.
 
-Bei der Erstellung einer API ist der "Pfad" die Hauptmethode zur Trennung von "Anliegen" und "Ressourcen".
+Bei der Erstellung einer API ist der "Pfad" die wichtigste Möglichkeit zur Trennung von "Anliegen" und "Ressourcen".
 
 #### Operation
 
@@ -226,7 +226,7 @@ Im HTTP-Protokoll können Sie mit jedem Pfad über eine (oder mehrere) dieser "M
 
 ---
 
-Wenn Sie APIs bauen, verwenden Sie normalerweise diese spezifischen HTTP-Methoden, um eine bestimmte Aktion durchzuführen.
+Bei der Erstellung von APIs verwenden Sie normalerweise diese spezifischen HTTP-Methoden, um eine bestimmte Aktion durchzuführen.
 
 Normalerweise verwenden Sie:
 
@@ -235,7 +235,7 @@ Normalerweise verwenden Sie:
 * `PUT`: um Daten zu aktualisieren (update).
 * `DELETE`: um Daten zu löschen (delete).
 
-Daher wird in OpenAPI jede dieser HTTP-Methoden als "Operation" bezeichnet.
+In OpenAPI wird folglich jede dieser HTTP-Methoden als "Operation" bezeichnet.
 
 Wir werden sie auch "**Operationen**" nennen.
 
@@ -251,15 +251,15 @@ Das `@app.get("/")` sagt **FastAPI**, dass die Funktion direkt darunter für die
  * unter der Verwendung der <abbr title="eine HTTP GET Methode"><code>get</code>-Operation</abbr> gehen
 
 !!! info "`@decorator` Information"
-    Diese `@etwas`-Syntax wird in Python "Dekorator" genannt.
+    Diese `@something`-Syntax wird in Python "Dekorator" genannt.
 
-    Sie platzieren sie über einer Funktion. Wie ein hübscher, dekorativer Hut (Ich nehme an, daher kommt der Begriff).
+    Sie platzieren ihn über einer Funktion. Wie ein hübscher, dekorativer Hut (daher kommt wohl der Begriff).
 
     Ein "Dekorator" nimmt die darunter stehende Funktion und macht etwas damit.
 
     In unserem Fall teilt dieser Dekorator **FastAPI** mit, dass die folgende Funktion mit dem **Pfad** `/` und der **Operation** `get` zusammenhängt.
 
-    Es ist der "**Pfadoperation-Dekorator**".
+    Dies ist der "**Pfadoperation-Dekorator**".
 
 Sie können auch die anderen Operationen verwenden:
 
@@ -275,11 +275,11 @@ Oder die exotischeren:
 * `@app.trace()`
 
 !!! tip
-    Es steht Ihnen frei, jede Operation (HTTP-Methode) so zu verwenden, wie Sie es wünschen.
+    Es steht Ihnen frei, jede Operation (HTTP-Methode) so zu verwenden, wie Sie es möchten.
 
     **FastAPI** erzwingt keine bestimmte Bedeutung.
 
-    Die hier aufgeführten Informationen dienen als Leitfaden, nicht als Anforderung.
+    Die hier aufgeführten Informationen dienen als Leitfaden und sind nicht verbindlich.
 
     Wenn Sie beispielsweise GraphQL verwenden, führen Sie normalerweise alle Aktionen nur mit "POST"-Operationen durch.
 
@@ -295,11 +295,11 @@ Das ist unsere "**Pfadoperation-Funktion**":
 {!../../../docs_src/first_steps/tutorial001.py!}
 ```
 
-Das ist eine Python-Funktion.
+Dies ist eine Python-Funktion.
 
-Sie wird von **FastAPI** aufgerufen, immer wenn sie eine Anfrage an die URL "`/`" mit einer `GET`-Operation erhält.
+Sie wird von **FastAPI** immer dann aufgerufen, wenn sie eine Anfrage an die URL "`/`" mittels einer `GET`-Operation erhält.
 
-In diesem Fall handelt es sich um eine `async`-Funktion (eine asynchrone Funktion).
+In diesem Fall handelt es sich um eine `async`-Funktion.
 
 ---
 
@@ -310,15 +310,15 @@ Sie könnten sie auch als normale Funktion anstelle von `async def` definieren:
 ```
 
 !!! note "Hinweis"
-    Wenn Sie den Unterschied nicht kennen, lesen Sie [Async: *"In Eile?"*](../async.md#in-a-hurry){.internal-link target=_blank}.
+    Wenn Sie den Unterschied nicht kennen, lesen Sie [Async: *"In a hurry?"*](../async.md#in-a-hurry){.internal-link target=_blank}.
 
 ### Schritt 5: den Inhalt zurückgeben
 
 ```Python hl_lines="8"
 {!../../../docs_src/first_steps/tutorial001.py!}
 ```
 
-Sie können ein `dict`, `list`, einzelne Werte wie `str`, `int`, usw. zurückgeben.
+Sie können ein `dict`, eine `list`, einzelne Werte wie `str`, `int`, usw. zurückgeben.
 
 Sie können auch Pydantic-Modelle zurückgeben (dazu später mehr).