Préparation de l'environnement (configuration du système d'exploitation)
Préparation de l'environnement (configuration sous OS)
Tracez le contenu du QuickStart de Flask (installation et configuration minimale)
Tracez le contenu de Flask's Tutrial (apprendre à créer une application de base) ★
Créez un contenu original

Cliquez ici pour Flask's Tutrial. Créez un service de microblogage appelé Flaskr. Sqlite est utilisé comme base de données.

Créer une structure de dossiers

Créez un répertoire pour placer l'application. Le nom est arbitraire, mais il est préférable d'utiliser des modèles statiques et tels qu'ils correspondent à la norme. (N'oubliez pas de mettre au pluriel avec des modèles)

[root@cnenyuy5l3c ~]# mkdir flaskr
[root@cnenyuy5l3c ~]# cd flaskr
[root@cnenyuy5l3c flaskr]#
[root@cnenyuy5l3c flaskr]# mkdir templates static
[root@cnenyuy5l3c flaskr]#
[root@cnenyuy5l3c flaskr]# virtualenv env
New python executable in /root/flaskr/env/bin/python2.7
Also creating executable in /root/flaskr/env/bin/python
Installing setuptools, pip, wheel...done.
[root@cnenyuy5l3c flaskr]#
[root@cnenyuy5l3c flaskr]# ls
env  static  templates
[root@cnenyuy5l3c flaskr]#

Isolation de l'environnement virtuel et installation de Flask

Activez virtualenv et installez-y flask.

[root@cnenyuy5l3c flaskr]# . env/bin/activate
(env) [root@cnenyuy5l3c flaskr]#
(env) [root@cnenyuy5l3c flaskr]# pip install flask
Collecting flask
(Omission)
Successfully installed Jinja2-2.9.5 MarkupSafe-0.23 Werkzeug-0.11.15 click-6.7 flask-0.12 itsdangerous-0.24
(env) [root@cnenyuy5l3c flaskr]#

Création de DB

Commencez par créer un schéma.

`schema.sql`


drop table if exists entries;
create table entries (
  id integer primary key autoincrement,
  title string not null,
  text string not null
);

Ce schéma n'est pas diffusé directement, mais modularisé en Python. Le flaskr.py suivant est le corps principal de l'application flaskr, mais ici seule la partie d'initialisation de la base de données est créée.

`flaskr.py`


import sqlite3
from flask import Flask, request, session, g, redirect, url_for, \
     abort, render_template, flash
from contextlib import closing    #Ce n'était pas officiellement ici, mais c'était nécessaire

# configuration
DATABASE = '/tmp/flaskr.db'
DEBUG = True
SECRET_KEY = 'development key'
USERNAME = 'admin'
PASSWORD = 'default'

# create our little application :)
app = Flask(__name__)
app.config.from_object(__name__)

def connect_db():
    return sqlite3.connect(app.config['DATABASE'])

def init_db():
    with closing(connect_db()) as db:
        with app.open_resource('schema.sql') as f:  #Voici le schéma.Exécutez SQL
            db.cursor().executescript(f.read())
        db.commit()

#Diverses fonctions d'affichage seront ajoutées ici.

if __name__ == '__main__':
    app.run(host='0.0.0.0')  #Faire référence à une personne autre que locale

from_object est une méthode qui lit toutes les variables majuscules de la cible. La cible ici est name, c'est-à-dire votre propre fichier (flaskr.py). De plus, dans l'original, le dernier app.run ne spécifie pas d'option, mais cette fois, host = '0.0.0.0' est spécifié pour référence à partir de la machine hôte. Maintenant que nous sommes prêts, créez une base de données.

