Opret datamodel i Flask

Vores applikationer er meget mere end simple sider, derfor skal vi oprette måder at gemme dataene i et eller andet persistenssystem, det er her, Databaser på spil, hvor for at fastslå, hvordan databasen skal hjælpe os, er, at modellerne skal oprettes.
En model giver os den struktur, under hvilken den største logik i vores applikation vil fungere, det er her, vi giver en mening til de forskellige enheder, som vi skal have med for at udøve vores handlinger.
Kolbe du har mulighed for at bruge forskellige typer af Databaser kun ved hjælp af ORM SQLAlchemy.
KravVi har brug for en funktionel installation af Kolbe, og de respektive tilladelser til at kunne installere flere komponenter igennem pip. Hvis vi har mulighed for at arbejde med Virtualenv det er meget mere anbefalet, men det er ikke nødvendigt. Hvis vi vil ekstrapolere vejledningseksemplerne, skal vi bruge nogle Database Hvad MySQL hvis vi ønsker at bringe funktionaliteten til et meget mere virkeligt miljø, da vi i øvelserne vil arbejde med sqlite som en forenkling og for at være mere praktisk.
Den første ting, vi vil gøre, er at installere SQLAchemy, dette trin er meget enkelt, vi behøver kun at udføre følgende kommando i konsollen, der er aktiveret til at køre pip:

 pip installer kolbe-sqlalchemy

I slutningen får vi en succesbesked, hvis alt er gået korrekt:

Lad os nu sætte SQLAchemy for at arbejde, til dette skal vi oprette en lille applikation, hvor vi vil se, hvordan vi kan etablere en forbindelse med en database -motor. I dette tilfælde vil vores ansøgning blive kaldt flasko og inden for den skal vi have følgende struktur.
1- En fil med navnet run.py det vil være i roden af ​​applikationen, denne fil er den, der foretager den grundlæggende initialisering af hele vores miljø.
2- En mappe med navnet flasko og inde i denne en fil kaldet __init__.py, som er hvor vi vil initialisere brugen af kolbe og af SQLAchemy direkte.
Lad os se på følgende billede, hvordan denne struktur ser ud i et projekt:

Når vi ved, hvad vi skal have, har vi indholdet til vores første filer. I filen run.py vi skal have følgende:

 fra flasko import appapp.run (debug = True)

Derefter placerer vi denne kode i vores __init__.py -fil:

 fra kolbe import Flask fra flask.ext.sqlalchemy import SQLAlchemyapp = Kolbe (__ navn __) app.config ['SQLALCHEMY_DATABASE_URI'] = 'sqlite: //flaskodb.db'db = SQLAlchemy (app)

Denne sidste kode er meget let at forklare, vi importerer bare Kolbe, så importerer vi SQLAchemy, vi etablerer vores app til at arbejde med rammerne, og derefter etablerer vi forbindelsen med vores Database I dette tilfælde sqlite, hvor det vil blive kaldt flaskdb.db og det vil være i samme bibliotek som vores applikation. Endelig tildeler vi objektet SQLAchemy til en variabel kaldet db som vi senere vil arbejde med.
Hvis vi starter vores ansøgning nu, skal den starte uden fejl, det eneste er, at vi ikke får et resultat, fordi applikationen stadig er tom.
Da vi har den grundlæggende konfiguration af vores applikation nu, skal vi lægge grundlaget for at oprette vores model, for dette bliver vi nødt til at oprette en mappe i vores mappe, der indeholder filen __init__.py og det er her, vi vil generere det nødvendige indhold.
Lad os se, hvordan vores mappestruktur ændres:

Som vi kan se inde i vores nye produktmappe, har vi genereret 3 filer, en fil __init__.py som skal være tom, en fil modeller.py og andre views.py. Med denne struktur vil vi ændre vores __init__.py fra roden af ​​vores applikation, hvor det er vigtigt ikke at forveksle med __init__.py af produkter.

 fra kolbe import Flask fra flask.ext.sqlalchemy import SQLAlchemyapp = Kolbe (__ navn __) app.config ['SQLALCHEMY_DATABASE_URI'] = 'sqlite: ///flaskodb.db'db = SQLAlchemy (app) fra import flasko.product. register_blu (produkt) db.create_all ()

