So erstellen Sie schnell APIs in Python

APIs sind das Rückgrat der meisten Anwendungen, die auf Datenaustausch oder externe Integrationen angewiesen sind.

Das Erlernen des Erstellens von APIs in Python kann viele Möglichkeiten eröffnen, Ihre App mit anderen Systemen zu verbinden und ein vielseitiges Backend zu erstellen.

Hier führe ich Sie durch die Grundlagen von APIs, das Erstellen von REST-APIs und deren Erstellung mit Flask und FastAPI – zwei beliebten Python-Frameworks.

---

1. Einführung in APIs

In der heutigen digitalen Welt gibt es überall APIs.

Sie ermöglichen es verschiedenen Systemen und Anwendungen, miteinander zu kommunizieren und Daten und Funktionen nahtlos auszutauschen.

Wenn Sie beispielsweise eine App verwenden, um das Wetter zu überprüfen, ruft diese tatsächlich eine API auf, die die Wetterdaten zurückgibt.

APIs erleichtern das Leben, indem sie als Vermittler fungieren, die Anfragen verarbeiten und Daten auf standardisierte Weise zurückgeben.

Es ist auch erwähnenswert, dass APIs nicht nur Clientanwendungen (wie Websites oder mobile Apps) bedienen.

APIs können zwischen Backend-Systemen oder Microservices innerhalb derselben Infrastruktur verwendet werden, um Daten effizienter zu verwalten.

---

2. REST-APIs

REST (Representational State Transfer) ist aufgrund seiner Einfachheit und Kompatibilität mit HTTP eine der beliebtesten Methoden zum Erstellen von APIs.

RESTful APIs sind so strukturiert, dass Standard-HTTP-Methoden (wie GET, POST, PUT, DELETE) die Manipulation von Ressourcen ermöglichen.

Sie werden häufig zum Verwalten von CRUD-Vorgängen (Erstellen, Lesen, Aktualisieren und Löschen) verwendet, bei denen jede Anforderungsmethode einen Vorgang für die Ressourcendaten ausführt.

Wenn Sie einen Webdienst erstellen, ist REST wahrscheinlich das am besten zugängliche und am weitesten verbreitete Format.

REST-APIs sind außerdem zustandslos, was bedeutet, dass jede Anfrage unabhängig ausgeführt wird, wodurch REST-APIs einfacher skaliert werden können.

---

3. Erstellen einer API mit Flask

Flask ist meine erste Wahl für kleine oder mittelgroße Projekte, da es leicht ist und sich leicht in Betrieb nehmen lässt.

Mit Flask können Sie fast jeden Aspekt Ihrer API steuern, aber es erfordert auch etwas mehr Arbeit bei der Datenvalidierung und Fehlerbehandlung.

Diese Flexibilität ist jedoch ideal für diejenigen, die mehr Kontrolle über die Funktionsweise jedes Teils der API wünschen.

Beispiel für die Erstellung einer Flask-API

So kann eine Aufgabenverwaltungs-API in Flask aussehen.

Stellen Sie zunächst sicher, dass Sie den Kolben mit Pip installieren:

pip install flask

Dieses Beispiel zeigt, wie Sie schnell Endpunkte zum Abrufen und Erstellen von Aufgaben sowie zum Aktualisieren und Löschen einrichten können.

from flask import Flask, jsonify, request

app = Flask(__name__)

tasks = [
    {"id": 1, "task": "Learn Flask", "done": False},
    {"id": 2, "task": "Build API", "done": False}
]

@app.route('/tasks', methods=['GET'])
def get_tasks():
    return jsonify({"tasks": tasks})

@app.route('/tasks', methods=['POST'])
def create_task():
    new_task = {
        "id": len(tasks) + 1,
        "task": request.json["task"],
        "done": False
    }
    tasks.append(new_task)
    return jsonify(new_task), 201

@app.route('/tasks/<int:task_id>', methods=['GET'])
def get_task(task_id):
    task = next((task for task in tasks if task["id"] == task_id), None)
    if task:
        return jsonify(task)
    return jsonify({"message": "Task not found"}), 404

@app.route('/tasks/<int:task_id>', methods=['PUT'])
def update_task(task_id):
    task = next((task for task in tasks if task["id"] == task_id), None)
    if task:
        task.update(request.json)
        return jsonify(task)
    return jsonify({"message": "Task not found"}), 404

@app.route('/tasks/<int:task_id>', methods=['DELETE'])
def delete_task(task_id):
    task = next((task for task in tasks if task["id"] == task_id), None)
    if task:
        tasks.remove(task)
        return jsonify({"message": "Task deleted"})
    return jsonify({"message": "Task not found"}), 404

