Izveidojiet datu modeli kolbā

Mūsu lietojumprogrammas ir daudz vairāk nekā vienkāršas lapas, tāpēc mums ir jāizveido veidi, kā saglabāt datus kādā noturības sistēmā. Datu bāzes runa ir par to, ka, lai noteiktu veidu, kādā Datubāze mums palīdzēs, ir jāizveido modeļi.
Modelis dod mums struktūru, saskaņā ar kuru darbosies mūsu lietojumprogrammas lielākā loģika, un šeit mēs piešķiram nozīmi dažādām vienībām, ar kurām mums jābūt, lai mēs varētu veikt savas darbības.
Kolba jums ir iespēja izmantot dažādus veidus Datu bāzes tikai izmantojot ORM SQLAlchemy.
PrasībasMums ir nepieciešama funkcionāla instalācija Kolba, un attiecīgās atļaujas, lai varētu instalēt vairāk komponentu pip. Ja mums ir iespēja sadarboties Virtualenv tas ir daudz vairāk ieteicams, tomēr tas nav nepieciešams. Ja mēs vēlamies ekstrapolēt apmācības piemērus, mums būs nepieciešami daži Datu bāze Kas MySQL ja mēs vēlamies funkcionalitāti ieviest daudz reālākā vidē, jo vingrinājumos mēs strādāsim sqlite kā vienkāršošanas pasākums un praktiskāk.
Pirmā lieta, ko mēs darīsim, ir instalēt SQLAlchemy, šis solis ir ļoti vienkāršs, mums ir tikai jāizpilda šāda komanda konsolē, kurā iespējota palaišana pip:

 pip instalēt kolbu-sqlalchemy

Beigās mēs saņemsim ziņojumu par panākumiem, ja viss ir noticis pareizi:

Tagad liekam SQLAlchemy lai strādātu, šim nolūkam mēs izveidosim nelielu lietojumprogrammu, kurā redzēsim, kā mēs varam izveidot savienojumu ar datu bāzes dzinēju. Šajā gadījumā tiks izsaukta mūsu lietojumprogramma flako un tajā mums ir jābūt šādai struktūrai.
1- Fails ar nosaukumu palaist.py kas būs lietojumprogrammas saknē, šis fails ir tas, kas veic visas mūsu vides pamata inicializāciju.
2- mape ar nosaukumu flako un šajā failā ar nosaukumu __init__.py, kur mēs inicializēsim tā izmantošanu kolba un no SQLAlchemy tieši.
Tālāk redzamajā attēlā redzēsim, kā šī struktūra izskatās projektā:

Tiklīdz mēs zinām, kas mums būtu vajadzīgs, mums būs sākotnējo failu saturs. Failā palaist.py mums jābūt šādam:

 no flasko importēšanas appapp.run (atkļūdošana = True)

Tad mūsu __init__.py failā mēs ievietosim šo kodu:

 no kolbas importēšanas Kolba no kolbas.ext.sqlalchemy imports SQLAlchemyapp = Kolba (__ name __) app.config ['SQLALCHEMY_DATABASE_URI'] = 'sqlite: //flaskodb.db'db = SQLAlchemy (lietotne)

Šo pēdējo kodu ir ļoti viegli izskaidrot, mēs vienkārši importējam Kolba, tad mēs importējam SQLAlchemy, mēs izveidojam savu lietotni darbam ar ietvaru un pēc tam izveidojam savienojumu ar mūsu Datu bāze šajā gadījumā sqlite, kur tas tiks saukts flaskdb.db un tas atradīsies tajā pašā direktorijā kā mūsu lietojumprogramma. Visbeidzot, mēs piešķiram objektu SQLAlchemy uz mainīgo, ko sauc db ar kuru mēs strādāsim vēlāk.
Ja mēs sākam savu lietojumprogrammu tūlīt, tai vajadzētu sākt bez kļūdām, vienīgais, ka mums nebūs rezultāta, jo lietojumprogramma joprojām ir tukša.
Tā kā mums ir mūsu lietojumprogrammas pamatkonfigurācija, mums ir jāizveido pamati, lai izveidotu savu modeli, tāpēc mums savā mapē būs jāizveido mape, kurā ir fails __init__.py un tieši šeit mēs radīsim nepieciešamo saturu.
Apskatīsim, kā tiek mainīta mūsu mapju struktūra:

Kā redzam mūsu jauno produktu mapē, mēs esam izveidojuši 3 failus, failu __init__.py kam jābūt tukšam, fails modeļi.py un cits views.py. Izmantojot šo struktūru, mēs pārveidosim savu __init__.py no mūsu lietojumprogrammas saknes, kur ir svarīgi nejaukt ar produktu __init__.py.

 no kolbas importēšanas Flaskfrom flask.ext.sqlalchemy import SQLAlchemyapp = Kolba (__ name __) app.config ['SQLALCHEMY_DATABASE_URI'] = 'sqlite: ///flaskodb.db'db = SQLAlchemy (lietotne) no importa flasko.product. (produkts) db.create_all ()

