Beherrschung von Python-APIs: Ein umfassender Leitfaden zur Erstellung und Nutzung von APIs in Python

APIs, also Anwendungsprogrammierschnittstellen, sind die Helden der modernen Softwareentwicklung. Sie ermöglichen es, dass verschiedene Softwaresysteme miteinander kommunizieren können, so dass Dienste integriert und Anwendungen erstellt werden können. Die Beherrschung von APIs ist eine wichtige Fähigkeit für jeden, der mit Daten in Python arbeiten möchte, vor allem wenn du ein Entwickler bist. Du wirst überrascht sein, welche Türen sich dir öffnen, denn wenn du diese Fähigkeit erlernt hast, kannst du Webanwendungen erstellen, Verbindungen zu externen Diensten herstellen oder sogar Echtzeitdaten in Machine-Learning-Projekten nutzen.

In diesem Leitfaden werden wir die Welt der APIs erkunden, lernen, wie man sie in Python verwendet, wie man mit FastAPI eigene APIs erstellt und wie man mit den häufigsten Herausforderungen umgeht, die mit Sicherheit auftreten werden. Am Ende dieses Tutorials wirst du ein solides Verständnis dafür haben, wie du APIs in deinen Projekten nutzen kannst, um deinen Entwicklungsprozess effizienter und deine Anwendungen leistungsfähiger zu machen. Wenn du mit all den Informationen nicht weiterkommst, kannst du unseren Kurs Einführung in APIs in Python ausprobieren, in dem jeder einzelne Teil detailliert besprochen wird.

Was ist eine API?

Eine API ist wie eine Brücke zwischen verschiedenen Softwareanwendungen. Sie ermöglicht es diesen Anwendungen, miteinander zu kommunizieren und Informationen auszutauschen.

Stell dir eine API als Kellner in einem Restaurant vor. Du sagst dem Kellner, was du willst (deine Bestellung), und er gibt deinen Wunsch an die Küche weiter. Die Küche bereitet dein Essen zu, und der Kellner bringt es dir zurück. Auf ähnliche Weise sendest du eine Anfrage an eine API, die deine Anfrage verarbeitet und die Ergebnisse zurückgibt.

Um dies zu verdeutlichen, lass uns einige reale Anwendungen betrachten: Du könntest z.B. eine öffentliche API nutzen, um Finanzdaten für eine Börsenanalyse abzurufen oder um auf Echtzeit-Wetterdaten für ein Klimavorhersagemodell zuzugreifen. Wie du vielleicht schon gemerkt hast, sind APIs besonders wichtig, wenn du mit großen Datenmengen arbeitest und/oder Daten in Echtzeit benötigst; andernfalls hättest du vielleicht keine Probleme mit der Integration.

Wie eine Python-API funktioniert. Bild von Napkin.AI

Verwendung von APIs in Python

Die Verwendung von APIs in Python ist eine leistungsstarke Methode, um mit externen Diensten zu interagieren, Daten abzurufen und verschiedene Funktionen in deine Anwendungen zu integrieren. Python macht die Arbeit mit APIs einfach und effizient, vor allem durch die Bibliothek requests, mit der du HTTP-Anfragen senden kannst, um mit APIs zu interagieren.

Einführung in APIs in Python

In Python ist die Interaktion mit APIs dank der Bibliothek requests ein unkomplizierter Prozess. Diese Bibliothek vereinfacht das Senden von HTTP-Anfragen und ermöglicht es dir, mit APIs zu kommunizieren und Daten abzurufen oder zu senden.

API-Anfragen in Python stellen

Bevor du API-Anfragen in Python stellen kannst, brauchst du die Bibliothekrequests. Du kannst es mit diesem Befehl installieren:

pip install requests

Die Grundlagen von API-Anfragen

Verknüpfen wir unser konzeptionelles Beispiel mit dem Restaurant mit dem, was tatsächlich in Python passiert. Hier ist die vereinfachte Aufschlüsselung:

1. Finde den richtigen Ort: Bestimme den API-Endpunkt, d.h. die spezifische Webadresse, an die du deine Anfrage sendest.

