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:

スクリーンショット 2016-05-10 21.35.04.png

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

github

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 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. スクリーンショット 2016-05-14 17.56.32.png

Cliquez sur chaque lien pour afficher le contenu de SQLite. Par exemple, si vous suivez le lien python, il ressemble à ce qui suit. スクリーンショット 2016-05-14 17.57.11.png

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é.

スクリーンショット 2016-05-14 19.39.02.png

Si vous cliquez sur httpie, vous pouvez voir qu'il a été acquis dans l'état mis à jour. J'ai pu POSTER.

スクリーンショット 2016-05-14 19.39.35.png

Recommended Posts

Créez une application Web simple avec Flask
Créer un service Web avec Docker + Flask
Comment déployer une application Web créée avec Flask sur Heroku
Jouez comme une application Web avec ipywidgets
Créer une application GUI simple en Python
Créer une application graphique avec Tkinter de Python
Démonisez une application Web Python avec Supervisor
Application Web facile avec Python + Flask + Heroku
Pratique de développement d'applications Web: Créez une page de création d'équipe avec Django! (Page de création de décalage)
Créez une application de composition d'images avec Flask + Pillow
Créez un simple générateur d'images par points avec Flask
Gagnez l'application Web Python + Flask avec Jenkins
Démarrez un serveur Web Python simple avec Docker
Créer un babillard avec Heroku, Flask, SQL Alchemy
Lancer un serveur Web avec Python et Flask
Procédure de création d'application multi-plateforme avec kivy
Créez une application Web qui peut être facilement visualisée avec Plotly Dash
Pratique de développement d'applications Web: Créez une page de création d'équipe avec Django! (Introduction)
Créer une application Todo avec Django REST Framework + Angular
Créez une application graphique native avec Py2app et Tkinter
Créer un serveur REST (simple)
Apprentissage automatique facile avec scikit-learn et flask ✕ Application Web
Développement d'applications Web avec Flask
Essayez de créer une application Todo avec le framework Django REST
Créer une application Todo avec Django ③ Créer une page de liste de tâches
Créez une application Web qui convertit le PDF en texte à l'aide de Flask et PyPDF2
Application Web avec Python + Flask ② ③
Créer un serveur textlint simple
Créer un répertoire avec python
Créer une application Todo avec Django ⑤ Créer une fonction d'édition de tâches
Déployez des applications Web en temps réel avec Swampdragon x Apache
Déployer une application Web créée avec Streamlit sur Heroku
Application Web avec Python + Flask ④
Pratique de développement d'applications Web: Créez une page de création d'équipe avec Django! (Ecrire un modèle de base)
Pratique de développement d'applications Web: Créez une page de création d'équipe avec Django! (Traitement d'authentification)
Pratique de développement d'applications Web: Créez une page de création d'équipe avec Django! (Expérience sur la page d'administration)
Créez une application Web qui reconnaît les nombres avec un réseau neuronal
Créez une application d'apprentissage automatique avec ABEJA Platform + LINE Bot
J'ai créé une application de livre simple avec python + Flask ~ Introduction ~
Créez un outil d'analyse vidéo simple avec python wxpython + openCV
Créez un environnement de développement Python simple avec VSCode et Docker Desktop
Tornado - Créons une API Web qui renvoie facilement JSON avec JSON
Créez une API Web capable de fournir des images avec Django
Créer une application Todo avec Django ① Créer un environnement avec Docker
(Pour les débutants) Essayez de créer une API Web simple avec Django
Créez une application CRUD simple en utilisant la vue de classe générique de Django
Créer un lecteur CSV avec Flask
Créer un serveur Flask avec Docker
Exécutez l'application avec Flask + Heroku
Créez un environnement virtuel avec Python!
Créer une application Web avec Django
Créer une application Web avec Flask ①
Créer une application Web avec Flask ③
Créez un stepper de poisson avec numpy.random
Créer une application Web avec Flask ④
Créer un téléchargeur de fichiers avec Django
Pratique de développement d'applications Web: Créez une page de création d'équipe avec Django! (Conception du modèle de base de données)
Étapes pour configurer Pipenv, créer une application CRUD avec Flask et la conteneuriser avec Docker