if __name__ == '__main__':
    app.run(debug=True)

Dieser Python-Code richtet mithilfe von Flask eine REST-API ein, um eine Liste von Aufgaben zu verwalten, sodass Clients Aufgaben erstellen, abrufen, aktualisieren und löschen können.

Die Aufgaben werden in einer Liste gespeichert, wobei jede Aufgabe ein Wörterbuch mit einer ID, einer Aufgabe und einem erledigten Status ist.

Der /tasks-Endpunkt unterstützt GET-Anfragen, um die vollständige Liste der Aufgaben zurückzugeben, und POST-Anfragen, um neue Aufgaben hinzuzufügen, wobei jeder Aufgabe automatisch eine eindeutige ID zugewiesen wird.

Zusätzliche Endpunkte, /tasks/, ermöglichen Benutzern die Interaktion mit einzelnen Aufgaben: GET ruft eine bestimmte Aufgabe anhand ihrer ID ab, PUT aktualisiert sie und DELETE entfernt sie aus der Liste.

Wenn eine Aufgabe mit der angegebenen ID nicht gefunden wird, geben diese Endpunkte einen 404-Fehler mit einer entsprechenden Meldung zurück.

Die API läuft im Debug-Modus und eignet sich daher ideal für Entwicklungs- und Testzwecke.

Beachten Sie jedoch, dass Sie bei größeren Projekten möglicherweise strukturiertere Routing- und Validierungsmechanismen hinzufügen müssen.

---

4. Erstellen einer API mit FastAPI

FastAPI ist eine ausgezeichnete Wahl für leistungsempfindliche Anwendungen oder Projekte, die etwas mehr Struktur und Typsicherheit erfordern.

FastAPI ist standardmäßig schneller (dank seiner asynchronen Funktionen) und bietet sofort eine robuste Datenvalidierung mit Pydantic.

Ich habe festgestellt, dass FastAPI sehr intuitiv und einfach zu bedienen ist, insbesondere für Projekte, bei denen ich asynchrone Funktionen benötige und eine integrierte Validierung ohne Pakete von Drittanbietern möchte.

Außerdem macht es die automatische Dokumentation (via Swagger UI) äußerst komfortabel.

Beispiel für die Erstellung einer FastAPI-API

So könnte die Aufgabenverwaltungs-API in FastAPI aussehen.

Vergessen Sie nicht, zuerst Fastapi und Uvicorn mit pip:
zu installieren

pip install flask

Dann können Sie die API erstellen:

from flask import Flask, jsonify, request

app = Flask(__name__)

tasks = [
    {"id": 1, "task": "Learn Flask", "done": False},
    {"id": 2, "task": "Build API", "done": False}
]

@app.route('/tasks', methods=['GET'])
def get_tasks():
    return jsonify({"tasks": tasks})

@app.route('/tasks', methods=['POST'])
def create_task():
    new_task = {
        "id": len(tasks) + 1,
        "task": request.json["task"],
        "done": False
    }
    tasks.append(new_task)
    return jsonify(new_task), 201

@app.route('/tasks/<int:task_id>', methods=['GET'])
def get_task(task_id):
    task = next((task for task in tasks if task["id"] == task_id), None)
    if task:
        return jsonify(task)
    return jsonify({"message": "Task not found"}), 404

@app.route('/tasks/<int:task_id>', methods=['PUT'])
def update_task(task_id):
    task = next((task for task in tasks if task["id"] == task_id), None)
    if task:
        task.update(request.json)
        return jsonify(task)
    return jsonify({"message": "Task not found"}), 404

@app.route('/tasks/<int:task_id>', methods=['DELETE'])
def delete_task(task_id):
    task = next((task for task in tasks if task["id"] == task_id), None)
    if task:
        tasks.remove(task)
        return jsonify({"message": "Task deleted"})
    return jsonify({"message": "Task not found"}), 404

if __name__ == '__main__':
    app.run(debug=True)

Dieser Python-Code erstellt mithilfe von FastAPI eine Aufgabenverwaltungs-API und nutzt Pydantic-Modelle für die Datenvalidierung und Typdurchsetzung.

Es definiert ein Aufgabenmodell mit einer ID, einer Aufgabe und einem erledigten Status und initialisiert eine Liste von Aufgaben.

Die API umfasst Endpunkte zum Ausführen von CRUD-Vorgängen für Aufgaben: Der /tasks-Endpunkt ermöglicht GET-Anfragen zum Abrufen der Aufgabenliste und POST-Anfragen zum Hinzufügen einer neuen Aufgabe, wodurch eingehende Daten automatisch validiert werden.

