Datenmodell in Flask erstellen

Unsere Anwendungen sind viel mehr als einfache Seiten, deshalb müssen wir Wege schaffen, um die Daten in einem Persistenzsystem zu speichern Datenbanken Auf dem Spiel steht, dass die Modelle erstellt werden müssen, um festzustellen, wie die Datenbank uns helfen wird.
Ein Modell gibt uns die Struktur vor, unter der die größte Logik unserer Anwendung operiert. Hier geben wir den verschiedenen Entitäten eine Bedeutung, die wir haben müssen, um unsere Handlungen auszuführen.
Flasche Sie haben die Möglichkeit, verschiedene Arten von zu verwenden Datenbanken nur mit dem ORM SQLAlchemy.
AnforderungenWir brauchen eine funktionsfähige Installation von Flasche, und die entsprechenden Berechtigungen, um weitere Komponenten installieren zu können Pip. Wenn wir die Möglichkeit haben mit zu arbeiten Virtualenv es wird viel mehr empfohlen, ist jedoch nicht notwendig. Wenn wir die Tutorial-Beispiele extrapolieren wollen, brauchen wir einige Datenbank Was MySQL falls wir die Funktionalität in eine viel realere Umgebung bringen wollen, da wir in den Übungen damit arbeiten werden sqlite als Vereinfachungsmaßnahme und um praktischer zu sein.
Das erste, was wir tun werden, ist die Installation SQLAlchemie, dieser Schritt ist sehr einfach, wir müssen nur den folgenden Befehl in der zum Ausführen aktivierten Konsole ausführen Pip:

 pip installflakon-sqlalchemy

Am Ende erhalten wir eine Erfolgsmeldung, wenn alles richtig gelaufen ist:

Lass uns jetzt setzen SQLAlchemie Um zu funktionieren, werden wir dafür eine kleine Anwendung erstellen, in der wir sehen, wie wir eine Verbindung mit einer Datenbank-Engine herstellen können. In diesem Fall wird unsere Bewerbung aufgerufen Kolben und darin müssen wir die folgende Struktur haben.
1- Eine Datei namens run.py die sich im Stammverzeichnis der Anwendung befinden wird, ist diese Datei diejenige, die die grundlegende Initialisierung unserer gesamten Umgebung durchführt.
2- Ein Ordner namens Kolben und darin eine Datei namens __init__.py, in der wir die Verwendung von initialisieren werden Flasche und von SQLAlchemie direkt.
Sehen wir uns im folgenden Bild an, wie diese Struktur in einem Projekt aussieht:

Sobald wir wissen, was wir haben sollten, haben wir den Inhalt für unsere anfänglichen Dateien. In der Datei run.py wir müssen folgendes haben:

 aus Flascheno import appapp.run (debug = True)

Dann werden wir in unserer __init__.py-Datei diesen Code platzieren:

 from Flask import Flaskfrom Flask.ext.sqlalchemy import SQLAlchemyapp = Flask (__ name __) app.config ['SQLALCHEMY_DATABASE_URI'] = 'sqlite: //flaskodb.db'db = SQLAlchemy (app)

Dieser letzte Code ist sehr einfach zu erklären, wir importieren einfach Flasche, dann importieren wir SQLAlchemie, wir richten unsere App ein, um mit dem Framework zu arbeiten, und stellen dann die Verbindung zu unserem her Datenbank in diesem Fall sqlite, wo es heißen wird Kolbendb.db und es befindet sich im selben Verzeichnis wie unsere Anwendung. Schließlich weisen wir das Objekt zu SQLAlchemie zu einer Variablen namens db mit denen wir später arbeiten werden.
Wenn wir jetzt unsere Anwendung starten, sollte sie ohne Fehler starten, nur werden wir kein Ergebnis haben, da die Anwendung noch leer ist.
Da wir jetzt die Grundkonfiguration unserer Anwendung haben, müssen wir die Grundlagen für die Erstellung unseres Modells legen. Dazu müssen wir in unserem Ordner einen Ordner erstellen, der die Datei enthält __init__.py und dort generieren wir die notwendigen Inhalte.
Sehen wir uns an, wie unsere Ordnerstruktur geändert wird:

Wie wir in unserem neuen Produktordner sehen können, haben wir 3 Dateien generiert, eine Datei __init__.py die leer sein muss, eine Datei modelle.py und andere ansichten.py. Mit dieser Struktur ändern wir unsere __init__.py aus dem Stamm unserer Anwendung, wobei es wichtig ist, nicht mit der __init__.py von Produkten zu verwechseln.

 from Flask import Flaskfrom Flask.ext.sqlalchemy import SQLAlchemyapp = Flask (__ name __) app.config ['SQLALCHEMY_DATABASE_URI'] = 'sqlite: ///flaskodb.db'db = SQLAlchemy (app) from importflako.product.register_blueprint (Produkt) db.create_all ()

Was wir gemacht haben ist, dass nach der Erstellung des Objekts db wir haben die Ansichten aus unserem neuen Ordner importiert und als registriert Entwurf, schließlich teilen wir dem db-Objekt mit, dass es alle notwendigen Tabellen erstellen muss. Jetzt müssen wir unsere Datei ändern modelle.py innerhalb des Produkts, und wir werden den folgenden Code platzieren:

 fromflako import dbclass Product (db.Model): id = db.Column (db.Integer, primary_key = True) name = db.Column (db.String (255)) price = db.Column (db.Float) def __init__ (self, name, price): self.name = name self.price = price def __repr __ (self): return ''% self.id

