Utwórz model danych w Flask

Nasze aplikacje to znacznie więcej niż proste strony, dlatego musimy stworzyć sposoby przechowywania danych w jakimś systemie utrwalania, tu właśnie Bazy danych Stawką jest to, że aby ustalić, w jaki sposób Baza danych ma nam pomóc, trzeba stworzyć modele.
Model daje nam strukturę, w której będzie działać największa logika naszej aplikacji, to tutaj nadajemy znaczenie różnym bytom, z którymi musimy mieć, aby wykonywać nasze działania.
Kolba masz możliwość korzystania z różnych rodzajów Bazy danych tylko używając ORM SQLAlchemia.
WymaganiaPotrzebujemy funkcjonalnej instalacji Kolba, oraz odpowiednie uprawnienia, aby móc zainstalować więcej komponentów za pośrednictwem pypeć. Jeśli mamy możliwość współpracy Wirtualne środowisko jest to znacznie bardziej zalecane, ale nie jest konieczne. Jeśli chcemy ekstrapolować przykłady z samouczka, będziemy potrzebować trochę Baza danych Co MySQL na wypadek, gdybyśmy chcieli przenieść funkcjonalność do znacznie bardziej rzeczywistego środowiska, ponieważ w ćwiczeniach będziemy pracować sqlite jako środek upraszczający i bardziej praktyczny.
Pierwszą rzeczą, którą zrobimy, jest instalacja SQLAlchemia, ten krok jest bardzo prosty, musimy tylko wykonać następujące polecenie w konsoli włączonej do uruchomienia pypeć:

 pip install flask-sqlalchemy

Na koniec dostaniemy komunikat o sukcesie, jeśli wszystko poszło poprawnie:

Załóżmy teraz SQLAlchemia do pracy, w tym celu stworzymy małą aplikację, w której zobaczymy, jak możemy nawiązać połączenie z silnikiem bazy danych. W takim przypadku nasza aplikacja będzie nazywać się kolba a w nim musimy mieć następującą strukturę.
1- plik o nazwie run.py który będzie w katalogu głównym aplikacji, ten plik jest tym, który wykonuje podstawową inicjalizację całego naszego środowiska.
2- Folder o nazwie kolba a wewnątrz tego pliku o nazwie __init__.py, w którym zainicjujemy użycie kolba i SQLAlchemia bezpośrednio.
Zobaczmy na poniższym obrazku jak ta struktura wygląda w projekcie:

Gdy już wiemy, co powinniśmy mieć, będziemy mieli zawartość naszych początkowych plików. W pliku run.py musimy mieć:

 z flasko import appapp.run (debug = True)

Następnie w naszym pliku __init__.py umieścimy ten kod:

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

Ten ostatni kod jest bardzo łatwy do wyjaśnienia, po prostu importujemy Kolba, następnie importujemy SQLAlchemia, nawiązujemy naszą aplikację do pracy z frameworkiem, a następnie nawiązujemy połączenie z naszym Baza danych w tym przypadku sqlite, gdzie będzie się nazywać flaskdb.db i będzie w tym samym katalogu co nasza aplikacja. Na koniec przypisujemy obiekt SQLAlchemia do zmiennej o nazwie db z którymi będziemy pracować później.
Jeśli teraz uruchomimy naszą aplikację, powinna uruchomić się bez błędów, jedyne, że nie będziemy mieli wyniku, ponieważ aplikacja jest nadal pusta.
Ponieważ mamy podstawową konfigurację naszej aplikacji, musimy teraz położyć podwaliny pod stworzenie naszego modelu, w tym celu będziemy musieli utworzyć folder w naszym folderze zawierającym plik __init__.py i tam wygenerujemy niezbędną treść.
Zobaczmy, jak zmienia się nasza struktura folderów:

Jak widzimy w naszym nowym folderze produktu, wygenerowaliśmy 3 pliki, plik __init__.py który musi być pusty, plik modele.py i inne widoki.py. Dzięki tej strukturze zamierzamy zmodyfikować nasz __init__.py z katalogu głównego naszej aplikacji, gdzie ważne jest, aby nie pomylić z __init__.py produktów.

 from flask import Flaskfrom flask.ext.sqlalchemy import SQLAlchemyapp = Flask (__ nazwa __) app.config ['SQLALCHEMY_DATABASE_URI'] = 'sqlite: ///flaskodb.db'db = SQLAlchemy (aplikacja) z importu flasko.product.registr_blueprint (produkt) db.create_all ()

