Flask-RESTful: Erstellen von RESTful-APIs mit Python

Flask-RESTful: Erstellen von RESTful-APIs mit Python

Mit dem Aufkommen moderner Internetdienste sind RESTful-APIs zum Standard für Kommunikationsprotokolle geworden. Um hochwertige RESTful-APIs zu entwickeln, verfügt Python über ein effizientes Framework, Flask-RESTful. In diesem Artikel wird vorgestellt, was Flask-RESTful ist und wie man mit Python eine RESTful-API erstellt.

Teil 1: RESTful API verstehen
REST (Representational State Transfer) ist ein Webdienst-Architekturstil, der auf dem HTTP-Protokoll basiert. Er ermöglicht es dem Client, Zugriff anzufordern und Ressourcen zu erhalten, und ermöglicht dem Server, die angeforderten Ressourcen zurückzugeben. API (Application Programming Interface) ist ein Kommunikationsprotokoll zwischen Programmen und Systemen, das es verschiedenen Anwendungen ermöglicht, über definierte Schnittstellen miteinander zu kommunizieren, um bestimmte Aufgaben auszuführen. Eine RESTful-API besteht aus zwei Teilen: Ressourcen (URIs) und Verhaltensweisen (HTTP-Methoden).

Ressourcen sind der Kern der RESTful-API, die die Darstellung interner Daten darstellen. Ein URI (Uniform Resource Identifier) ​​gibt den Standort jeder Ressource an, und jede Ressource verfügt über einen eindeutigen URI. Das Verhalten hingegen gibt an, wie auf eine Ressource zugegriffen und sie manipuliert wird. Die RESTful-API verwendet HTTP-Methoden, um diese Vorgänge zu definieren. Beispielsweise wird die GET-Methode zum Abrufen von Ressourcen, die POST-Methode zum Erstellen von Ressourcen, die PUT-Methode zum Aktualisieren von Ressourcen und die DELETE-Methode zum Löschen von Ressourcen verwendet.

Teil 2: Einführung in Flask-RESTful
Flask-RESTful ist ein Erweiterungsmodul von Flask und ein Python-RESTful-Framework. Es bietet vereinfachte Methoden und Tools zum Erstellen von RESTful-APIs. Die Vorteile von Flask-RESTful sind wie folgt:

1. Einfach zu verwenden
Flask-RESTful ist ein leichtes Framework, das auf dem Flask-Framework basiert. Es bietet eine Reihe einfacher Tools, mit denen Entwickler schnell RESTful-APIs erstellen können, ohne viel sich wiederholenden Code schreiben zu müssen.

2. Schnelle Entwicklung
Dank einiger vereinfachter Methoden, wie z. B. der Analyse von Anforderungsparametern und der Routenerstellung, kann die API-Entwicklungszeit erheblich verkürzt werden.

3. Bietet Unterstützung für Erweiterung und Anpassung.
Flask-RESTful bietet flexible Erweiterungs- und Anpassungspunkte, und Entwickler können seine Funktionen nach Bedarf erweitern.

4. Die Dokumentation ist sehr detailliert. Die Dokumentation von Flask-RESTful ist sehr detailliert und einfach zu erlernen und zu verwenden.

Teil 3: So verwenden Sie Flask-RESTful

Als nächstes stellen wir vor, wie Sie Flask-RESTful zum Erstellen einer RESTful-API verwenden. Wir erstellen eine einfache API zum Verwalten von Filmdaten. Mit dieser API kann der Client die folgenden Vorgänge ausführen:

1. Detaillierte Informationen zu einem Film abrufen

4. Filmdatensätze löschen

. Installieren und konfigurieren Sie Flask-RESTful und erstellen Sie eine virtuelle Python-Umgebung. Installieren Sie Flask-RESTful mit dem folgenden Befehl (stellen Sie sicher, dass pip installiert ist):

pip install flask-restful

Als nächstes erstellen Sie eine app.py-Datei. Diese Datei muss die erforderlichen Module und Bibliotheken importieren. Diese Datei definiert und implementiert die Flask-Anwendung.

from flask import Flask, request
from flask_restful import Resource, Api, reqparse

app = Flask(__name__)
api = Api(app)

Hier stellen wir Flask- und Flask-RESTful-Bibliotheken und -Module vor. Als nächstes definieren wir einige Dummy-Daten.

