[PYTHON] Introduction à Tornado (2): Introduction au développement à l'aide de modèles - Génération de pages dynamiques -
introduction
Dans cette série, nous présenterons comment développer des applications avec Tornado, un serveur Web et un framework d'applications Web qui s'exécutent sur Python. Le contenu de cette série est le suivant.
- Caractéristiques de Tornado
- Procédure de configuration de l'environnement pour l'utilisation de Tornado
- Hello, World Création d'une application
- Création d'une application liée à une base de données
- Autres techniques utiles liées à la tornade
Dans ce deuxième volet, nous présenterons la génération de pages dynamiques à l'aide de modèles.
Public cible
- Ceux qui sont intéressés par le développement d'applications Web en utilisant Python
- Ceux qui ont touché Python
- Ceux qui apprennent ou qui commencent tout juste à développer des applications Web
Environnement requis
- Python 2.6 et supérieur
- Tornado 4.2
Article associé
Exemple de code
Dernier examen
Dans Article précédent, j'ai créé le code suivant pour afficher Hello World.
app.py
import tornado.ioloop
import tornado.web
class MainHandler(tornado.web.RequestHandler):
def get(self):
self.write("Hello, world")
application = tornado.web.Application([
(r"/", MainHandler),
])
if __name__ == "__main__":
application.listen(8888)
tornado.ioloop.IOLoop.current().start()
Dans le code ci-dessus, lorsque vous effectuez une requête GET à [http: // localhost: 8888 /](http: // localhost: 8888 /), la méthode get de MainHandler renvoie la chaîne de caractères "Hello, World" et l'affiche dans le navigateur. C'était à faire. Cependant, si seules des valeurs fixes sont renvoyées et affichées comme dans le code ci-dessus, il n'est pas possible de créer une application flexible qui modifie l'affichage en fonction de l'entrée de l'utilisateur. Pour ce faire, la plupart des frameworks d'applications Web, y compris Tornado, ont la capacité de générer dynamiquement des pages par programmation. Donc, cette fois, je présenterai la fonction pour générer dynamiquement des pages dans Tornado. Les mots-clés ici sont les deux suivants.
- modèle
- Moteur de modèle
Dans ce qui suit, nous allons d'abord expliquer le modèle et le moteur de modèle, puis générer la page de manière dynamique.
Modèles et moteur de modèles
** Un modèle est un modèle **. Les modèles dans le développement d'applications Web se composent de parties qui changent et de parties qui ne le sont pas. Parmi ceux-ci, incorporez une chaîne de caractères à remplacer dans la partie changeante et incorporez les données du programme si nécessaire. À ce stade, le moteur de modèle est utilisé pour remplacer les données. ** En d'autres termes, le moteur de modèle est un mécanisme qui remplace la chaîne de caractères changeante intégrée dans le modèle et crée une nouvelle chaîne de caractères **.
Prenons un exemple simple. Voici un exemple de modèle.
example1.html
<html>
<head>
<title>{{ title }}</title>
</head>
<body>
<ul>
{% for item in items %}
<li>{{ item }}</li>
{% end %}
</ul>
</body>
</html>
Comme vous pouvez le voir ci-dessus, les modèles sont principalement en HTML. ** Les modèles Tornado sont constitués de structures de contrôle et d'expressions intégrées dans le balisage. ** Ce modèle comporte certaines parties qui changent et d'autres pas. Ce qui change, c'est la partie entourée de {{title}} et {% for%} {% end%} entourée de crochets ondulés, et ce qui ne change pas, c'est la partie de la balise HTML.
Vous pouvez créer une nouvelle chaîne en transmettant des données au moteur de modèle pour remplacer le modèle ci-dessus. Par exemple, si vous passez ** Liste de fruits ** comme ** {{title}} ** et ** ['pomme', 'orange', 'raisin'] ** comme ** éléments **, chaque partie sera remplacée. Sera généré et la chaîne de caractères suivante sera générée.
example2.html
<html>
<head>
<title>Fruits List</title>
</head>
<body>
<ul>
<li>apple</li>
<li>orange</li>
<li>grape</li>
</ul>
</body>
</html>
En faisant bon usage de la fonction de gabarit, vous pourrez développer efficacement en séparant les parties qui changent et les parties qui ne changent pas.
Application à créer
Cette fois, nous allons créer une application qui affiche quelque chose comme "Bonjour votre nom!" Lorsqu'elle reçoit un nom. C'est une application simple, mais grâce à la création de cette application, vous comprendrez les bases de la génération de pages dynamiques. L'image de l'application est la suivante.
Ici, nous passons la chaîne Hironsan comme nom.
Structure du répertoire
Avant de regarder le code, examinons d'abord cette structure de répertoires. Cette fois, la structure des répertoires est la suivante.
.
├── app.py
├── static
│ └── style.css
└── templates
└── index.html
La principale différence par rapport aux précédents [http://qiita.com/Hironsan/items/4e0345704cda5b661d9f) est qu'il existe des répertoires ** static ** et ** templates **. Cette fois, le fichier style.css est stocké de manière statique et le fichier index.html est stocké dans des modèles. L'utilisation générale de ces répertoires est de placer les fichiers HTML dans le répertoire des modèles et de stocker séparément les fichiers CSS, le code JavaScript, les images, etc. dans le répertoire statique.
D'après ce qui précède, les composants de cette application peuvent être divisés en trois.
- Code Python
- modèle
- Fichier CSS
Commençons par le code Python.
Code Python
Le code Python à exécuter cette fois est le suivant.
app.py
import os
import tornado.ioloop
import tornado.web
class MainHandler(tornado.web.RequestHandler):
def get(self):
name = self.get_argument('name', 'World')
self.render('index.html', name=name)
BASE_DIR = os.path.dirname(__file__)
application = tornado.web.Application([
(r'/', MainHandler),
],
template_path=os.path.join(BASE_DIR, 'templates'),
static_path=os.path.join(BASE_DIR, 'static'),
)
if __name__ == '__main__':
application.listen(8888)
tornado.ioloop.IOLoop.current().start()
Les principales différences par rapport au code précédent sont les trois points suivants.
- Passer template_path et static_path lors de la création de l'objet Application
- La méthode de rendu est utilisée dans la méthode get.
- Dans la méthode get, le nom est reçu en utilisant get_argument
template_path et static_path
Dernière fois Comme je l'ai expliqué, l'objet Application pourrait être utilisé pour configurer l'ensemble de l'application. En passant template_path et static_path comme arguments à cet objet Application, ** indique à l'application où se trouvent les modèles et les répertoires statiques. ** Si vous ne les passez pas, l'application ne saura pas où se trouve le fichier HTML, donc le chargement du modèle etc. échouera et l'erreur suivante se produira.
FileNotFoundError: [Errno 2] No such file or directory: '/hogehoge/index.html'
render La méthode d'écriture utilisée la dernière fois est une méthode qui prend une chaîne de caractères comme argument et renvoie cette chaîne de caractères comme réponse HTTP. D'autre part, la ** méthode render est une méthode qui transmet le fichier de modèle et l'argument spécifié au moteur de modèle et envoie la chaîne de caractères résultante en tant que réponse **. Cette fois, nous transmettons les arguments comme suit.
self.render('index.html', name=name)
Le premier argument est le nom de fichier du modèle, et le deuxième argument et les suivants sont les variables transmises au modèle. Ici, le nom de fichier du modèle est «index.html» et le nom est passé en tant que variable avec le nom. Puisque nous transmettons l'argument avec le nom nom, nous pouvons y faire référence avec le nom nom dans le modèle. S'il s'agit de votrenom = nom, faites-y référence comme votre nom dans le modèle.
Après tout, j'ai défini le template_path dans l'objet Application pour indiquer à Tornado l'emplacement du répertoire des modèles et charger le fichier de modèle à partir de la méthode de rendu.
get_argument La méthode ** get_argument est une méthode ** pour recevoir les paramètres passés du client. La classe RequestHandler de Tornado a un certain nombre de méthodes intégrées qui sont utiles. L'un d'eux est get_argument. Par exemple, dans ce cas, il est spécifié comme suit.
name = self.get_argument('name', 'World')
La valeur du nom spécifié dans le premier argument de get_argument est obtenue à partir du paramètre. Si le paramètre n'a pas le nom spécifié dans le premier argument de la méthode get_argument, la valeur du deuxième argument de la méthode get_argument est renvoyée. En d'autres termes, la valeur du deuxième argument définit la valeur par défaut. Si le deuxième argument n'est pas défini dans get_argument et que le nom spécifié dans le premier argument n'existe pas dans le paramètre, une erreur se produit.
Ensuite, jetons un coup d'œil au fichier html.
modèle
Le modèle utilisé pour l'affichage cette fois est le suivant.
templates/index.html
<html>
<head>
<title>Hello Tornado</title>
<link rel="stylesheet" href="{{ static_url('style.css') }}" />
</head>
<body>
<h1>Hello, {{ name }}!</h1>
</body>
</html>
Pouvez-vous voir qu'une partie du modèle est entourée de crochets ondulés? Ceux-ci peuvent être remplacés en passant des données selon les besoins. {{name}} contient la valeur transmise par la méthode render, et {{static_url ('style.css')}} contient le chemin de style.css.
La méthode static_url () utilisée ici ** convertit le chemin relatif du fichier spécifié dans la méthode en une URL **. En outre, lors de la conversion en URL, la valeur de static_path définie dans l'objet Application est utilisée. Rappelez-vous que cette fois, nous définissons le répertoire statique comme static_path.
Comme exemple de conversion par la méthode static_url (), dans le cas de static_url ('style.css'), il est converti en /static/style.css, et dans le cas de static_url ('css / style.css'), / static Il sera converti en /css/style.css.
Enfin, jetons un œil à CSS.
Fichier CSS
Le fichier CSS utilisé pour spécifier le style HTML cette fois est le suivant.
static/style.css
body {
background-color: #FFFFE0;
}
h1 {
background-color: #99cc00;
}
Ce fichier CSS n'utilise aucune fonctionnalité propre à Tornado, je vais donc omettre l'explication.
Courir
Tout comme la dernière fois, exécutez le code suivant pour démarrer le serveur.
$ python app.py
Accédez ensuite à [http: // localhost: 8888 /? Name = yourname](http: // localhost: 8888 /? Name = yourname). Vous devriez voir "Bonjour, votre nom!". Essayez de remplacer la partie votrenom de l'URL par différentes chaînes. Vous pouvez voir que la page est générée dynamiquement en fonction de la chaîne que vous avez passée.
Résumé
Cette fois, j'ai introduit la génération de page dynamique en utilisant le modèle et le moteur de modèle. Vous pouvez voir que vous pouvez générer dynamiquement des pages en passant des données du programme au modèle. Cette fois, je mets le fichier css directement sous statique, mais en réalité, je crée souvent un répertoire css ou un répertoire de feuille de style et y mets le fichier css. Je vais parler de la structure du projet ici. La prochaine fois, je présenterai le modèle Tornado en détail.
Matériel de référence
Recommended Posts