Der /tasks/{task_id}-Endpunkt ermöglicht das Abrufen bestimmter Aufgaben mit GET, das Aktualisieren mit PUT und das Löschen mit DELETE und gibt einen 404-Fehler zurück, wenn eine Aufgabe mit der angegebenen ID nicht gefunden wird.

Die asynchronen Funktionen und die integrierte Dokumentation von FastAPI machen diese API effizient und einfach zu testen, ideal für eine schnelle Entwicklung.

---

5. APIs testen

Testen ist von entscheidender Bedeutung, insbesondere beim Erstellen einer API, die von anderen Anwendungen genutzt wird.

Flask und FastAPI bieten hervorragende Unterstützung für Unit-Tests und machen es einfach, das Verhalten jedes Endpunkts zu überprüfen.

Um das Testen zu vereinfachen, würde ich die Verwendung von Pytest für die allgemeine Teststruktur empfehlen, da es sowohl mit Flask als auch FastAPI kompatibel ist.

Speziell für FastAPI ist TestClient ein hilfreiches Tool, um HTTP-Anfragen zu simulieren und Antworten zu überprüfen.

Sie müssen httpx mit pip:
installieren

pip install flask

Hier ist ein Beispiel zum Testen eines FastAPI-Endpunkts:

from flask import Flask, jsonify, request

app = Flask(__name__)

tasks = [
    {"id": 1, "task": "Learn Flask", "done": False},
    {"id": 2, "task": "Build API", "done": False}
]

@app.route('/tasks', methods=['GET'])
def get_tasks():
    return jsonify({"tasks": tasks})

@app.route('/tasks', methods=['POST'])
def create_task():
    new_task = {
        "id": len(tasks) + 1,
        "task": request.json["task"],
        "done": False
    }
    tasks.append(new_task)
    return jsonify(new_task), 201

@app.route('/tasks/<int:task_id>', methods=['GET'])
def get_task(task_id):
    task = next((task for task in tasks if task["id"] == task_id), None)
    if task:
        return jsonify(task)
    return jsonify({"message": "Task not found"}), 404

@app.route('/tasks/<int:task_id>', methods=['PUT'])
def update_task(task_id):
    task = next((task for task in tasks if task["id"] == task_id), None)
    if task:
        task.update(request.json)
        return jsonify(task)
    return jsonify({"message": "Task not found"}), 404

@app.route('/tasks/<int:task_id>', methods=['DELETE'])
def delete_task(task_id):
    task = next((task for task in tasks if task["id"] == task_id), None)
    if task:
        tasks.remove(task)
        return jsonify({"message": "Task deleted"})
    return jsonify({"message": "Task not found"}), 404

if __name__ == '__main__':
    app.run(debug=True)

Mit beiden Frameworks ist das Testen unkompliziert und ermöglicht Ihnen zu überprüfen, ob sich Ihre API wie erwartet verhält, insbesondere während sie sich weiterentwickelt.

---

6. Vergleich zwischen Flask und FastAPI

Sehen wir uns einen Vergleich zwischen Flask und FastAPI an

Wenn Sie an einem schnellen Prototyp oder einem kleineren Projekt arbeiten, könnte die Einfachheit von Flask alles sein, was Sie brauchen.

Für Projekte, die eine hohe Parallelität, Datenvalidierung oder automatische Dokumentation erfordern, bietet FastAPI eine leistungsfähigere, funktionsreichere Umgebung.

---

7. Fazit

Sowohl Flask als auch FastAPI haben Stärken, die sie für verschiedene Arten von Projekten geeignet machen.

Wenn Sie neu in der Python-Webentwicklung sind, kann Ihnen der Einstieg in Flask dabei helfen, die Grundlagen zu verstehen, bevor Sie zu etwas Fortgeschrittenerem übergehen.

FastAPI hingegen ist eine ideale Wahl, wenn Sie nach einer modernen, leistungsstarken API-Entwicklung mit integrierter Validierung und Dokumentation suchen.

Egal wofür Sie sich entscheiden, Python bietet ein robustes Ökosystem für die API-Entwicklung.

Mit beiden Frameworks können Sie APIs erstellen, die verschiedene Anwendungen unterstützen können, von einfachen Websites bis hin zu komplexen Mikrodiensten.

Der Schlüssel liegt darin, zu experimentieren, die Stärken jedes Frameworks zu verstehen und das richtige Tool für Ihre Bedürfnisse auszuwählen.

Das obige ist der detaillierte Inhalt vonSo erstellen Sie schnell APIs in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!