Créer un modèle de données dans Flask

Nos applications sont bien plus que de simples pages, c'est pourquoi nous devons créer des moyens de stocker les données dans un système de persistance, c'est là que le Base de données l'enjeu où pour établir la manière dont la base de données va nous aider est que les modèles doivent être créés.
Un modèle nous donne la structure sous laquelle va opérer la plus grande logique de notre application, c'est là que nous donnons un sens aux différentes entités avec lesquelles nous devons avoir pour exercer nos actions.
Ballon vous avez la possibilité d'utiliser différents types de Base de données en utilisant uniquement le ORM SQLAlchemy.
ExigencesNous avons besoin d'une installation fonctionnelle de Ballon, et les autorisations respectives pour pouvoir installer plus de composants via pépin. Si nous avons la possibilité de travailler avec Environnement virtuel c'est beaucoup plus recommandé, mais ce n'est pas nécessaire. Si nous voulons extrapoler les exemples du didacticiel, nous aurons besoin de quelques Base de données Quoi MySQL au cas où nous voudrions apporter la fonctionnalité à un environnement beaucoup plus réel, car dans les exercices nous travaillerons avec sqlite comme mesure de simplification et pour être plus pratique.
La première chose que nous allons faire est d'installer SQLAlchimie, cette étape est très simple, il suffit d'exécuter la commande suivante dans la console activée pour s'exécuter pépin:

 pip installer flacon-sqlalchemy

À la fin, nous obtiendrons un message de réussite si tout s'est bien passé :

Mettons maintenant SQLAlchimie pour fonctionner, pour cela nous allons créer une petite application où nous verrons comment nous pouvons établir une connexion avec un moteur de base de données. Dans ce cas, notre application s'appellera flacon et en son sein, nous devons avoir la structure suivante.
1- Un fichier nommé run.py qui sera à la racine de l'application, ce fichier est celui qui fait l'initialisation de base de tout notre environnement.
2- Un dossier nommé flacon et à l'intérieur de celui-ci un fichier appelé __init__.py qui est l'endroit où nous allons initialiser l'utilisation de ballon et de SQLAlchimie directement.
Voyons dans l'image suivante à quoi ressemble cette structure dans un projet :

Une fois que nous saurons ce que nous devrions avoir, nous aurons le contenu de nos fichiers initiaux. Dans le fichier run.py nous devons avoir les éléments suivants :

 depuis flasko import appapp.run (debug = True)

Ensuite dans notre fichier __init__.py nous allons placer ce code :

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

Ce dernier code est très simple à expliquer, on importe juste Ballon, puis nous importons SQLAlchimie, nous établissons notre application pour qu'elle fonctionne avec le framework, puis nous établissons la connexion avec notre Base de données dans ce cas sqlite, où il s'appellera flaskdb.db et il sera dans le même répertoire que notre application. Enfin, nous attribuons l'objet SQLAlchimie à une variable appelée db avec lequel nous travaillerons plus tard.
Si nous démarrons notre application maintenant, elle devrait démarrer sans erreur, la seule chose est que nous n'aurons pas de résultat car l'application est toujours vide.
Puisque nous avons la configuration de base de notre application, nous devons maintenant jeter les bases pour créer notre modèle, pour cela nous devrons créer un dossier dans notre dossier qui contient le fichier __init__.py et c'est là que nous allons générer le contenu nécessaire.
Voyons comment notre structure de dossiers est modifiée :

Comme nous pouvons le voir dans notre nouveau dossier de produits, nous avons généré 3 fichiers, un fichier __init__.py qui doit être vide, un fichier modèles.py et autre vues.py. Avec cette structure nous allons modifier notre __init__.py depuis la racine de notre application, où il est important de ne pas confondre avec le __init__.py des produits.

 from flask import Flaskfrom flask.ext.sqlalchemy import SQLAlchemyapp = Flask (__ nom __) app.config ['SQLALCHEMY_DATABASE_URI'] = 'sqlite: ///flaskodb.db'db = SQLAlchemy (app) from import flasko.product. register_blueprint (produit) db.create_all ()

