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.

Installation

pip install flask

introduction

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.

Paramètres de développement

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.

Si vous passez 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.

Rendez-le accessible de l'extérieur.

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

Le navigateur démarre également en même temps

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)

Ajoutez une commande pour ouvrir le navigateur avec main. --Lorsque vous exécutez ʻapp.py`, le navigateur démarre et la page s'affiche.
Si vous passez 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 passedebug = 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.

Renvoie un fichier html

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.

Pour le fichier html (ici, ʻindex.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.

Fichier CSS / JavaScript

--Placez les fichiers CSS et les fichiers JavaScript dans le répertoire . / Static. L'image est également placée ici.

À partir du fichier html, chacun

<head>
  <script src="/static/script.js"></script>
  <link rel="stylesheet" href="/static/style.css">
</head>

Appelez comme.

OBTENIR la demande

Ici, considérons une api qui reçoit une requête GET à l'adresse de / 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 ʻurletmethods 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)
  );

Demande POST

Ici, considérons une api qui reçoit une requête POST à l'adresse / 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>

Ici, lorsque vous appuyez sur le bouton, une requête POST avec le JSON de {'message': 'Hello World !!!'} comme données est envoyée. Le même JSON sera renvoyé, alors affichez-le.

API pour renvoyer les données d'image

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()

Tout d'abord, notez que la commande suivante est exécutée au tout début de l'importation de la bibliothèque associée à 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.

Cross Origin Request (COR): accès depuis un autre domaine

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()

Appliquez simplement CORS à ʻapp` et vous êtes prêt à partir.

Authentification utilisateur (authentification Digest)

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.

Ici, on suppose qu'il y a deux utilisateurs, «Michael» et «Smith», et les mots de passe sont respectivement «pw_m» et «pw_s».
Décorez les fonctions qui nécessitent une authentification avec @ 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.

[PYTHON] Résumé d'utilisation pratique de Flask