To, co zrobiliśmy, to to, że po stworzeniu obiektu db zaimportowaliśmy widoki z naszego nowego folderu i zarejestrowaliśmy a projekt, na koniec mówimy obiektowi db, że musi utworzyć wszystkie potrzebne tabele. Teraz musimy zmodyfikować nasz plik modele.py wewnątrz produktu, a my umieścimy następujący kod:

 from flasko import dbclass Produkt (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 = nazwa self.price = cena __repr __ (self): return ''% self.id

Tutaj zasadniczo to, co robimy, to zdefiniuj klasę który będzie niósł jako atrybuty pola, których będziemy wymagać od naszego produktu, również w nim jest kilka metod definicji i reprezentacji naszego modelu.
Po wykonaniu powyższych czynności przechodzimy do pliku widoki.py, w tym musimy stworzyć kod, który pozwoli nam na interakcję z naszym modelem, w tym celu musimy napisać:

 from flask import request, jsonify, Blueprintfrom flasko import app, dbfrom flasko.product.models import Productproduct = Blueprint ('produkt', __nazwa __) @ 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 'Produkt -% s, $% s'% ( product .name, product.price) @ app.route ('/ products') def products (): products = Product.query.all () res = {} dla produktu w produktach: 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 ('name') price = request.form.get ('price') product = Product (nazwa, cena) db.session.add (product) db.session.commit () return 'Produkt został pomyślnie utworzony '

Pierwszą rzeczą, jaką zauważamy, jest to, że mamy w tym pliku znacznie więcej treści niż w pozostałej części naszej aplikacji, a to dlatego, że to tam toczy się całe życie naszego widoku, pierwsza trasa jest początkiem naszej aplikacji i nie wiązać się z jakąkolwiek większą tajemnicą.
Druga i trzecia droga służą do konsultacji, gdzie możemy wyszukiwać według identyfikatora produktu, a jeśli nie ma nic do zwrócenia strony 404, mamy również funkcję wyświetlania wszystkich produktów dostępnych w naszym Baza danych.
Ostatnia trasa to ta, która pozwala nam przejść przez tę metodę POCZTA tworzenie produktu i jego późniejsze przechowywanie w Baza danych, w tym celu tworzymy nasz model produktu, w którym następnie przekazujemy wspomniany atrybut do obiektu db i jego metodami Dodaj Tak popełniać dodajemy to do Baza danych.
Teraz do przetestowania naszej aplikacji pozostaje dodanie treści, która trafi do naszej bazy danych, jeśli pamiętamy w pliku widoki.py tworzymy widok, który otrzymuje dane za pomocą metody POCZTA i to on jest odpowiedzialny za tworzenie wstawek. Do dodawania elementów użyjemy modułu Pyton zwany upraszanie który pozwala nam na przesyłanie danych przez POST, jeśli nie mamy ich do dyspozycji, wystarczy je zainstalować za pomocą następującego polecenia:

 prośby o instalację pip

W konsoli dodatkowej uruchomimy naszą aplikację kolba aby serwer działał i aby móc wysyłać żądania z Pyton. W naszej interaktywnej konsoli Pyton do którego uzyskujemy dostęp pisząc słowo pyton, musimy wykonać następujące czynności:

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

To, co zrobiliśmy, to wysłanie prośby przez POCZTA do naszej trasy, która dodaje elementy do Bazy danych, parametry są przekazywane w słowniku Pyton który jest bardzo podobny do przedmiotu JSON.
Powinno to dać nam kod 200, który oznacza, że ​​nasza prośba się powiodła, możemy to zobaczyć na poniższym obrazku:

Jeśli teraz przejdziemy do naszej aplikacji w widoku produktów, zobaczymy, jak uzyskujemy to, co właśnie wprowadziliśmy za pomocą konsoli:

Widzimy, że mamy listę w formacie JSON z naszym produktem, który właśnie dodaliśmy, jeśli teraz szukamy trasy produkt / 1 zobaczymy, że też to dostaniemy:

Oczywiście nie jest to coś godnego wprowadzenia do produkcji, ale pomaga nam poznać podstawy modeli i trwałości danych w Kolba, najciekawsze jest to, że skoro nie złożyliśmy zapytań SQL bezpośrednio, jeśli zmienimy połączenie na sqlite dla jednego do MySQL na przykład nasza aplikacja będzie działać normalnie.
Na tym zakończyliśmy ten samouczek, wiemy już, jak tworzyć modele w KolbaPonadto nauczyliśmy się manipulować w prosty, ale bardzo użyteczny sposób ORM SQLAlchemia, gdzie te komponenty są bardzo ważne, gdy budujemy znacznie większe aplikacje, ponieważ pozwolą nam osiągnąć bardziej złożone wyniki przy mniejszym nakładzie pracy.