Ce que nous avons fait, c'est qu'après la création de l'objet db nous avons importé les vues de notre nouveau dossier et enregistré un plan, enfin nous disons à l'objet db qu'il doit créer toutes les tables nécessaires. Maintenant, nous devons modifier notre fichier modèles.py à l'intérieur du produit, et nous placerons le code suivant :

 de flasko import dbclass Product (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

Ici, en gros, ce que nous faisons est définir une classe qui portera comme attributs les champs que nous aurons besoin de notre produit, il contient également quelques méthodes pour la définition et la représentation de notre modèle.
Une fois ce qui précède accompli, on passe au fichier vues.py, en cela, nous devons créer le code qui nous permet d'interagir avec notre modèle pour cela, nous devons écrire ce qui suit :

 from flask import request, jsonify, Blueprintfrom flasko import app, dbfrom flasko.product.models import Productproduct = Blueprint ('product', __name __) @ 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 'Product -% s, $% s'% ( product .name, product.price) @ app.route ('/ products') def products (): products = Product.query.all () res = {} pour le produit dans products: res [product.id] = {' name ': product.name,' price ': str (product.price)} return jsonify(res)@app.route (' / create-product ', methodes = [' POST ',]) def create_product (): nom = request.form.get ('nom') prix = request.form.get ('prix') produit = Produit (nom, prix) db.session.add (produit) db.session.commit () return 'Le produit a été créé avec succès '

La première chose que nous remarquons est que nous avons beaucoup plus de contenu dans ce fichier que dans le reste de notre application et c'est parce que c'est là que se déroule toute la vie de notre vue, la première route est le début de notre application et ne impliquent un plus grand mystère.
Les deuxième et troisième itinéraires sont à consulter, où nous pouvons rechercher par identifiant de produit et au cas où il n'y aurait rien pour renvoyer une page 404, nous avons également la fonctionnalité de répertorier tous les produits disponibles dans notre Base de données.
Le dernier itinéraire est celui qui nous permet à travers la méthode PUBLIER la création d'un produit et son stockage ultérieur dans Base de données, pour cela nous instancions notre modèle Product, où nous passons ensuite cet attribut à l'objet db et avec ses méthodes ajouter Oui s'engager nous l'ajoutons à Base de données.
Maintenant ce qui reste à tester notre application c'est d'ajouter le contenu qui ira dans notre Database, si on se souvient dans le fichier vues.py nous créons une vue qui reçoit des données via la méthode PUBLIER et c'est lui qui se charge d'y faire les insertions. Pour ajouter des éléments, nous allons utiliser un module Python appelé demandes qui nous permet d'envoyer des données via POST, si nous ne l'avons pas disponible nous devons simplement l'installer avec la commande suivante :

 demandes d'installation de pip

Dans une console secondaire nous allons lancer notre application flacon pour que le serveur soit opérationnel et pour pouvoir envoyer les requêtes de Python. Dans notre console interactive Python auquel on accède en écrivant le mot python, nous devons procéder comme suit :

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

Ce que nous avons fait, c'est envoyer une demande via PUBLIER à notre route qui ajoute les éléments à la base de données, les paramètres sont passés dans un dictionnaire Python qui ressemble beaucoup à un objet JSON.
Cela devrait nous donner un code 200 qui signifie que nous avons effectivement réussi notre requête, nous pouvons le voir dans l'image suivante :

Si nous naviguons maintenant vers notre application dans la vue des produits, nous verrons comment nous obtenons ce que nous venons de saisir via la console :

Nous voyons que nous avons une liste au format JSON avec notre produit que nous venons d'ajouter, si nous faisons maintenant une recherche sur l'itinéraire produit / 1 nous verrons que nous l'obtiendrons également :

Bien sûr, c'est loin d'être quelque chose qui mérite d'être mis en production, mais cela nous aide à apprendre les bases des modèles et de la persistance des données au sein de Ballon, le plus intéressant est que puisque nous n'avons pas fait d'enquête SQL direct, si nous modifions la connexion en sqlite pour un à MySQL par exemple, notre application continuera à fonctionner comme d'habitude.
Avec cela, nous avons terminé ce tutoriel, nous savons déjà comment créer des modèles dans BallonDe plus, nous avons appris à manipuler de manière basique mais très utile les ORM SQLAlchimie, où ces composants sont très importants lorsque nous construisons des applications beaucoup plus volumineuses car ils nous permettront d'obtenir des résultats plus complexes avec moins de travail.