flask ist eine Bibliothek zum Erstellen von Webanwendungen mit Python. Hier finden Sie eine Zusammenfassung der grundlegenden Methoden zur Verwendung des Kolbens.

Installation

pip install flask

Einführung

Erstellen Sie zunächst eine API, die die einfachste "Hallo Welt" zurückgibt.

from flask import Flask
app = Flask(__name__)

@app.route('/')
def root():
    return "Hello World!"

if __name__ == "__main__":
    app.run()

--Wenn Sie mit der Funktion "@ app.route (url)" dekorieren, wird die Funktion ausgeführt, wenn Sie auf die URL zugreifen.

python app.py

Durch Ausführen der oben erstellten app.py wird der Webserver gestartet. Wenn Sie mit Ihrem Browser auf "http: // localhost: 5000 /" zugreifen, wird "Hello World!" Auf dem Bildschirm angezeigt.

Entwicklungseinstellungen

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)

Ändern Sie main wie oben.
Wenn Sie debug = True (Debug-Modus) übergeben, wird es automatisch geladen, wenn Sie app.py oder die später beschriebene HTML-Datei ändern, während der Server ausgeführt wird. Der Anfangswert von debug ist False. --host ・ port kann frei entschieden werden. Der Anfangswert von "Port" ist 5000.

Machen Sie es von außen zugänglich.

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)

Ändern Sie main wie oben. --Wenn host = localhost, kann nur lokal darauf zugegriffen werden. Um es von außen zugänglich zu machen, ist host =" 0.0.0.0 ".
Setzen Sie aus Sicherheitsgründen debug = False.

Gleichzeitig startet auch der Browser

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)

Fügen Sie einen Befehl hinzu, um den Browser mit main zu öffnen. --Wenn Sie app.py ausführen, startet der Browser und die Seite wird angezeigt.
Wenn Sie debug = True an app.run () übergeben, wird das main bei jeder Änderung des Codes erneut ausgeführt und der Browser wird jedes Mal zusätzlich geöffnet. Ich übergebe debug = False, um das zu verhindern.

Wenn Sie möchten, dass der Browser im Debug-Modus automatisch geöffnet wird (debug = True), ist main

if __name__ == "__main__":
    app.run(debug=True)

Und dann

!/bin/sh
( sleep 2; open http://localhost:5000/ ) &
python app.py

Es gibt eine Möglichkeit, ein Shell-Skript wie auszuführen.

Gibt eine HTML-Datei zurück

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>

--Verwenden Sie render_template (file), wenn Sie eine HTML-Datei zurückgeben. --Für die HTML-Datei (hier index.html) erstellen Sie ein Verzeichnis mit dem Namen templates am selben Speicherort wie app.py und legen Sie es in diesem Verzeichnis ab.

Wenn Sie über einen Browser auf "http: // localhost: 5000 /" zugreifen, wird "index.html" gerendert und in diesem Fall "Hellow World!" Angezeigt.

CSS / JavaScript-Datei

Platzieren Sie CSS- und JavaScript-Dateien im Verzeichnis . / Static. Das Bild wird auch hier platziert.
Aus der HTML-Datei

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

Rufen Sie an wie.

GET Anfrage

Betrachten Sie hier eine API, die eine GET-Anfrage unter der Adresse / get empfängt und ein JSON-Objekt von {" message ":" Hello World! "} Zurückgibt.

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

Geben Sie "url" und "Methoden" an, um Anforderungen mit dem Dekorator "@ app.route (URL, Methoden)" anzunehmen. --jsonify () ist eine Funktion, die ein Objekt in eine Zeichenfolge konvertiert und eine entsprechende Antwort generiert.

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

Wenn Sie die Taste drücken, wird der zurückgegebene JSON als Zeichenfolge angezeigt.

Wenn Sie etwas tun möchten, wenn der Abruf erfolgreich sein soll, können Sie Folgendes tun.

fetch('/get').then(
  response => (
    if (response.ok){
 //成功時に行ないたい処理
    } else {
        throw new Error()
    }
  ).catch(
    e => console.error(e)
  );

POST-Anfrage

Betrachten Sie hier eine API, die eine POST-Anfrage an die Adresse "/ post" empfängt und denselben JSON zurückgibt, wie er ist.

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 (): # Gibt den gesendeten JSON so zurück, wie er ist.
    req = request.json
    return jsonify(req)

if __name__ == '__main__':
    app.run()

--JSON, das per POST-Anfrage gesendet wurde, kann unter request.json abgerufen werden.

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

--Hier, wenn Sie die Taste drücken, wird eine POST-Anfrage mit dem JSON "{'message': 'Hello World !!!'}" gesendet, wenn Daten gesendet werden. Der gleiche JSON wird zurückgegeben, zeigen Sie ihn also an.

API zur Rückgabe von Bilddaten

Stellen Sie sich eine API vor, bei der der Server die Daten empfängt, mit matplotlib ein Diagramm erstellt und die Bilddaten zurückgibt. Hier werden die Bilddaten in eine dataURL konvertiert und die Daten zurückgegeben. Die dataURL repräsentiert die Bilddaten als 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']

 #Erstellen Sie ein Diagramm
    plt.figure(figsize=(3,3),dpi=100)
    plt.plot(x,y,'k*-',markersize=10)

 # Ändern Sie die Zahl in 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()

Beachten Sie zunächst, dass der folgende Befehl zu Beginn des Imports der Bibliothek in Bezug auf "matplotlib" ausgeführt wird, da die Abbildung auf dem Server gezeichnet wird.

import matplotlib
matplotlib.use('agg')

In image () erstellt matplotlib ein Diagramm aus Daten, konvertiert es in dataURL und gibt es zurück.

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

--Klicken Sie auf die Schaltfläche img, um die Daten "x = [0,1,2,3,4,5]", "y = [5,2,4,0,3,8]" an den Server zu senden. --Wenn die Antwort zurückgegeben wird, geben Sie die dataURL in den src des img-Tags ein und das Bild wird angezeigt.

Cross Origin Request (COR): Zugriff von einer anderen Domain

Standardmäßig ist der Zugriff von einer anderen Domäne eingeschränkt. Verwenden Sie dazu das flask-cors-Paket.

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

Wenden Sie einfach "CORS" auf "App" an und es ist in Ordnung.

Benutzerauthentifizierung (Digest-Authentifizierung)

Verwenden Sie zur Authentifizierung das Paket flask-httpauth.

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

--Erstellen Sie eine Funktion (get_pw), die das Kennwort des Benutzers zurückgibt, wenn der Benutzer vorhanden ist, oder None, wenn der Benutzer nicht vorhanden ist, unter Angabe des Benutzernamens und dann @auth Mit .get_password dekorieren.

Hier wird angenommen, dass es zwei Benutzer gibt, 'Michael' und 'Smith', und die Passwörter sind 'pw_m' bzw. 'pw_s'.
Dekorieren Sie Funktionen, die eine Authentifizierung erfordern, mit "@ auth.login_required".
Wenn Sie darauf zugreifen, wird zuerst der Authentifizierungsbildschirm angezeigt. Wenn Sie den richtigen Benutzernamen und das richtige Kennwort eingeben, wird "Hello World" angezeigt.

[PYTHON] Bequeme Nutzungsübersicht von Flask