Hier im Grunde was wir tun ist eine Klasse definieren die als Attribute die Felder tragen, die wir von unserem Produkt benötigen, auch darin gibt es eine Reihe von Methoden zur Definition und Darstellung unseres Modells.
Sobald dies erledigt ist, gehen wir zur Datei ansichten.py, dabei müssen wir den Code erstellen, der es uns ermöglicht, mit unserem Modell zu interagieren, dafür müssen wir Folgendes schreiben:

 from Flask import request, jsonify, Blueprintfromflako import app, dbfromflako.product.models import Productproduct = Blueprint ('product', __name __) @ app.route ('/') @ app.route ('/start') def start (): return "Welcome to Flasko" @ app.route ('/ product /') def product (id): product = Product.query.get_or_404 (id) return 'Product -% s, $% s'% ( product .name, product.price) @ app.route ('/ products') def products (): products = Product.query.all () res = {} für Produkt in Produkten: res [product.id] = {' name ': product.name,' price ': str (product.price)} return jsonify(res)@app.route (' / create-product ', Methoden = [' POST ',]) def create_product (): name = request.form.get ('Name') Preis = request.form.get ('Preis') Produkt = Produkt (Name, Preis) db.session.add (Produkt) db.session.commit () return 'Das Produkt wurde erfolgreich erstellt '

Das erste, was uns auffällt, ist, dass wir in dieser Datei viel mehr Inhalt haben als im Rest unserer Bewerbung, und das liegt daran, dass hier das ganze Leben unserer Ansicht stattfindet, der erste Weg der Beginn unserer Bewerbung ist und nicht ein größeres Geheimnis beinhalten.
Die zweite und dritte Route dienen der Beratung, bei der wir nach Produkt-ID suchen können und falls keine 404-Seite zurückgegeben werden kann, haben wir auch die Möglichkeit, alle in unserem verfügbaren Produkte aufzulisten Datenbank.
Die letzte Route ist die, die uns durch die Methode ermöglicht POST die Erstellung eines Produktes und dessen anschließende Lagerung in Datenbank, dafür instanziieren wir unser Produktmodell, wo wir dann das Attribut an das Objekt übergeben db und mit seinen Methoden hinzufügen Ja begehen wir fügen es hinzu Datenbank.
Jetzt müssen wir unsere Anwendung testen, um den Inhalt hinzuzufügen, der in unsere Datenbank aufgenommen wird, wenn wir uns in der Datei erinnern ansichten.py wir erstellen eine Ansicht, die Daten über die Methode empfängt POST und es ist derjenige, der für die Einfügungen verantwortlich ist. Um Elemente hinzuzufügen, verwenden wir ein Modul Python namens Anfragen Damit können wir Daten per POST senden, wenn wir sie nicht zur Verfügung haben, müssen wir sie einfach mit dem folgenden Befehl installieren:

 Pip-Installationsanfragen

In einer sekundären Konsole werden wir unsere Anwendung starten Kolben damit der Server läuft und die Anfragen von Python. In unserer interaktiven Konsole Python auf die wir zugreifen, indem wir das Wort schreiben Python, müssen wir Folgendes tun:

 request.post ('http://127.0.0.1:5000/ create-product', data = {'name': 'product1', 'price': '50'})

Was wir gemacht haben, war eine Anfrage per POST zu unserer Route, die die Elemente zur Datenbank hinzufügt, werden die Parameter in einem Wörterbuch übergeben Python was einem Objekt sehr ähnlich ist JSON.
Dies sollte uns einen Code 200 geben, der bedeutet, dass wir unsere Anfrage effektiv erfüllt haben, wir können dies in der folgenden Abbildung sehen:

Wenn wir nun in der Produktansicht zu unserer Anwendung navigieren, sehen wir, wie wir das, was wir gerade über die Konsole eingegeben haben, erhalten:

Wir sehen, dass wir eine Liste im Format haben JSON mit unserem Produkt, das wir gerade hinzugefügt haben, wenn wir jetzt eine Suche auf der Route durchführen Produkt / 1 wir werden sehen, dass wir es auch bekommen:

Natürlich ist dies alles andere als produktionswürdig, aber es hilft uns, die Grundlagen von Modellen und Datenpersistenz innerhalb von . zu erlernen Flasche, das Interessanteste ist, dass wir nicht nachgefragt haben SQL direkt, wenn wir die Verbindung ändern auf sqlite für einen zu MySQL zum Beispiel wird unsere Anwendung wie gewohnt weiterarbeiten.
Damit haben wir dieses Tutorial abgeschlossen, wir wissen bereits, wie man Modelle in . erstellt FlascheDarüber hinaus haben wir gelernt, auf einfache, aber sehr nützliche Weise die ORM SQLAlchemy, wo diese Komponenten sehr wichtig sind, wenn wir viel größere Anwendungen erstellen, da sie es uns ermöglichen, mit weniger Aufwand komplexere Ergebnisse zu erzielen.