Gegevensmodel maken in Flask

Onze applicaties zijn veel meer dan eenvoudige pagina's, daarom moeten we manieren creëren om de gegevens op te slaan in een of ander persistentiesysteem, dit is waar de Databases waar het om gaat, om vast te stellen op welke manier de database ons gaat helpen, is dat de modellen moeten worden gemaakt.
Een model geeft ons de structuur waaronder de grootste logica van onze applicatie zal werken, dit is waar we een betekenis geven aan de verschillende entiteiten waarmee we moeten beschikken om onze acties uit te voeren.
Kolf je hebt de mogelijkheid om verschillende soorten Databases alleen met behulp van de ORM SQLAlchemie.
VereistenWe hebben een functionele installatie nodig van: Kolf, en de respectievelijke rechten om meer componenten te kunnen installeren via Pip. Als we de mogelijkheid hebben om samen te werken met virtuele omgeving het is veel meer aanbevolen, maar het is niet nodig. Als we de tutorialvoorbeelden willen extrapoleren, hebben we er een nodig Database Wat MySQL voor het geval we de functionaliteit naar een veel reëlere omgeving willen brengen, aangezien we in de oefeningen waarmee we zullen werken sqlite als vereenvoudigingsmaatregel en om praktischer te zijn.
Het eerste wat we zullen doen is installeren SQLAlchemie, deze stap is heel eenvoudig, we hoeven alleen de volgende opdracht uit te voeren in de console die is ingeschakeld om te worden uitgevoerd: Pip:

 pip install flask-sqlalchemy

Aan het einde krijgen we een succesbericht als alles correct is verlopen:

Laten we nu zeggen SQLAlchemie om te werken, hiervoor gaan we een kleine applicatie maken waarin we zullen zien hoe we een verbinding kunnen maken met een database-engine. In dit geval wordt onze applicatie genoemd fles en daarbinnen moeten we de volgende structuur hebben.
1- Een bestand met de naam run.py dat zal in de root van de applicatie zijn, dit bestand is degene die de basisinitialisatie van onze hele omgeving uitvoert.
2- Een map met de naam fles en hierin een bestand met de naam __init__.py waar we het gebruik van zullen initialiseren kolf en van SQLAlchemie direct.
Laten we in de volgende afbeelding zien hoe deze structuur eruitziet in een project:

Zodra we weten wat we moeten hebben, hebben we de inhoud voor onze eerste bestanden. In het bestand run.py we moeten het volgende hebben:

 van flasko import appapp.run (debug = True)

Vervolgens gaan we deze code in ons __init__.py-bestand plaatsen:

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

Deze laatste code is heel gemakkelijk uit te leggen, we importeren alleen Kolf, dan importeren we SQLAlchemie, we stellen onze app op om met het raamwerk te werken en vervolgens brengen we de verbinding tot stand met onze Database in dit geval sqlite, waar het zal worden genoemd flaskdb.db en het zal in dezelfde map staan ​​als onze applicatie. Ten slotte wijzen we het object toe SQLAlchemie naar een variabele genaamd db waarmee we later zullen werken.
Als we onze applicatie nu starten, zou deze zonder fouten moeten starten, het enige is dat we geen resultaat zullen hebben omdat de applicatie nog leeg is.
Omdat we nu de basisconfiguratie van onze applicatie hebben, moeten we de basis leggen om ons model te maken, hiervoor zullen we een map in onze map moeten maken die het bestand bevat __init__.py en daar zullen we de nodige content genereren.
Laten we eens kijken hoe onze mappenstructuur wordt gewijzigd:

Zoals we in onze nieuwe productmap kunnen zien, hebben we 3 bestanden gegenereerd, een bestand __init__.py die leeg moet zijn, een bestand modellen.py en andere views.py. Met deze structuur gaan we onze __init__.py wijzigen vanuit de root van onze applicatie, waarbij het belangrijk is om niet te verwarren met de __init__.py van producten.

 from flask import Flaskfrom flask.ext.sqlalchemy import SQLAlchemyapp = Flask (__ naam __) app.config ['SQLALCHEMY_DATABASE_URI'] = 'sqlite: ///flaskodb.db'db = SQLAlchemy (app) van import flasko.product. register_blueprint. (product) db.create_all ()