movies = [
{ 'id': 1, 'title': 'The Shawshank Redemption', 'director': 'Frank Darabont', 'year_released': 1994},
{ 'id': 2, 'title': 'Forrest Gump', 'director': 'Robert Zemeckis', 'year_released': 1994},
{ 'id': 3, 'title': 'The Matrix', 'director': 'The Wachowski Brothers', 'year_released': 1999},
{ 'id': 4, 'title': 'Léon: The Professional', 'director': 'Luc Besson', 'year_released': 1994},
{ 'id': 5, 'title': 'The Dark Knight', 'director': 'Christopher Nolan', 'year_released': 2008},
{ 'id': 6, 'title': 'Interstellar', 'director': 'Christopher Nolan', 'year_released': 2014},
{ 'id': 7, 'title': 'Inception', 'director': 'Christopher Nolan', 'year_released': 2010},
{ 'id': 8, 'title': 'The Lord of the Rings: The Fellowship of the Ring', 'director': 'Peter Jackson', 'year_released': 2001},
{ 'id': 9, 'title': 'Gladiator', 'director': 'Ridley Scott', 'year_released': 2000},
{ 'id': 10, 'title': 'The Godfather', 'director': 'Francis Ford Coppola', 'year_released': 1972}
]

Jetzt erstellen Sie 5 verschiedene Ressourcen, um 5 verschiedene HTTP-Anfragen zu verarbeiten: GET, POST, PUT, DELETE.

class MovieList(Resource):
    def get(self):
        return { 'movies': movies }

    def post(self):
        parser = reqparse.RequestParser()
        parser.add_argument('title', type=str, required=True, help='Title is required.')
        parser.add_argument('director', type=str, required=True, help='Director is required.')
        parser.add_argument('year_released', type=int, required=True, help='Year must be a number.')
        args = parser.parse_args()

        movie = {
        'id': len(movies) + 1,
        'title': args['title'],
        'director': args['director'],
        'year_released': args['year_released']
        }

        movies.append(movie)
        return movie, 201

class Movie(Resource):
    def get(self, movie_id):
        movie = next(filter(lambda x:x['id']==movie_id, movies), None)
        return {'movie': movie}, 200 if movie else 404

    def put(self, movie_id):
        parser = reqparse.RequestParser()
        parser.add_argument('title', type=str, required=True, help='Title is required.')
        parser.add_argument('director', type=str, required=True, help='Director is required.')
        parser.add_argument('year_released', type=int, required=True, help='Year must be a number.')
        args = parser.parse_args()

        movie = next(filter(lambda x:x['id']==movie_id, movies), None)
        if movie is None:
            movie = {'id': movie_id, 'title': args['title'], 'director': args['director'], 'year_released': args['year_released']}
            movies.append(movie)
        else:
            movie.update(args)
        return movie

    def delete(self, movie_id):
        global movies
        movies = list(filter(lambda x:x['id']!=movie_id, movies))
        return {'message': 'Movie deleted.'}, 200

Diese Ressourcen werden Pfaden zugeordnet, die der URL zugeordnet sind.

api.add_resource(MovieList, '/movies')
api.add_resource(Movie, '/movies/<int:movie_id>')

Starten Sie nun die Flask-Anwendung und überprüfen Sie den lokalen Host (http://127.0.0.1:5000/movies). Wir können die API-Liste sehen, die wir gerade erstellt haben:

{
"movies": [
    {
      "director": "Frank Darabont", 
      "id": 1, 
      "title": "The Shawshank Redemption", 
      "year_released": 1994
    },
    ...
  ]
}

Jetzt können wir mit dem eine neue hinzufügen POST-Methode Film.

import requests

url = 'http://localhost:5000/movies'
data = {"title": "The Green Mile", "director": "Frank Darabont", "year_released": "1999"}
res = requests.post(url, data=data)

Die vollständige Anfrage und Antwort sieht so aus:

<Response [201]>
{'id': 11, 'title': 'The Green Mile', 'director': 'Frank Darabont', 'year_released': 1999}

Wir können auch die PUT-Methode verwenden, um Filminformationen zu aktualisieren.

url = 'http://localhost:5000/movies/11'
data = {"title": "The Green Mile", "director": "Frank Darabont", "year_released": "1999"}
res = requests.put(url, data=data)

Lass uns zum Schluss einen Film löschen.

url = 'http://localhost:5000/movies/11'
res = requests.delete(url)

Wir haben eine einfache RESTful-API mithilfe des Flask-RESTful-Frameworks erstellt, um die Entwicklung und Wartung zu vereinfachen. Die RESTful API ist eine wesentliche Komponente für die Entwicklung von Webanwendungen. Sie ermöglicht Clients den Zugriff auf und die Aktualisierung von Ressourcen und legt den Schwerpunkt auf URI- und HTTP-Methoden. Die gleichzeitige Verwendung von Flask-RESTful kann die Entwicklung des Teams beschleunigen und den Code vereinfachen.

Das obige ist der detaillierte Inhalt vonFlask-RESTful: Erstellen von RESTful-APIs mit Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!