Créez une application Web simple avec Flask
Site à faire
http://www.kzfmix.com/flaski/
Préparation de l'environnement pour flask avec virtualenv
Voir ici pour savoir comment installer et utiliser virtualenv.
$ mkvirtualenv flaski
$ workon flaski
Installation
(flaski):flask_test hoge$ pip install flask
(flaski):flask_test hoge$ pip install sqlalchemy
Configurez un serveur Web localement et affichez Hello World sur le navigateur.
{app.py}
from flask import Flask
app = Flask(__name__)
# http://127.0.0.1:Avec 5000 comme route("")Désignation du point d'accès dans
# @app.route("hoge")Si vous spécifiez avec etc., http://127.0.0.1:5000/Peut décrire l'opération en hoge.
@app.route("/")
def hello():
return "Hello World!"
if __name__ == "__main__":
#Lancement du serveur Web
app.run()
Et exécutez-le avec python app.py```, ce qui suit sera affiché dans la sortie standard.
(flaski)hoge:src hoge$ python app.py
* Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
Tapez http: //127.0.0.1: 5000 / dans votre navigateur et vous verrez ce qui suit:
Travailler avec SQLite à l'aide de SQLAlchemy
organisation des fichiers
├── flaski
│ ├── __init__.py
│ ├── database.py
│ └── models.py
├── do_create.py
└── do_insert.py
Vérifiez chaque script et opération
{database.py}
# -*- coding: utf-8 -*-
from sqlalchemy import create_engine
from sqlalchemy.orm import scoped_session, sessionmaker
from sqlalchemy.ext.declarative import declarative_base
import os
# wiki.Spécifie de créer un fichier db nommé db
databese_file = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'wiki.db')
#Spécifiez sqlite et spécifiez la création de la table.
engine = create_engine('sqlite:///' + databese_file, convert_unicode=True)
#Spécifiez la table créée pour la liaison.
db_session = scoped_session(sessionmaker(autocommit=False,
autoflush=False,
bind=engine))
# declarative_Création d'instance de base.
Base = declarative_base()
#Stockage de session pour l'exécution?
Base.query = db_session.query_property()
def init_db():
import flaski.models
#Exécuter create avec le contenu de Base?
Base.metadata.create_all(bind=engine)
{models.py}
# -*- coding: utf-8 -*-
from sqlalchemy import Column, Integer, String, Text, DateTime
from flaski.database import Base
from datetime import datetime
class WikiContent(Base):
__tablename__ = 'wikicontents' #nom de la table
id = Column(Integer, primary_key=True) #Colonne 1(id)
title = Column(String(128), unique=True) #Colonne 2(title)
body = Column(Text) #Colonne 3(body)
date = Column(DateTime, default=datetime.now()) #Colonne 4(date)Définir la date et l'heure actuelles par défaut
def __init__(self, title=None, body=None, date=None):
self.title = title
self.body = body
self.date = date
def __repr__(self):
return '<Title %r>' % (self.title)
{do_create.py}
from flaski.database import init_db
#Créer une table
init_db()
En exécutant do_create.py, wiki.db sera créé sous le répertoire flaski. Vérifions le contenu.
{confirm_sqllite.}
$ > (flaski)hoge:flaski hoge$ sqlite3 wiki.db
SQLite version 3.8.5 2014-08-15 22:37:57
Enter ".help" for usage hints.
sqlite> .schema
CREATE TABLE wikicontents (
id INTEGER NOT NULL,
title VARCHAR(128),
body TEXT,
date DATETIME,
PRIMARY KEY (id),
UNIQUE (title)
);
{do_insert.py}
from flaski.database import init_db
from flaski.database import db_session
from flaski.models import WikiContent
#L'identifiant est un numéro de série. Spécifiez le titre et le texte. la date peut être saisie sans autorisation(model.Par défaut de py)
c1 = WikiContent("Flask", "micro framework") #Colonne 1:'Flask'Colonne 2:'micro framework'Créez une instance en spécifiant
db_session.add(c1) #insérer une exécution
db_session.commit() #exécuter la validation
c2 = WikiContent("python", "pppython") #Comme ci-dessus
c3 = WikiContent("kobito", "kakure-momojiri")
db_session.add(c2)
db_session.add(c3)
db_session.commit()
Vérifions le tableau plus tôt.
{confirm_sqllite2.}
(flaski)hoge:flaski hoge$ sqlite3 wiki.db
SQLite version 3.8.5 2014-08-15 22:37:57
Enter ".help" for usage hints.
sqlite> select * from wikicontents;
1|Flask|micro framework|2016-05-14 15:04:24.246057
2|python|pppython|2016-05-14 15:04:24.246057
3|kobito|kakure-momojiri|2016-05-14 15:04:24.246057
Vous pouvez voir que 3 enregistrements ont été insérés.
référence
http://omake.accense.com/static/doc-ja/sqlalchemy/session.html
OBTENIR des données en liant flask et SQLite
Affichez la page Web en utilisant les valeurs de la table créée dans SQLite précédemment.
Code source
organisation des fichiers
├── flaski
│ ├── __init__.py
│ ├── database.py
│ └── models.py
├── app.py
├── static
│ └── snake.jpg
└── templates
├── index.html
├── layout.html
└── show_content.html
Chaque script
{app.py}
# -*- coding: utf-8 -*-
"""
Using SQLAlchemy and Flask get db record.(GET)
"""
from flask import Flask, render_template, abort
from flaski.models import WikiContent
app = Flask(__name__)
app.config['DEBUG'] = True
#Du serveur démarré/Décrit le comportement lors de l'accès.
# @app.route("/hoge")Si vous écrivez, http://127.0.0.1:5000/Vous pouvez décrire le comportement lors de l'accès avec aa.
@app.route("/")
def hello():
contents = WikiContent.query.all()
# index.Exécutez en passant le contexte comme argument à html.
return render_template("index.html", contents=contents)
#/<title>En spécifiant l'index.titre html=content.Le titre est spécifié. méthodes=["GET"]Spécifiez ensuite la requête GET.
@app.route("/<title>", methods=["GET"])
def show_content(title):
"""
:param title:Chaîne de requête pour le modèle
:return:
"""
#Filtrer par titre à partir du tableau wikicontent(obtenir en spécifiant où)signifie d'abord obtenir une seule ligne.
# all()Ensuite, obtenez le résultat dans un format de liste multiple.
content = WikiContent.query.filter_by(title=title).first()
if content is None:
abort(404)
# show_content.Afficher html. Passez le contenu comme argument.
return render_template("show_content.html", content=content)
if __name__ == "__main__":
#Démarrez le serveur
app.run()
snake.jpg
{index.html}
{% extends "layout.html" %}
{% block body %}
<h1>Flaski</h1>
<!-- snake.Affichage de jpg-->
<img src="{{url_for('static', filename='snake.jpg')}}" alt="snake"/>
<ul>
<!--Boucle For de contenu passé en argument-->
{% for content in contents %}
<!-- show_content.Exécutez html.+ {{content.title}}Spectacle.-->
<li><a href="{{url_for('show_content', title=content.title)}}">{{content.title}}</a></li>
{% endfor%}
</ul>
{% endblock %}
{show_content.html}
{% extends "layout.html" %}
{% block body %}
<!--Affichage en utilisant le contenu du contenu-->
<h1>{{content.title}}</h1>
<div>{{content.body}}</div>
<p>{{content.date}}</p>
<div>{{content.body}}</div>
{% endblock %}
Jusqu'à ce point, la page suivante sera affichée à http://127.0.0.1:5000.
Cliquez sur chaque lien pour afficher le contenu de SQLite.
Par exemple, si vous suivez le lien python, il ressemble à ce qui suit.
Il est affiché en utilisant le contenu de python de SQLite. (J'ai pu l'obtenir) Le contenu de l'id suivant = 2.
{confirm_sqllite2.}
(flaski)hoge:flaski hoge$ sqlite3 wiki.db
SQLite version 3.8.5 2014-08-15 22:37:57
Enter ".help" for usage hints.
sqlite> select * from wikicontents;
1|Flask|micro framework|2016-05-14 15:04:24.246057
2|python|pppython|2016-05-14 15:04:24.246057
3|kobito|kakure-momojiri|2016-05-14 15:04:24.246057
Insérer / Mettre à jour (POST) dans la table SQLite avec la publication d'API
Essayez d'insérer et de mettre à jour la table SQLite.
organisation des fichiers
├── flaski
│ ├── __init__.py
│ ├── database.py
│ └── models.py
└── app.py
{app.py}
# -*- coding: utf-8 -*-
from flask import Flask, render_template, abort, request
from flaski.models import WikiContent
from flaski.database import db_session
from datetime import datetime
app = Flask(__name__)
app.config['DEBUG'] = True
@app.teardown_request
def shutdown_session(exception=None):
db_session.remove()
@app.route("/")
def hello():
contents = WikiContent.query.all()
return render_template("index.html", contents=contents)
@app.route("/<title>", methods=["GET"])
def show_content(title):
content = WikiContent.query.filter_by(title=title).first()
if content is None:
abort(404)
return render_template("show_content.html", content=content)
@app.route("/<title>", methods=["POST"])
def post_content(title=None):
if title is None:
abort(404)
content = WikiContent.query.filter_by(title=title).first()
#Si le contenu ne peut pas être obtenu, insérez-le, créez donc une instance de WikiContent.
if content is None:
content = WikiContent(title,
request.form["body"]
)
#Si le contenu peut être obtenu, il sera mis à jour, donc le contenu du corps et datetime=Réglez l'heure actuelle
else:
content.body = request.form["body"]
content.date = datetime.now()
#Ajouter le contenu du contenu et s'engager
db_session.add(content)
db_session.commit()
return content.body
if __name__ == "__main__":
app.run()
Dans cet état, exécutez app.py.
Pour faire une requête http sur la console, installez httpie avec pip install httpie.
{insert_sqlite.}
# body=Mettre à jour avec test de httpie
http --form POST http://localhost:5000/httpie body="test from httpie"
Lorsque j'ai vérifié le contenu, un enregistrement avec id = 4 a été ajouté.
{confirm_sqllite3.}
sqlite> select * from wikicontents;
1|Flask|micro framework|2016-05-14 15:04:24.246057
2|python|pppython|2016-05-14 15:04:24.246057
3|kobito|kakure-momojiri|2016-05-14 15:04:24.246057
4|httpie|test from httpie|2016-05-14 19:32:12.075871
Je vais le mettre à jour cette fois.
{update_sqlite.}
# body=Mis à jour avec modifié à partir de httpie
http --form POST http://localhost:5000/httpie body="modified from httpie"
{confirm_sqllite4.}
sqlite> select * from wikicontents;
1|Flask|micro framework|2016-05-14 15:04:24.246057
2|python|pppython|2016-05-14 15:04:24.246057
3|kobito|kakure-momojiri|2016-05-14 15:04:24.246057
4|httpie|modified from httpie|2016-05-14 19:35:40.904904
Il a été mis à jour.
Dans cet état, si vous cochez http: // localhost: 5000, httpie est ajouté.
Si vous cliquez sur httpie, vous pouvez voir qu'il a été acquis dans l'état mis à jour. J'ai pu POSTER.
Recommended Posts