Wat we hebben gedaan, is dat na de creatie van het object db we hebben de views geïmporteerd uit onze nieuwe map en geregistreerd a blauwdruk, ten slotte vertellen we het db-object dat het alle benodigde tabellen moet maken. Nu moeten we ons bestand aanpassen modellen.py inside product, en we zullen de volgende code plaatsen:

 van flasko import dbclass Product (db.Model): id = db.Kolom (db.Integer, primary_key = True) naam = db.Kolom (db.String (255)) prijs = db.Kolom (db.Float) def __init__ (zelf, naam, prijs): zelf.naam = naam zelf.prijs = prijs def __repr __ (zelf): return ''% self.id

Hier doen we eigenlijk: een klasse definiëren die als attributen de velden zal bevatten die we van ons product nodig hebben, ook daarbinnen zijn er een aantal methoden voor de definitie en representatie van ons model.
Zodra het bovenstaande is bereikt, gaan we naar het bestand views.py, hierin moeten we de code maken waarmee we met ons model kunnen communiceren, hiervoor moeten we het volgende schrijven:

 from flask import request, jsonify, Blueprintfrom flasko import app, dbfrom flasko.product.models import Productproduct = Blueprint ('product', __name __) @ app.route ('/') @ app.route ('/ start') def start (): return "Welkom bij 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 = {} voor product in producten: res [product.id] = {' name ': product.name,' price ': str (product.price)} return jsonify(res)@app.route (' / create-product ', methods = [' POST ',]) def create_product (): naam = request.form.get ('naam') prijs = request.form.get ('prijs') product = Product (naam, prijs) db.session.add (product) db.session.commit () return 'Het product is succesvol aangemaakt '

Het eerste dat ons opvalt, is dat we veel meer inhoud in dit bestand hebben dan in de rest van onze applicatie en omdat dit is waar het hele leven van onze visie plaatsvindt, is de eerste route het begin van onze applicatie en niet een groter mysterie inhouden.
De tweede en derde route zijn voor overleg, waar we kunnen zoeken op product-ID en als er niets is om een ​​404-pagina terug te geven, hebben we ook de functionaliteit om alle beschikbare producten in onze Database.
De laatste route is degene die ons door de methode leidt NA het creëren van een product en de daaropvolgende opslag in Database, hiervoor instantiëren we ons productmodel, waar we vervolgens het attribuut doorgeven aan het object db en met zijn methoden toevoegen Y verbinden we voegen het toe aan Database.
Wat nu nog moet gebeuren om onze applicatie te testen, is om de inhoud toe te voegen die in onze database zal komen, als we het ons herinneren in het bestand views.py we creëren een weergave die gegevens ontvangt via de methode NA en het is degene die verantwoordelijk is voor het maken van de invoegingen erin. Om elementen toe te voegen gaan we een module gebruiken Python genaamd verzoeken waarmee we gegevens via POST kunnen verzenden, als we het niet beschikbaar hebben, hoeven we het gewoon te installeren met het volgende commando:

 pip installatieverzoeken

In een secundaire console gaan we onze applicatie starten fles zodat de server up is en om de verzoeken te kunnen verzenden van Python. In onze interactieve console Python waartoe we toegang hebben door het woord te schrijven Python, moeten we het volgende doen:

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

Wat we deden was een verzoek sturen via NA naar onze route die de elementen aan de database toevoegt, worden de parameters doorgegeven in een woordenboek Python wat erg lijkt op een object JSON.
Dit zou ons een code 200 moeten geven, wat betekent dat we effectief in ons verzoek zijn geslaagd, we kunnen dit zien in de volgende afbeelding:

Als we nu naar onze applicatie navigeren in de productenweergave, zullen we zien hoe we verkrijgen wat we zojuist via de console hebben ingevoerd:

We zien dat we een lijst in formaat hebben JSON met ons product dat we zojuist hebben toegevoegd, als we nu op de route zoeken artikel / 1 we zullen zien dat we het ook zullen krijgen:

Dit is natuurlijk verre van iets dat het waard is om in productie te worden genomen, maar het helpt ons de basisprincipes van modellen en datapersistentie binnen Kolf, het meest interessante is dat aangezien we geen navraag hebben gedaan SQL direct, als we de verbinding wijzigen in sqlite voor één om MySQL onze applicatie blijft bijvoorbeeld gewoon werken.
Hiermee hebben we deze tutorial afgerond, we weten al hoe we modellen moeten maken in KolfBovendien hebben we geleerd om op een eenvoudige, maar zeer nuttige manier te manipuleren met de ORM SQLAlchemie, waar deze componenten erg belangrijk zijn wanneer we veel grotere applicaties bouwen, omdat ze ons in staat stellen om complexere resultaten te bereiken met minder werk.