(flaskr) [root@localhost flaskr]# python
Python 2.7.12 (default, Jan  4 2017, 08:18:28)
[GCC 4.4.7 20120313 (Red Hat 4.4.7-17)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>
>>> from flaskr import init_db
>>> init_db()
>>>

Si vous obtenez l'erreur suivante ici, sqlite3-devel est manquant lors de la compilation de python, vous devez donc le réinstaller.

>>> from flaskr import init_db
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "flaskr.py", line 5, in <module>
    import sqlite3
  File "/opt/local/lib/python2.7/sqlite3/__init__.py", line 24, in <module>
    from dbapi2 import *
  File "/opt/local/lib/python2.7/sqlite3/dbapi2.py", line 28, in <module>
    from _sqlite3 import *
ImportError: No module named _sqlite3

Vérifiez la base de données créée pour le moment.

(env) [root@cnenyuy5l3c flaskr]# sqlite3 /tmp/flaskr.db
SQLite version 3.6.20
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite> .tables
entries
sqlite>
sqlite> .schema
CREATE TABLE entries (
  id integer primary key autoincrement,
  title string not null,
  text string not null
);
sqlite> .quit

Créer une fonction d'affichage

Ajoutez des fonctions à partir d'ici. Le premier est le processus de création et de fermeture d'une connexion avec la base de données.

@app.before_request
def before_request():
    g.db = connect_db()

@app.after_request
def after_request(response):
    g.db.close()
    return response

g est un objet spécial fourni par flask qui stocke la connexion à la base de données actuelle. (g ne stocke les informations que pour une seule demande) before_request est appelé avant la requête. Il n'a pas d'arguments ici.

after_request est appelé après la requête. Ici, la connexion est fermée et la réponse de la base de données est transmise au client. Est-il normal de considérer cela comme un cliché? De là, entrez le contenu correspondant à la page réelle. En gros, le travail d'association de l'URL avec la fonction appelée par le décorateur d'itinéraire.

@app.route('/')    # http://<hostname>:5000/Définir une fonction à appeler lors de l'accès(routage)
def show_entries():
    cur = g.db.execute('select title, text from entries order by id desc')
    entries = [dict(title=row[0], text=row[1]) for row in cur.fetchall()]
    return render_template('show_entries.html', entries=entries)    # show_entries.Incorporer des entrées en HTML appelées html(le rendu)

@app.route('/add', methods=['POST'])
def add_entry():
    if not session.get('logged_in'):
        abort(401)
    g.db.execute('insert into entries (title, text) values (?, ?)',
                 [request.form['title'], request.form['text']])
    g.db.commit()
    flash('New entry was successfully posted')
    return redirect(url_for('show_entries'))    #Rediriger si vous souhaitez passer à une fonction au lieu du rendu()utilisation.

@app.route('/login', methods=['GET', 'POST'])
def login():
    error = None
    if request.method == 'POST':
        if request.form['username'] != app.config['USERNAME']:
            error = 'Invalid username'
        elif request.form['password'] != app.config['PASSWORD']:
            error = 'Invalid password'
        else:
            session['logged_in'] = True
            flash('You were logged in')
            return redirect(url_for('show_entries'))
    return render_template('login.html', error=error)

@app.route('/logout')
def logout():
    session.pop('logged_in', None)
    flash('You were logged out')
    return redirect(url_for('show_entries'))

Créer du HTML

Maintenant que nous avons créé la partie fonction, passons au HTML (apparence). Flask crée le code HTML de base d'origine (souvent appelé layout.html) et le développe comme il convient.

`layout.html`


<!doctype html>
<title>Flaskr</title>
<link rel=stylesheet type=text/css href="{{ url_for('static', filename='style.css') }}">
<div class=page>
  <h1>Flaskr</h1>
  <div class=metanav>
  {% if not session.logged_in %}
    <a href="{{ url_for('login') }}">log in</a>
  {% else %}
    <a href="{{ url_for('logout') }}">log out</a>
  {% endif %}
  </div>
  {% for message in get_flashed_messages() %}
    <div class=flash>{{ message }}</div>
  {% endfor %}
  {% block body %}{% endblock %}    <!--Ce bloc est remplacé sur référence-->
</div>

`show_entries.html`


{% extends "layout.html" %}    <!--Spécifiez le HTML d'origine-->
{% block body %}    <!-- layout.Remplacez le bloc de corps html par:-->
  {% if session.logged_in %}
    <form action="{{ url_for('add_entry') }}" method=post class=add-entry>
      <dl>
        <dt>Title:
        <dd><input type=text size=30 name=title>
        <dt>Text:
        <dd><textarea name=text rows=5 cols=40></textarea>
        <dd><input type=submit value=Share>
      </dl>
    </form>
  {% endif %}
  <ul class=entries>
  {% for entry in entries %}
    <li><h2>{{ entry.title }}</h2>{{ entry.text|safe }}
  {% else %}
    <li><em>Unbelievable.  No entries here so far</em>
  {% endfor %}
  </ul>
{% endblock %}

`login.html`


{% extends "layout.html" %}
{% block body %}
  <h2>Login</h2>
  {% if error %}<p class=error><strong>Error:</strong> {{ error }}{% endif %}
  <form action="{{ url_for('login') }}" method=post>
    <dl>
      <dt>Username:
      <dd><input type=text name=username>
      <dt>Password:
      <dd><input type=password name=password>
      <dd><input type=submit value=Login>
    </dl>
  </form>
{% endblock %}

Créer du CSS

Enfin, créez un fichier CSS.

`style.css`


body            { font-family: sans-serif; background: #eee; }
a, h1, h2       { color: #377BA8; }
h1, h2          { font-family: 'Georgia', serif; margin: 0; }
h1              { border-bottom: 2px solid #eee; }
h2              { font-size: 1.2em; }

.page           { margin: 2em auto; width: 35em; border: 5px solid #ccc;
                  padding: 0.8em; background: white; }
.entries        { list-style: none; margin: 0; padding: 0; }
.entries li     { margin: 0.8em 1.2em; }
.entries li h2  { margin-left: -1em; }
.add-entry      { font-size: 0.9em; border-bottom: 1px solid #ccc; }
.add-entry dl   { font-weight: bold; }
.metanav        { text-align: right; font-size: 0.8em; padding: 0.3em;
                  margin-bottom: 1em; background: #fafafa; }
.flash          { background: #CEE5F5; padding: 0.5em;
                  border: 1px solid #AACBE2; }
.error          { background: #F0D6D6; padding: 0.5em; }

Démarrer, tester

Placez les fichiers ci-dessus comme suit.

flaskr / (racine)
- env/
- templates/
  - layout.html
  - show_entries.html
  - login.html
- static/
  - style.css
- flaskr.py
- schema.sql

Si possible, démarrez l'application et vérifiez l'accès.

(env) [root@cnenyuy5l3c flaskr]# python flaskr.py
 * Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)
 * Restarting with stat
 * Debugger is active!
 * Debugger pin code: 602-691-323

Il ne semble y avoir aucun problème. Avec cela, les bases minimales ont été supprimées (devraient), donc je prévois de passer à l'original la prochaine fois.

Application Web avec Python + Flask ④

Créer une structure de dossiers

Isolation de l'environnement virtuel et installation de Flask

Création de DB

schema.sql

flaskr.py