Skapa datamodell i Flask

Våra applikationer är mycket mer än enkla sidor, det är därför vi måste skapa sätt att lagra data i något uthållighetssystem, det är här Databaser på spel där för att fastställa hur databasen ska hjälpa oss är att modellerna måste skapas.
En modell ger oss strukturen enligt vilken den största logiken i vår applikation kommer att fungera, det är här vi ger en mening till de olika enheter som vi måste ha för att utföra våra handlingar.
Flaska du har möjlighet att använda olika typer av Databaser använder bara ORM SQLAlchemy.
KravVi behöver en funktionell installation av Flaska, och respektive behörighet för att kunna installera fler komponenter genom pip. Om vi ​​har möjlighet att arbeta med Virtualenv det är mycket mer rekommenderat, men det är inte nödvändigt. Om vi ​​vill extrapolera handledningsexemplen behöver vi några Databas Vad MySQL om vi vill föra funktionaliteten till en mycket mer verklig miljö, eftersom vi kommer att arbeta med övningarna sqlite som en förenklingsåtgärd och för att vara mer praktisk.
Det första vi ska göra är att installera SQLAlchemy, det här steget är mycket enkelt, vi behöver bara utföra följande kommando i konsolen som kan köras pip:

 pip installera flask-sqlalchemy

I slutet kommer vi att få ett framgångsmeddelande om allt har gått rätt:

Låt oss nu sätta SQLAlchemy för att arbeta, för detta kommer vi att skapa en liten applikation där vi kommer att se hur vi kan upprätta en anslutning med en databasmotor. I det här fallet kommer vår ansökan att kallas flasko och inom den måste vi ha följande struktur.
1- En fil med namnet run.py som kommer att vara i roten till applikationen, den här filen är den som gör den grundläggande initialiseringen av hela vår miljö.
2- En mapp med namnet flasko och inuti denna en fil som heter __init__.py som är där vi kommer att initiera användningen av flaska och av SQLAlchemy direkt.
Låt oss se i följande bild hur denna struktur ser ut i ett projekt:

När vi vet vad vi ska ha kommer vi att ha innehållet för våra första filer. I filen run.py vi måste ha följande:

 från flasko import appapp.run (debug = True)

Sedan kommer vi att placera denna kod i vår __init__.py -fil:

 från flaskimport Flaskfrån flask.ext.sqlalchemy import SQLAlchemyapp = Kolv (__ namn __) app.config ['SQLALCHEMY_DATABASE_URI'] = 'sqlite: //flaskodb.db'db = SQLAlchemy (app)

Denna sista kod är mycket lätt att förklara, vi importerar bara Flaska, sedan importerar vi SQLAlchemy, vi etablerar vår app för att arbeta med ramarna och sedan etablerar vi anslutningen med vår Databas I detta fall sqlite, där det kommer att kallas flaskdb.db och det kommer att finnas i samma katalog som vår applikation. Slutligen tilldelar vi objektet SQLAlchemy till en variabel som heter db som vi kommer att arbeta med senare.
Om vi ​​startar vår applikation nu ska den starta utan fel, det enda är att vi inte kommer att få ett resultat eftersom applikationen fortfarande är tom.
Eftersom vi har den grundläggande konfigurationen av vår applikation nu måste vi lägga grunden för att skapa vår modell, för detta måste vi skapa en mapp i vår mapp som innehåller filen __init__.py och det är där vi kommer att skapa det nödvändiga innehållet.
Låt oss se hur vår mappstruktur ändras:

Som vi kan se inuti vår nya produktmapp har vi genererat tre filer, en fil __init__.py som måste vara tom, en fil modeller. py och andra views.py. Med denna struktur kommer vi att ändra vår __init__.py från roten i vår applikation, där det är viktigt att inte förväxla med __init__.py av produkter.

 från flaskimport Flaskfrån flask.ext.sqlalchemy import SQLAlchemyapp = Kolv (__ namn __) app.config ['SQLALCHEMY_DATABASE_URI'] = 'sqlite: ///flaskodb.db'db = SQLAlchemy (app) från import flasko.product. register_blu (produkt) db.create_all ()