Tas, ko mēs esam izdarījuši, ir tas, ka pēc objekta izveidošanas db mēs esam importējuši skatus no mūsu jaunās mapes un reģistrējuši plāns, visbeidzot mēs sakām db objektam, ka tam ir jāizveido visas nepieciešamās tabulas. Tagad mums ir jāmaina mūsu fails modeļi.py produkta iekšpusē, un mēs ievietojam šādu kodu:

 no flasko importa dbclass Produkts (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

Šeit būtībā ir tas, ko mēs darām definēt klasi kas kā atribūtus izmantos laukus, kurus mēs prasīsim no sava produkta, arī tajā ir dažas metodes mūsu modeļa definēšanai un attēlošanai.
Kad iepriekš minētais ir izpildīts, mēs ejam uz failu views.py, šajā mums ir jāizveido kods, kas ļauj mums mijiedarboties ar mūsu modeli, tāpēc mums ir jāraksta:

 no kolbas importēšanas pieprasījuma, jsonify, Blueprint no flasko importēšanas lietotnes, dbfrom flasko.product.models importēt Productproduct = Blueprint ('produkts', __vārds __) @ 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 'Produkts -% s, $% s'% ( product .name, product.price) @ app.route ('/ products') def products (): products = Product.query.all () res = {} produktā esošajam produktam: res [product.id] = {' name ': product.name,' price ': str (product.price)} return jsonify(res)@app.route (' / create-product ', metodes = [' POST ',]) def create_product (): nosaukums = request.form.get ('name') price = request.form.get ('price') product = Product (name, price) db.session.add (product) db.session.commit () return 'Produkts tika veiksmīgi izveidots '

Pirmā lieta, ko mēs pamanām, ir tā, ka šajā failā ir daudz vairāk satura nekā pārējā mūsu lietojumprogrammā, un tas ir tāpēc, ka šeit notiek visa mūsu skatījuma dzīve, pirmais ceļš ir mūsu lietojumprogrammas sākums, nevis ietver kādu lielāku noslēpumu.
Otrais un trešais ceļš ir paredzēts apspriešanai, kur mēs varam meklēt pēc produkta ID un, ja nav ko atgriezt 404 lapu, mums ir arī funkcionalitāte, lai uzskaitītu visus mūsu vietnē pieejamos produktus Datu bāze.
Pēdējais ceļš ir tas, kas ļauj mums izmantot šo metodi POST produkta izveide un tā turpmākā uzglabāšana Datu bāze, šim nolūkam mēs izveidojam produkta modeli, kur pēc tam nododam šo atribūtu objektam db un ar viņa metodēm pievienot Y apņemties mēs to pievienojam Datu bāze.
Tagad, lai pārbaudītu mūsu lietojumprogrammu, ir pievienot saturu, kas tiks iekļauts mūsu datu bāzē, ja atceramies failā views.py mēs izveidojam skatu, kas saņem datus, izmantojot metodi POST un tā ir atbildīga par ievietojumu izdarīšanu tajā. Lai pievienotu elementus, mēs izmantosim moduli Python sauca pieprasījumus kas ļauj mums nosūtīt datus, izmantojot POST, ja mums tas nav pieejams, mums tas vienkārši jāinstalē ar šādu komandu:

 pip instalēšanas pieprasījumi

Sekundārajā konsolē mēs sāksim savu lietojumprogrammu flako lai serveris darbotos un varētu nosūtīt pieprasījumus no Python. Mūsu interaktīvajā konsolē Python kam mēs piekļūstam, rakstot vārdu pitons, mums jādara šādi:

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

Mēs izdarījām pieprasījumu, izmantojot POST mūsu maršrutam, kas pievieno elementus datu bāzei, parametri tiek nodoti vārdnīcā Python kas ir ļoti līdzīgs objektam JSON.
Tam vajadzētu dot kodu 200, kas nozīmē, ka mēs esam veiksmīgi izpildījuši mūsu pieprasījumu, un to var redzēt šādā attēlā:

Ja tagad produktu skatā pāriesim uz savu lietojumprogrammu, mēs redzēsim, kā caur konsoli iegūstam tikko ievadīto:

Mēs redzam, ka mums ir saraksts formātā JSON ar mūsu tikko pievienoto produktu, ja tagad veicam meklēšanu maršrutā produkts / 1 mēs redzēsim, ka mēs to arī iegūsim:

Protams, tas nebūt nav kaut kas, ko būtu vērts laist ražošanā, tomēr tas palīdz mums apgūt modeļu pamatus un datu noturību Kolba, interesantākais ir tas, ka, tā kā mēs neesam veikuši pieprasījumus SQL tiešs, ja mainām savienojumu uz sqlite vienam līdz MySQL piemēram, mūsu lietojumprogramma turpinās darboties kā parasti.
Ar to mēs esam pabeiguši šo apmācību, mēs jau zinām, kā izveidot modeļus KolbaTurklāt mēs esam iemācījušies manipulēt pamata, bet ļoti noderīgā veidā ORM SQLAlchemy, kur šīs sastāvdaļas ir ļoti svarīgas, veidojot daudz lielākas lietojumprogrammas, jo tās ļaus mums sasniegt sarežģītākus rezultātus ar mazāku darbu.