Det, vi har gjort, er det efter oprettelsen af ​​objektet db vi har importeret visningerne fra vores nye mappe og registreret en blueprint, endelig fortæller vi db -objektet, at det skal oprette alle de nødvendige tabeller. Nu skal vi ændre vores fil modeller.py inde i produktet, og vi vil placere følgende kode:

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

Her er det grundlæggende, hvad vi gør definere en klasse der som egenskaber vil bære de felter, vi vil kræve fra vores produkt, også inden for det er der et par metoder til definition og repræsentation af vores model.
Når ovenstående er opnået, går vi til filen views.py, i dette skal vi oprette den kode, der giver os mulighed for at interagere med vores model til dette, skal vi skrive følgende:

 fra anmodning om kolbeimport, jsonify, Blueprint fra flasko -importapp, dbfrom flasko.product.models import Productproduct = Blueprint ('produkt', __navn __) @ app.route ('/') @ app.route ('/ start') def start (): returner "Welcome to Flasko" @ app.route (' / product /') def product (id): product = Product.query.get_or_404 (id) return 'Product -% s, $% s'% ( produkt. navn, produkt.pris) @ app.route ('/ produkter') def produkter (): products = Product.query.all () res = {} for produkt i produkter: 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 ('navn') pris = request.form.get ('pris') produkt = Produkt (navn, pris) db.session.add (produkt) db.session.commit () returner 'Produktet blev oprettet med succes '

Den første ting, vi bemærker, er, at vi har meget mere indhold i denne fil end i resten af ​​vores ansøgning, og det er fordi det er her, hele vores livssyn finder sted, den første rute er begyndelsen på vores ansøgning og gør det ikke indebære noget større mysterium.
Den anden og tredje rute er til høring, hvor vi kan søge efter produkt -id, og hvis der ikke er noget at returnere en 404 -side, har vi også funktionaliteten til at liste alle de tilgængelige produkter i vores Database.
Den sidste rute er den, der tillader os gennem metoden STOLPE oprettelsen af ​​et produkt og dets efterfølgende opbevaring i Database, for dette instantierer vi vores produktmodel, hvor vi derefter sender attributten til objektet db og med hans metoder tilføje Y begå vi tilføjer det til Database.
Det, der er tilbage for at teste vores applikation, er at tilføje det indhold, der vil komme i vores database, hvis vi husker det i filen views.py vi opretter en visning, der modtager data via metoden STOLPE og det er den, der er ansvarlig for at foretage indsættelser i den. For at tilføje elementer skal vi bruge et modul Python hedder anmodninger det giver os mulighed for at sende data via POST, hvis vi ikke har dem tilgængelige, skal vi blot installere dem med følgende kommando:

 pip installationsanmodninger

I en sekundær konsol starter vi vores applikation flasko så serveren er oppe og kan sende anmodningerne fra Python. I vores interaktive konsol Python hvortil vi får adgang ved at skrive ordet python, skal vi gøre følgende:

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

Det vi gjorde var at sende en anmodning via STOLPE til vores rute, der tilføjer elementerne til databasen, sendes parametrene i en ordbog Python som minder meget om et objekt JSON.
Dette skulle give os en kode 200, der betyder, at vi faktisk er lykkedes med vores anmodning, vi kan se dette i følgende billede:

Hvis vi nu navigerer til vores applikation i produktvisningen, ser vi, hvordan vi får det, vi lige har indtastet via konsollen:

Vi ser, at vi har en liste i format JSON med vores produkt, som vi lige har tilføjet, hvis vi nu søger på ruten produkt / 1 vi vil se, at vi også får det:

Selvfølgelig er dette langt fra noget, der er værd at sætte i produktion, men det hjælper os med at lære det grundlæggende i modeller og datapersistens inden for Kolbe, det mest interessante er, at da vi ikke har foretaget forespørgsler SQL direkte, hvis vi ændrer forbindelsen til sqlite for en til MySQL for eksempel vil vores applikation fortsætte med at fungere som normalt.
Med dette har vi afsluttet denne vejledning, vi ved allerede, hvordan vi opretter modeller i KolbeDerudover har vi lært at manipulere på en grundlæggende, men meget nyttig måde ORM SQLAlchemy, hvor disse komponenter er meget vigtige, når vi bygger meget større applikationer, da de giver os mulighed for at opnå mere komplekse resultater med mindre arbejde.