Lag datamodell i Flask

Våre applikasjoner er mye mer enn enkle sider, det er derfor vi må lage måter å lagre dataene på i et eller annet utholdenhetssystem, det er her Databaser på spill hvor for å fastslå måten databasen skal hjelpe oss på er at modellene må lages.
En modell gir oss strukturen som den største logikken i applikasjonen vår vil fungere under. Det er her vi gir en mening til de forskjellige enhetene vi må ha for å utøve handlingene våre.
Kolbe du har muligheten til å bruke forskjellige typer Databaser bruker bare ORM SQLAlchemy.
KravVi trenger en funksjonell installasjon av Kolbe, og de respektive tillatelsene for å kunne installere flere komponenter gjennom pip. Hvis vi har muligheten til å jobbe med Virtualenv det er mye mer anbefalt, men det er ikke nødvendig. Hvis vi ønsker å ekstrapolere opplæringseksemplene, trenger vi noen Database Hva MySQL i tilfelle vi ønsker å bringe funksjonaliteten til et mye mer reelt miljø, siden vi vil jobbe med øvelsene sqlite som et forenklingstiltak og for å være mer praktisk.
Det første vi skal gjøre er å installere SQLAlchemy, dette trinnet er veldig enkelt, vi trenger bare å utføre følgende kommando i konsollen som er aktivert for å kjøre pip:

 pip installere flask-sqlalchemy

På slutten vil vi få en suksessmelding hvis alt har gått riktig:

La oss nå sette SQLAlchemy for å fungere, for dette skal vi lage en liten applikasjon der vi skal se hvordan vi kan etablere en forbindelse med en databasemotor. I dette tilfellet vil søknaden vår bli kalt flasko og innenfor den må vi ha følgende struktur.
1- En fil som heter run.py som vil være i roten til applikasjonen, er denne filen den som gjør den grunnleggende initialiseringen av hele miljøet vårt.
2- En mappe som heter flasko og inne i denne en fil som heter __init__.py som er hvor vi vil initialisere bruken av kolbe og av SQLAlchemy direkte.
La oss se på følgende bilde hvordan denne strukturen ser ut i et prosjekt:

Når vi vet hva vi skal ha, vil vi ha innholdet for de første filene våre. I filen run.py vi må ha følgende:

 fra flasko import appapp.run (debug = True)

Så i vår __init__.py -fil skal vi plassere denne koden:

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

Denne siste koden er veldig lett å forklare, vi importerer bare Kolbe, så importerer vi SQLAlchemy, vi etablerer appen vår for å jobbe med rammeverket, og deretter etablerer vi forbindelsen med vår Database i dette tilfellet sqlite, hvor det vil bli kalt flaskdb.db og den vil være i samme katalog som applikasjonen vår. Til slutt tildeler vi objektet SQLAlchemy til en variabel som heter db som vi vil jobbe med senere.
Hvis vi starter applikasjonen vår nå, bør den starte uten feil, det eneste er at vi ikke får et resultat fordi applikasjonen fortsatt er tom.
Siden vi har den grunnleggende konfigurasjonen av applikasjonen vår nå må vi legge grunnlaget for å lage vår modell, for dette må vi lage en mappe i mappen vår som inneholder filen __init__.py og det er der vi vil generere nødvendig innhold.
La oss se hvordan mappestrukturen vår endres:

Som vi kan se inne i den nye produktmappen, har vi generert 3 filer, en fil __init__.py som må være tom, en fil models.py og annen views.py. Med denne strukturen kommer vi til å endre __init__.py fra roten av applikasjonen vår, der det er viktig å ikke forveksle med __init__.py av produkter.

 fra kolbeimport Flaskfrå 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 at etter opprettelsen av objektet db vi har importert visningene fra vår nye mappe og registrert a blåkopi, til slutt forteller vi db -objektet at det må lage alle nødvendige tabeller. Nå må vi endre filen vår models.py inne i produktet, og vi vil plassere følgende kode:

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

Her er det vi i utgangspunktet gjør definere en klasse som vil bære feltene som vi vil kreve fra produktet vårt som attributter, er det også et par metoder for definisjonen og representasjonen av modellen vår.
Når ovennevnte er oppnådd, går vi til filen views.py, i dette må vi lage koden som lar oss samhandle med modellen vår for dette må vi skrive følgende:

 fra kolbeimportforespørsel, jsonify, Blueprintfrå flaskoimportapp, dbfrom flasko.product.models import Productproduct = Blueprint ('produkt', __name __) @ 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'% ( product .name, product.price) @ app.route ('/ products') def products (): 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 ble opprettet

Det første vi legger merke til er at vi har mye mer innhold i denne filen enn i resten av applikasjonen vår, og det er fordi det er her hele livet i vårt syn foregår, den første ruten er begynnelsen på applikasjonen vår og gjør det ikke innebære noe større mysterium.
Den andre og tredje ruten er til konsultasjon, hvor vi kan søke etter produkt -ID, og ​​hvis det ikke er noe å returnere en 404 -side, har vi også funksjonaliteten til å liste alle produktene som er tilgjengelige i vår Database.
Den siste ruten er den som tillater oss gjennom metoden POST opprettelsen av et produkt og dets påfølgende lagring i Database, for dette instantiserer vi vår produktmodell, hvor vi deretter sender attributtet til objektet db og med metodene hans Legg til Y begå vi legger det til Database.
Det som gjenstår for å teste søknaden vår er å legge til innholdet som vil komme i databasen vår, hvis vi husker det i filen views.py vi lager en visning som mottar data gjennom metoden POST og det er den som har ansvaret for å gjøre innsettingene i den. For å legge til elementer skal vi bruke en modul Python kalt forespørsler som lar oss sende data via POST, hvis vi ikke har dem tilgjengelig, må vi bare installere dem med følgende kommando:

 pip installasjonsforespørsler

I en sekundærkonsoll skal vi starte applikasjonen vår flasko slik at serveren er oppe og kan sende forespørslene fra Python. I vår interaktive konsoll Python som vi får tilgang til ved å skrive ordet python, må vi gjøre følgende:

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

Det vi gjorde var å sende en forespørsel via POST til ruten vår som legger elementene til databasen, blir parametrene sendt i en ordbok Python som er veldig lik et objekt JSON.
Dette bør gi oss en kode 200 som betyr at vi effektivt har lykkes i forespørselen vår, vi kan se dette i følgende bilde:

Hvis vi nå navigerer til applikasjonen vår i produktvisningen, vil vi se hvordan vi får tak i det vi nettopp har lagt inn gjennom konsollen:

Vi ser at vi har en liste i format JSON med produktet vårt som vi nettopp har lagt til, hvis vi nå søker på ruten produkt / 1 vi vil se at vi også får det:

Selvfølgelig er dette langt fra noe som er verdig å bli satt i produksjon, men det hjelper oss å lære det grunnleggende om modeller og datastyrke i Kolbe, det mest interessante er at siden vi ikke har spurt SQL direkte, hvis vi endrer tilkoblingen til sqlite for en til MySQL for eksempel vil søknaden vår fortsette å fungere som vanlig.
Med dette har vi fullført denne opplæringen, vi vet allerede hvordan vi lager modeller i KolbeI tillegg har vi lært å manipulere på en grunnleggende, men veldig nyttig måte ORM SQLAlchemy, der disse komponentene er svært viktige når vi bygger mye større applikasjoner, da de vil tillate oss å oppnå mer komplekse resultater med mindre arbeid.