Utilisation de modèles dans Flask

Une application web nécessite une partie que l'utilisateur peut voir qui s'appelle vue ou view et se compose d'une interface écrite en HTML qui nous permet d'afficher des données statiques et dynamiques selon le chemin auquel l'utilisateur accède.
Lorsque nous travaillons avec des microframeworks comme Ballon, par défaut il n'est pas nécessaire d'afficher la vue pour utiliser des éléments supplémentaires, ne renvoyant que le code HTML correspondant que nous pouvons atteindre pour afficher des données cohérentes.
Le problème survient lorsque notre application commence à grandir et que nous avons plusieurs vues, la répétition du code remplit notre application d'éléments que nous pourrions réutiliser et que le faire manuellement représente un travail plus important pour nous. Pour éviter ce problème, nous avons le moteurs de modèles, qui nous aident à réutiliser les fichiers HTML et ainsi réduire la quantité de code en plus d'augmenter la lisibilité de notre programme.
Jinja2 est un moteur de template entièrement écrit en Python et a été calqué sur le moteur de modèle de Django, cela nous permet de placer des portions de code HTML et avec le propre code du moteur, incluez des étiquettes qui seront plus tard remplacées par les données de notre application.
Que comprend-il d'autre ?Il comprend également ses propres fonctions qui nous aident à formater les données que nous recevons, en plus de gérer les conditions, les fonctions de date et d'autres éléments qui nous aident à programmer le comportement du modèle de manière simple et expressive.
Dans la dernière version de Ballon Ce moteur est inclus dans l'installation donc son utilisation est plus facile et plus rapide.
Nous avions discuté de la création d'une vue dans Ballon c'était aussi simple que d'imprimer le code HTML dans la fonction de chemin souhaitée, mais pour ceux qui découvrent ce cadre, cela peut sembler très déroutant.
Dans l'exemple suivant nous allons créer une vue où nous allons recevoir un paramètre et l'imprimer dans le résultat, la chose intéressante est que ce paramètre peut être saisi par l'utilisateur, donc la vue est dynamique jusqu'à un certain point, voyons le code puis on passera à l'explication :

 from flask import Flaskapp = Flask (__ nom __) @ app.route ('/') @ app.route ('/ welcome') @ app.route ('/ welcome /') def welcome (name = None): nom = nom ou 'Utilisateur' return '' 'Bienvenue !
C'est notre point de vue made in Flask !

'' '% ifname __name__ ==' __main__ ': app.run ()

Ici, ce que nous faisons est quelque chose de très simple, d'abord nous importons les bibliothèques qui contiennent les cadre, puis nous définissons trois routes clés, toutes nous conduisent à la même fonction appelée bienvenue et reçoivent un paramètre facultatif où s'il n'est pas reçu, il sera simplement ignoré dans le programme.
Ensuite, dans la fonction, nous créons notre instruction revenir et ici nous indiquons qu'un Chaîne de caractères contenant le HTML pour la vue. Si nous testons ce programme nous obtiendrons un résultat acceptable dans le navigateur, voyons :

Beaucoup peuvent dire que c'est très fonctionnel, mais que se passe-t-il si au lieu d'afficher cette page blanche, nous voulons intégrer des styles CSS, des effets JavaScript ou d'autres choses. Ensuite, notre code HTML prendrait plus de code et donc tout serait trop compliqué, rendant notre application un enfer à gérer.
Maintenant, nous allons créer la même vue mais en utilisant le moteur de modèle que nous avons décrit au début du didacticiel, pour réaliser l'exemple, nous devons faire quelques préparations, celles-ci ont à voir avec la structure de notre projet, car si nous sommes Pour utiliser des fichiers modèles, il est préférable de les séparer de l'application dans d'autres dossiers et de séparer ainsi notre couche visuelle des règles métier et de la couche logique.
Sachant cela alors nous devons créer un dossier pour nos modèles, à des fins de convention nous l'appellerons modèles, cependant nous devons également avoir d'autres choses, par exemple nous devons avoir un dossier qui servira de module et nous l'appellerons avec le nom de la vue que nous allons créer, En plus de cela, nous devons avoir des fichiers, dans l'image suivante, nous verrons la structure complète, puis nous irons au code correspondant pour que tout fonctionne.

