Résumé d'utilisation pratique de Flask

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.

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)

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.

Fichier CSS / JavaScript

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

OBTENIR la demande

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

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>

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

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.

Recommended Posts

Résumé d'utilisation pratique de Flask
Résumé de l'utilisation de pyenv
Résumé de l'utilisation de base de Pandas
résumé de l'utilisation de pytest
Installation de Python 3 et Flask [Résumé de la construction de l'environnement]
Utilisation pratique d'ipython
Résumé de Tensorflow / Keras
Utilisation de base de Jinja2
Utilisation des locaux Python ()
Utilisation de base de SQL Alchemy
Résumé des opérations sur les chaînes
Page de résumé de l'article Flask
Résumé des arguments Python
Résumé de la méthode d'essai
Python - Explication et résumé de l'utilisation des 24 meilleurs packages
Résumé des choses qui étaient pratiques lors de l'utilisation de pandas
pandas Matplotlib Résumé par utilisation
Utilisation super basique de pytest
résumé lié à l'opération de fichier python
Résumé des opérations de liste Python3
2017.3.6 ~ 3.12 Résumé de ce que nous avons fait
Bibliothèque pratique TF-Slim de Tensorflow
Remarques pratiques sur l'utilisation de la commande diff
Résumé des types de distribution Linux
Résumé de l'utilisation de Pipenv (pour moi-même)
Utilisation (minimale) de django logger
Exemple d'utilisation de pickle Python
Utilisation basique de la f-string Python
Un bref résumé de Linux
[Python] Utilisation correcte de la jointure
Index d'utilisation de certains pandas
Résumé des paramètres de connexion proxy
Résumé de l'utilisation de pandas.DataFrame.loc
Résumé des connaissances de base de PyPy Partie 1
Résumé de l'implémentation de base par PyTorch
Résumé de la relation de grattage (sélénium, pyautogui)
Un bref résumé de la collection Python
H29.2.27 ~ 3.5 Résumé de ce que j'ai fait
Résumé de l'enquête sur les développeurs Stack Overflow 2020
Notes d'utilisation faciles pour Anaconda (conda)
Apprentissage automatique ③ Résumé de l'arbre de décision
Résumé des différentes opérations dans Tensorflow
Un résumé approximatif de l'histoire du système d'exploitation
J'ai brièvement résumé les bits quantiques (débutants)
Résumé du comportement de conversion de go json
[python] Utilisation correcte de l'instruction if
[Anaconda3] Résumé des commandes fréquemment utilisées
Résumé de l'utilisation de csvkit
[Pour les professionnels de la concurrence] Résumé du doublement
Résumé des index et des tranches Python
Résumé du traitement multi-processus du langage de script
[OpenCV; Python] Résumé de la fonction findcontours