2. Gib deine Bestellung auf: Verwende die requests Bibliothek von Python, um die Anfrage an die API zu senden. Du gibst an, welche Art von Aktion du durchführen willst (z. B. Daten abrufen oder Daten senden).

3. Hol dir dein Essen: Die API sendet eine Antwort zurück, die du verarbeiten kannst, um die benötigten Informationen zu erhalten.

GET-Anfragen

Wenn du eine URL in deinen Browser eingibst und die Eingabetaste drückst, sendest du im Grunde eine GET-Anfrage an den Server und gibst die gewünschte Ressource an, die der Server verarbeitet, um die angeforderten Daten zu finden und aufzubereiten, bevor er sie in einem Format wie JSON oder XML zurückschickt.

import requestsresponse = requests.get('https://api.example.com/data')data = response.json()print(data)

In diesem Beispiel senden wir eine GET-Anfrage an eine fiktive API und drucken die JSON-Antwort aus. GET-Anfragen werden in der Regel verwendet, um Daten abzurufen, ohne sie zu verändern.

POST-Anfragen

Während GET-Anfragen Daten abrufen, senden POST-Anfragen Anweisungen an einen Server. Sie werden oft verwendet, um neue Ressourcen zu erstellen (wie das Hinzufügen eines Benutzers) oder bestehende zu aktualisieren (wie das Bearbeiten eines Profils).

Stell dir vor, du füllst ein Online-Formular aus, um dich für einen Dienst zu registrieren. Wenn du auf "Absenden" klickst, sendest du eine POST-Anfrage mit deinen Informationen. Hier ist ein vereinfachtes Beispiel:

# Data to send (like user information)data = {'name': 'John Doe', 'email': 'john.doe@example.com'}# Send the data to the API (replace the URL with the actual API endpoint)response = requests.post('https://api.example.com/users', json=data)# Check if the request was successful (usually a status code of 201 for creation)if response.status_code == 201:    print("User created successfully!")else:    print("Error:", response.status_code)

Dieses Beispiel sendet ein Wörterbuch mit Benutzerinformationen als JSON-Daten an die API. Dann überprüfen wir den Antwortstatuscode, um zu sehen, ob der Benutzer erfolgreich erstellt wurde.

Umgang mit Antworten

Wenn du eine API-Anfrage stellst, sendet der Server eine Antwort zurück, die zwei wichtige Informationen enthält:

• Status Code: Eine Zahl, die den Erfolg oder Misserfolg der Anfrage anzeigt. Zum Beispiel bedeutet 200 normalerweise Erfolg, während 404 bedeutet, dass die Ressource nicht gefunden wurde.
• Daten: Die von dir angeforderten Informationen liegen oft im JSON-Format vor. Das ist der Ort, an dem sich die wertvollen Inhalte befinden.

Hier ist ein Python-Beispiel:

response = requests.get('https://api.example.com/data')if response.status_code == 200:    data = response.json()    print(data)   else:    print(f"Request failed with status code {response.status_code}")   

Python API Status Codes verstehen

API-Statuscodes sind standardisierte Antworten, die Server zurücksenden, um das Ergebnis der Anfrage eines Kunden anzuzeigen. Diese Codes helfen Entwicklern zu verstehen, ob eine Anfrage erfolgreich war, ob ein Fehler aufgetreten ist oder ob weitere Maßnahmen erforderlich sind.

Allgemeine Statuscodes

• 200 OK: Dieser Statuscode zeigt an, dass die Anfrage erfolgreich war. Wenn du zum Beispiel eine GET-Anfrage stellst, um Daten von einer API abzurufen, bedeutet eine 200 OK Antwort, dass die Daten korrekt abgerufen wurden.  

• 404 Nicht gefunden: Dieser Code wird zurückgegeben, wenn der Server die angeforderte Ressource nicht finden kann. Wenn du zum Beispiel versuchst, auf einen Endpunkt zuzugreifen, der nicht existiert, erhältst du die Fehlermeldung 404 Not Found.