Contenu du fichierAvant de passer à la génération et à l'utilisation du template, il faut voir le contenu des fichiers qui permettront à notre application de fonctionner sans problème, nous verrons brièvement chaque fichier pour ne pas perdre beaucoup de temps. Il est important de noter qu'il s'agit d'une structure suggérée, cependant Ballon permet à chaque développeur de réaliser la structure qui lui convient le mieux en fonction de son objectif.
Ce fichier est celui qui nous permet de lancer l'application, d'où son nom, il peut généralement être appelé run.py Aussi, mais pour les besoins de ce tutoriel nous mettons un nom qui soit plus compréhensible par la communauté hispanophone, ici nous devons placer le code suivant :

 depuis flasko import appapp.run (debug = True)

C'est le fichier qui est à la racine de l'application, il faut pouvoir établir qu'il va être exécuté et ses dépendances, dans ce fichier c'est là que l'on définit aussi que le fichier va être utilisé vues.py du dossier de bienvenue que nous avons vu auparavant, cela peut avoir n'importe quel nom mais vues.py C'est une convention qui nous aidera à maintenir une application conviviale, nous devons placer ici les éléments suivants :

 à partir du flacon importer Flaskapp = Flask (__ nom __) importer flasko.bienvenido.views

Ce fichier doit être vide puisque nous n'avons besoin qu'il existe pour que Ballon interpréter que ce dossier est un module de notre application.
Puisque nous avons les fichiers de base pour notre application, il est temps de créer la vue et d'utiliser le modèle. La première chose que nous allons faire est de créer notre vue, celle-ci sera très similaire à la vue précédente mais améliorée, pour cela nous devons travailler dans le fichier vues.py et placez les éléments suivants :

 from flask import render_template, requestfrom flasko import [email protected] ('/') @ app.route ('/ welcome') def welcome_web (): name = request.args.get ('name', 'User') return render_template ('index.html', nom = nom)

La première chose que nous faisons est à partir du framework d'importer la bibliothèque qui nous permet d'afficher les modèles et une bibliothèque pour traiter les requêtes du navigateur.
Ensuite on définit les routes qui vont faire apparaître cette vue, dans ce cas c'est la racine / et aussi quand le mot est placé Bienvenue.
Enfin, nous définissons notre fonction Bienvenue qui affecte à la variable name les paramètres obtenus à partir de la requête navigateur puis on fait un retour de la fonction render_template, c'est celui-ci qui appellera le modèle et passera le nom de la variable en paramètre, où l'on indiquera également le nom du modèle.
Il est temps de créer le modèle, il s'agit essentiellement d'un fichier avec du contenu HTML et avec quelques balises qui vont nous aider à lui donner du dynamisme, le fichier à modifier est le index.html qui est dans le dossier modèles, voyons le code que nous utiliserons :

 Bienvenue {{nom}}
Nous utilisons Flask !

Ce code est simple, nous faisons notre HTML basic puis là où nous voulons que le contenu généré apparaisse dans la vue, nous plaçons simplement des accolades doubles {{}} et à l'intérieur, le nom du paramètre, cela signifie que lorsque l'application est exécutée, cette valeur est remplacée par le contenu que nous voulons. Si nous voyons dans l'image suivante, nous réaliserons comment est placé le nom que nous passons en paramètre via l'URL :

Non seulement pouvons-nous utiliser des paramètres, nous pouvons également créer des dictionnaires Python avec des données provenant d'une source de persistance comme un Base de données ou quelque chose de similaire et ainsi pouvoir placer encore plus de données.
Différents modèlesLa chose intéressante à propos de cette question est que nous pouvons jouer avec différents modèles pour différentes parties de notre application, cela sépare la couche de présentation pure de ce que nous programmons réellement, en supprimant le HTML à partir du milieu, nous pouvons nous séparer en deux équipes et ainsi travailler correctement sans confusion.
Avec cela, nous terminons ce tutoriel, nous avons appris à utiliser les modèles dans les applications faites avec Ballon, cette façon de travailler nous évitera des efforts et des répétitions de code, surtout si nous nous appuyons sur la documentation officielle de Jinja2 pour tirer le meilleur parti du moteur de modèles. Il est très important d'établir une structure de projet et de séparer les différents types de fichiers, car de cette manière, nous maintiendrons un projet convivial pour le reste de notre équipe de développement ou dans le cas où nous souhaitons le télécharger sur un réseau de code tel que GitHub pour partager le travail effectué avec la communauté.