flask est une bibliothèque pour créer des applications Web avec python. Voici un résumé des méthodes de base d'utilisation de flask.
pip install flask
Tout d'abord, créez une API qui renvoie le plus simple "Hello World".
from flask import Flask
app = Flask(__name__)
@app.route('/')
def root():
return "Hello World!"
if __name__ == "__main__":
app.run()
--Si vous décorez avec la fonction @ app.route (url)
, la fonction sera exécutée lorsque vous accéderez à l'url.
python app.py
Exécutez le ʻapp.py` créé ci-dessus pour démarrer le serveur Web. Lorsque vous accédez à «http: // localhost: 5000 /» avec votre navigateur, vous verrez «Hello World!» Sur l'écran.
from flask import Flask
app = Flask(__name__)
@app.route('/')
def root():
return "Hello World!"
if __name__ == "__main__":
app.run(debug=True,host='localhost',port=5000)
--Changez main
comme ci-dessus.
debug = True
(mode de débogage), il sera automatiquement chargé lorsque vous changez ʻapp.py ou le fichier html décrit plus tard pendant que le serveur est en cours d'exécution. La valeur initiale de «debug» est «False». --
host・
port` peut être décidé librement. La valeur initiale de «port» est de 5000.from flask import Flask
app = Flask(__name__)
@app.route('/')
def root():
return "Hello World!"
if __name__ == "__main__":
app.run(debug=False,host='0.0.0.0',port=5000)
--Changez main
comme ci-dessus.
--Lorsque host = localhost
, il n'est accessible que localement. Pour le rendre accessible de l'extérieur, host =" 0.0.0.0 "
.
--Définissez debug = False
pour des raisons de sécurité.
import threading,webbrowser
from flask import Flask
app = Flask(__name__)
@app.route('/')
def root():
return "Hello World!"
if __name__ == "__main__":
threading.Timer(1.0, lambda: webbrowser.open('http://localhost:5000') ).start()
app.run(debug=False)
main
.
--Lorsque vous exécutez ʻapp.py`, le navigateur démarre et la page s'affiche.debug = True
à ʻapp.run (), le
mainsera ré-exécuté à chaque fois que vous modifiez le code, et le navigateur s'ouvrira en plus à chaque fois. Je passe
debug = False` pour éviter cela.Si vous voulez que le navigateur s'ouvre automatiquement en mode débogage (debug = True
), main
est
if __name__ == "__main__":
app.run(debug=True)
Et alors
!/bin/sh
( sleep 2; open http://localhost:5000/ ) &
python app.py
Il existe un moyen d'exécuter un script shell comme.
from flask import Flask,render_template
app = Flask(__name__)
@app.route('/')
def main():
return render_template('index.html')
if __name__ == "__main__":
app.run()
<html>
<body>
Hello World!
</body>
</html>
--Utilisez render_template (file)
lors du retour d'un fichier html.
), créez un répertoire appelé
templates au même emplacement que ʻapp.py
et placez-le dans ce répertoire.
--Lorsque vous accédez à http: // localhost: 5000 /
à partir d'un navigateur, ʻindex.html` est rendu, et dans ce cas, "Hellow World!" S'affiche.--Placez les fichiers CSS et les fichiers JavaScript dans le répertoire . / Static
. L'image est également placée ici.
<head>
<script src="/static/script.js"></script>
<link rel="stylesheet" href="/static/style.css">
</head>
Appelez comme.
/ get
et renvoie un objet json de {" message ":" Hello World! "}
.from flask import Flask,request,jsonify,render_template
app = Flask(__name__)
@app.route('/')
def index_html():
return render_template('index.html')
@app.route('/get',methods=['GET'])
def get():
return jsonify({'message':'Hello world!'})
if __name__ == '__main__':
app.run()
--Spécifiez ʻurlet
methods pour accepter les requêtes avec decorator
@app.route (url, méthodes). --
jsonify () `est une fonction qui convertit un objet en une chaîne et génère une réponse appropriée.
<html>
<body>
<button onclick='get();'>get</button>
<script>
function get(){
fetch('/get').then(
response => response.json()
).then(
json => { document.body.innerHTML += JSON.stringify(json); }
).catch(
e => console.error(e)
);
}
</script>
</body>
</html>
--Lorsque vous appuyez sur le bouton, le JSON renvoyé s'affiche sous forme de chaîne de caractères.
Si vous souhaitez effectuer quelque chose lorsque vous souhaitez que la récupération réussisse, vous pouvez effectuer les opérations suivantes.
fetch('/get').then(
response => (
if (response.ok){
//成功時に行ないたい処理
} else {
throw new Error()
}
).catch(
e => console.error(e)
);
/ post
et renvoie le même JSON tel quel.from flask import Flask,request,jsonify,render_template
app = Flask(__name__)
@app.route('/')
def index_html():
return render_template('index.html')
@app.route('/post',methods=['POST'])
def post (): # Renvoie le json envoyé tel quel.
req = request.json
return jsonify(req)
if __name__ == '__main__':
app.run()
--JSON envoyé par requête POST peut être obtenu par request.json
.
<html>
<body>
<button onclick='post();'>post</button>
<script>
function post(){
fetch('/post', {
method: "POST",
headers: { "Content-Type": "application/json"},
body: JSON.stringify({"message": "Hello World!!!"})
}).then(
response => response.json()
).then(
json => { document.body.innerHTML += JSON.stringify(json); }
).catch(
e => console.error(e)
);
}
</script>
</body>
</html>
{'message': 'Hello World !!!'}
comme données est envoyée. Le même JSON sera renvoyé, alors affichez-le.Pensez à une API où le serveur reçoit les données, crée un graphique avec matplotlib et renvoie les données d'image. Ici, les données d'image sont converties en dataURL et les données sont renvoyées. La dataURL représente les données d'image sous forme d'URL.
from flask import Flask,render_template,jsonify,request
import matplotlib
matplotlib.use('agg')
from matplotlib import pyplot as plt
from matplotlib.backends.backend_agg import FigureCanvasAgg
import io,base64
app = Flask(__name__)
@app.route('/')
def main():
return render_template('index.html')
@app.route('/image',methods=['POST'])
def image():
data = request.json
x = data['x']
y = data['y']
#Créer un diagramme
plt.figure(figsize=(3,3),dpi=100)
plt.plot(x,y,'k*-',markersize=10)
#Change chiffre en dataURL
canvas = FigureCanvasAgg(plt.gcf())
png_output = io.BytesIO()
canvas.print_png(png_output)
img_data = base64.b64encode(png_output.getvalue()).decode('utf-8')
dataurl = 'data:image/png;base64,'+img_data
return jsonify({'img_data':dataurl})
if __name__ == "__main__":
app.run()
matplotlib
car elle dessinera la figure sur le serveur.import matplotlib
matplotlib.use('agg')
--Dans ʻimage () `, matplotlib crée un graphique à partir de données, le convertit en dataURL et le renvoie.
<html>
<body>
<button onclick="image();">img</button>
<div id='img'></div>
<script>
function image(){
fetch('/image', {
method: "POST",
headers: { "Content-Type": "application/json"},
body: JSON.stringify({"x":[0,1,2,3,4,5], "y":[5,2,4,0,3,8]})
}).then(
response => response.json()
).then(
json => { document.getElementById('img').innerHTML = `<img src="${json['img_data']}">`; }
).catch(
e => console.error(e)
);
}
</script>
</body>
</html>
--Cliquez sur le bouton img pour envoyer les données x = [0,1,2,3,4,5]
, y = [5,2,4,0,3,8]
au serveur.
--Lorsque la réponse est renvoyée, placez le dataURL dans le src de la balise img et l'image sera affichée.
Par défaut, l'accès depuis un autre domaine est restreint. Utilisez le paquet flask-cors
pour autoriser cela.
pip install flask-cors
from flask import Flask
from flask_cors import CORS
app = Flask(__name__)
CORS(app)
@app.route('/')
def root():
return "Hello World!"
if __name__ == "__main__":
app.run()
CORS
à ʻapp` et vous êtes prêt à partir.Utilisez le package flask-httpauth
pour l'authentification.
pip install flask-httpauth
from flask import Flask
from flask_httpauth import HTTPDigestAuth
app = Flask(__name__)
app.config['SECRET_KEY'] = 'secret key here'
auth = HTTPDigestAuth()
users = {
'Michael': 'pw_m',
'Smith': 'pw_s'
}
@auth.get_password
def get_pw(username):
if username in users:
return users.get(username)
return None
@app.route('/')
@auth.login_required
def root():
return "Hello World!"
if __name__ == "__main__":
app.run()
--Créez une fonction (get_pw
) qui renvoie le mot de passe de l'utilisateur si l'utilisateur existe, ou None
si l'utilisateur n'existe pas, étant donné le nom d'utilisateur, puis @auth Décorez avec .get_password
.
@ auth.login_required
.
--Lorsque vous y accédez, l'écran d'authentification apparaît en premier et si vous entrez le nom d'utilisateur et le mot de passe corrects, "Hello World" s'affiche.Recommended Posts