Det vi har gjort är att efter skapandet av objektet db vi har importerat vyer från vår nya mapp och registrerat en plan, slutligen säger vi till db -objektet att det måste skapa alla nödvändiga tabeller. Nu måste vi ändra vår fil modeller. py inuti produkten, och vi kommer att placera följande kod:

 från flasko import dbclass Product (db.Model): id = db.Column (db.Integer, primary_key = True) namn = 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

Här är i princip vad vi gör definiera en klass som kommer att bära som attribut de fält som vi kommer att kräva av vår produkt, även inom den finns det ett par metoder för definition och representation av vår modell.
När ovanstående har uppnåtts går vi till filen views.py, i detta måste vi skapa koden som gör att vi kan interagera med vår modell för detta måste vi skriva följande:

 från kolvimportbegäran, jsonify, Blueprintfrån flaskoimportapp, dbfrom flasko.product.models import Productproduct = Blueprint ('produkt', __namn __) @ app.route ('/') @ app.route ('/ start') def start (): returnera "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 = {} for product in products: res [product.id] = {' name ': product.name,' price ': str (product.price)} return jsonify(res)@app.route (' / create-product ', methods = [' POST ',]) def create_product (): name = request.form.get ('namn') pris = request.form.get ('pris') produkt = Produkt (namn, pris) db.session.add (produkt) db.session.commit () return 'Produkten skapades framgångsrikt '

Det första vi märker är att vi har mycket mer innehåll i den här filen än i resten av vår applikation och det är för att det är här som hela vår synvinkel äger rum, den första vägen är början på vår ansökan och inte innebär något större mysterium.
Den andra och tredje rutten är för konsultation, där vi kan söka efter produkt -id och om det inte finns något att returnera en 404 -sida, har vi också funktionalitet för att lista alla produkter som finns tillgängliga i vår Databas.
Den sista rutten är den som tillåter oss genom metoden POSTA skapandet av en produkt och dess efterföljande lagring i Databas, för detta instanserar vi vår produktmodell, där vi sedan skickar attributet till objektet db och med hans metoder Lägg till Y begå lägger vi till det Databas.
Det som återstår att testa vår applikation är att lägga till innehållet som kommer att finnas i vår databas, om vi kommer ihåg det i filen views.py vi skapar en vy som tar emot data genom metoden POSTA och det är den som ansvarar för att göra insatserna i den. För att lägga till element kommer vi att använda en modul Pytonorm kallad förfrågningar som tillåter oss att skicka data via POST, om vi inte har den tillgänglig måste vi helt enkelt installera den med följande kommando:

 pip -installationsförfrågningar

I en sekundärkonsol ska vi starta vår applikation flasko så att servern är uppe och för att kunna skicka förfrågningarna från Pytonorm. I vår interaktiva konsol Pytonorm som vi kommer åt genom att skriva ordet pytonormmåste vi göra följande:

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

Det vi gjorde var att skicka en förfrågan via POSTA till vår rutt som lägger till elementen i databasen, skickas parametrarna i en ordlista Pytonorm som liknar ett objekt mycket JSON.
Detta bör ge oss en kod 200 som betyder att vi effektivt har lyckats med vår begäran, vi kan se detta i följande bild:

Om vi ​​nu navigerar till vår applikation i produktvyn kommer vi att se hur vi får det vi just skrivit in genom konsolen:

Vi ser att vi har en lista i format JSON med vår produkt som vi precis har lagt till, om vi nu gör en sökning på rutten produkt / 1 vi kommer att se att vi också kommer att få det:

Naturligtvis är detta långt ifrån något som är värt att sättas i produktion, men det hjälper oss att lära oss grunderna i modeller och datapersistens inom Flaska, det mest intressanta är att eftersom vi inte har gjort förfrågningar SQL direkt, om vi ändrar anslutningen till sqlite för en till MySQL Till exempel kommer vår applikation att fungera som vanligt.
Med detta har vi avslutat den här självstudien, vi vet redan hur vi skapar modeller i FlaskaDessutom har vi lärt oss att manipulera på ett grundläggande men mycket användbart sätt ORM SQLAlchemy, där dessa komponenter är mycket viktiga när vi bygger mycket större applikationer eftersom de gör att vi kan uppnå mer komplexa resultat med mindre arbete.