• 500 Interner Serverfehler: Dieser Code signalisiert, dass auf der Seite des Servers etwas schief gelaufen ist. Es handelt sich um eine allgemeine Fehlermeldung, die aufgrund verschiedener Probleme auftreten kann, z. B. durch Fehler im Servercode oder Probleme mit der Datenbank.

Umgang mit verschiedenen Statuscodes

Ein effektiver Umgang mit API-Statuscodes in deinen Python-Anwendungen stellt sicher, dass sich dein Code vorhersehbar verhält und Fehler elegant behandelt werden können. Wenn die Antwort 200 lautet, fährst du mit der Verarbeitung der zurückgegebenen Daten fort. Wenn du auf einen 404-Fehler stößt, überprüfe, ob die Endpunkt-URL korrekt ist, und implementiere bei Bedarf eine Fallback-Logik oder informiere den Nutzer, dass die Ressource nicht verfügbar ist. Bei 500-Fehlern solltest du die Anfrage nach einer kurzen Verzögerung erneut versuchen oder den Fehler für weitere Untersuchungen protokollieren. Vermeide jedoch übermäßige Wiederholungsversuche, um eine Überlastung des Servers zu vermeiden.

Python-APIs erstellen

Die Erstellung von APIs mit Python ermöglicht es dir, leistungsstarke und effiziente Anwendungsschnittstellen zu erstellen. Die Einfachheit von Python und seine robusten Bibliotheken machen es zu einer hervorragenden Wahl für die API-Entwicklung.

Einführung in die FastAPI

Da du nun weißt, wie du APIs nutzen kannst, wollen wir nun herausfinden, wie wir unsere eigenen erstellen können. FastAPI ist ein modernes, schnelles (Hochleistungs-)Web-Framework für die Erstellung von APIs mit Python. Wie der Name schon sagt, ist es so konzipiert, dass es einfach zu bedienen ist. Eine Sache, die ich an FastAPI mag, ist, dass es auch automatisch eine interaktive Dokumentation erstellt.

FastAPI einrichten

Um loszulegen, musst du Python und seinen Paketmanager pip installiert haben. Anschließend installierst du FastAPI und Uvicorn, einen leistungsstarken ASGI-Server:

pip install fastapi uvicorn

Nebenbei bemerkt: Wenn du Probleme mit Python oder der Pip-Einrichtung hast, schau dir unser Tutorial an: Wie man Python und Pip unter Windows, MacOS und Linux aktualisiert.

Erstellen einer einfachen API

Lass uns eine einfache API konstruieren, die eine einfache Begrüßung zurückgibt:

from fastapi import FastAPIapp = FastAPI()@app.get("/")def read_root():    return {"Hello": "World"}

Um diese API zu starten, führe den folgenden Befehl aus:

uvicorn main:app --reload

Dieser Befehl initiiert den Uvicorn-Server, der deine API auf http://127.0.0.1:8000 bereitstellt. Wenn du diese URL in deinem Webbrowser aufrufst, erhältst du die Antwort {"Hello": "World"}.

Erweiterte Funktionen der FastAPI

Mit FastAPI lassen sich nicht nur einfache APIs schnell erstellen, sondern es bietet auch eine Reihe von fortschrittlichen Funktionen, die es für komplexe und leistungsstarke Anwendungen geeignet machen. Hier sind einige der wichtigsten Funktionen: 

Abfrage-Parameter

In der FastAPI ist das Hinzufügen und Bearbeiten von Abfrageparametern dank der Python-Typ-Hinweise ganz einfach. Abfrageparameter sind Teil der URL und werden verwendet, um optionale Daten an den API-Endpunkt zu übergeben, oft um die zurückgegebenen Daten zu filtern oder zu ändern.

Hinzufügen von Abfrageparametern

Um einen Abfrageparameter in FastAPI hinzuzufügen, definierst du ihn einfach als Funktionsargument in deiner Pfadoperationsfunktion. Wenn ein Parameter optional ist, kannst du ihm einen Standardwert zuweisen, wie z.B. None. Nehmen wir zum Beispiel an, du hast einen Endpunkt, der Elemente aus einer Datenbank abruft. Du möchtest es den Nutzern ermöglichen, Artikel nach einer Suchanfrage zu filtern:

app = FastAPI()@app.get("/items/")def read_items(q: str = None):    if q:        return {"items": ["Item 1", "Item 2", "Item 3"], "query": q}    return {"items": ["Item 1", "Item 2", "Item 3"]}

In diesem Beispiel ist q ein optionaler Abfrageparameter. Wenn wir einen Wert für q angeben, filtert er die Ergebnisse auf der Grundlage dieser Abfrage. Wenn q nicht angegeben wird, gibt der Endpunkt alle Elemente zurück.

Umgang mit Abfrageparametern

FastAPI verarbeitet die Abfrageparameter automatisch, einschließlich der Typvalidierung und Konvertierung. Wenn du zum Beispiel einen Abfrageparameter als Ganzzahl angibst, überprüft die FastAPI, ob die Eingabe tatsächlich eine Ganzzahl ist. Wenn die Eingabe nicht mit dem erwarteten Typ übereinstimmt, gibt FastAPI eine eindeutige Fehlermeldung zurück.

Hier ist ein Beispiel mit einem erforderlichen Abfrageparameter und einer Typüberprüfung:

@app.get("/items/{item_id}")def read_item(item_id: int, q: str = None):    return {"item_id": item_id, "query": q}

In diesem Fall ist item_id ein Pfadparameter und q ist ein optionaler Abfrageparameter. Die FastAPI stellt sicher, dass item_id eine ganze Zahl ist und verarbeitet den Abfrageparameter q, wenn er angegeben wird.

Umgang mit verschiedenen HTTP-Methoden

Die Implementierung verschiedener HTTP-Methoden wie GET, POST, PUT und DELETE ist einfach und spiegelt wider, wie du Routen in anderen Frameworks definierst. Jede Methode ist an einen bestimmten Vorgangstyp gebunden, z. B. das Abrufen von Daten (GET), das Erstellen neuer Daten (POST), das Aktualisieren vorhandener Daten (PUT) oder das Löschen von Daten (DELETE).

GET-Methode

Die Methode GET wird verwendet, um Daten vom Server abzurufen. In FastAPI definierst du einen GET Endpunkt wie folgt:

@app.get("/items/")def get_items():    return {"items": ["Item 1", "Item 2", "Item 3"]}

POST-Methode

Die Methode POST wird verwendet, um neue Daten zu erstellen. Du kannst einen POST Endpunkt definieren und Daten im Request Body empfangen:

@app.post("/items/")def create_item(item: dict):    return {"item": item}

PUT-Methode

Die Methode PUT wird verwendet, um bestehende Daten zu aktualisieren. Normalerweise werden sowohl ein Identifikator als auch die neuen Daten benötigt:

@app.put("/items/{item_id}")def update_item(item_id: int, item: dict):    return {"item_id": item_id, "updated_item": item}

DELETE-Methode

Die Methode DELETE wird verwendet, um Daten zu entfernen. In FastAPI ist ein DELETE Endpunkt wie folgt definiert:

@app.delete("/items/{item_id}")def delete_item(item_id: int):    return {"message": f"Item {item_id} deleted"}

Authentifizierung und Sicherheit

Die FastAPI bietet mehrere Mechanismen zur Umsetzung von Authentifizierung und Sicherheit:

• HTTP Basic Auth: Eine unkomplizierte Methode, die aber aufgrund von Sicherheitsbedenken nicht für Produktionsumgebungen empfohlen wird.
• API-Schlüssel: Eine sicherere Option ist die Generierung eindeutiger Schlüssel für die Kunden.
• OAuth 2.0: Ein komplexer, aber robuster Standard für die Autorisierung, der häufig für die Integration von Drittanbietern verwendet wird.
• JSON Web Tokens (JWT): Ein beliebter Ansatz, um Ansprüche zwischen zwei Parteien sicher darzustellen.