JSON-antwoord teruggeven vanuit Flask-weergave

Ik heb een functie die een CSV-bestand met Panda’s analyseert en een dictaat met beknopte informatie produceert. Ik wil de resultaten retourneren als een reactie van een Flask-weergave. Hoe retourneer ik een JSON-antwoord?

@app.route("/summary")
def summary():
    d = make_summary()
    # send it back as json

Antwoord 1, autoriteit 100%

Vanaf Flask 1.1.0 kan een weergave direct een Python-dictaat retourneren en Flask roept jsonify automatisch.

@app.route("/summary")
def summary():
    d = make_summary()
    return d

Als uw Flask-versie lager is dan 1.1.0 of als u een ander JSON-serializeerbaar object wilt retourneren, importeert en gebruikt u jsonify.

from flask import jsonify
@app.route("/summary")
def summary():
    d = make_summary()
    return jsonify(d)

Antwoord 2, autoriteit 28%

jsonify serialiseert de gegevens die u doorgeeft aan JSON. Als je de gegevens zelf wilt serialiseren, doe dan wat jsonify doet door een reactie op te bouwen met status=200 en mimetype='application/json' .

from flask import json
@app.route('/summary')
def summary():
    data = make_summary()
    response = app.response_class(
        response=json.dumps(data),
        status=200,
        mimetype='application/json'
    )
    return response

Antwoord 3, autoriteit 16%

Geef trefwoordargumenten door aan flask.jsonify en ze worden uitgevoerd als een JSON-object.

@app.route('/_get_current_user')
def get_current_user():
    return jsonify(
        username=g.user.username,
        email=g.user.email,
        id=g.user.id
    )
{
    "username": "admin",
    "email": "[email protected]",
    "id": 42
}

Als je al een dictaat hebt, kun je het direct doorgeven als jsonify(d).


Antwoord 4, autoriteit 5%

Als u jsonify om de een of andere reden niet wilt gebruiken, kunt u dit handmatig doen. Bel flask.json.dumps om JSON-gegevens te maken en retourneer vervolgens een reactie met het inhoudstype application/json.

from flask import json
@app.route('/summary')
def summary():
    data = make_summary()
    response = app.response_class(
        response=json.dumps(data),
        mimetype='application/json'
    )
    return response

flask.json verschilt van de ingebouwde json-module. Het gebruikt de snellere simplejson-module, indien beschikbaar, en maakt verschillende integraties met uw Flask-app mogelijk.


Antwoord 5, autoriteit 3%

Als u een JSON-antwoord wilt retourneren en een statuscode wilt instellen, kunt u make_response gebruiken:

from flask import jsonify, make_response
@app.route('/summary')
def summary():
    d = make_summary()
    return make_response(jsonify(d), 200)

Inspiratie ontleend aan deze opmerking in de Flask issue tracker.


Antwoord 6, autoriteit 2%

Vanaf versie 1.1.0 Flask, als een weergave een dictaat retourneert, wordt het omgezet in een JSON-antwoord.

@app.route("/users", methods=['GET'])
def get_user():
    return {
        "user": "John Doe",
    }

Antwoord 7, autoriteit 2%

Als je een door de gebruiker geüpload bestand wilt analyseren, laat de Flask snelstart zien hoe om bestanden van gebruikers te krijgen en ze te openen. Haal het bestand op van request.files en geef het door aan de samenvattingsfunctie.

from flask import request, jsonify
from werkzeug import secure_filename
@app.route('/summary', methods=['GET', 'POST'])
def summary():
    if request.method == 'POST':
        csv = request.files['data']
        return jsonify(
            summary=make_summary(csv),
            csv_name=secure_filename(csv.filename)
        )
    return render_template('submit_data.html')

Vervang de 'data'-sleutel voor request.files door de naam van de bestandsinvoer in uw HTML-formulier.


Antwoord 8

Ik gebruik een decorateur om het resultaat van jsonfiy te retourneren. Ik denk dat het beter leesbaar is wanneer een weergave meerdere rendementen heeft. Dit biedt geen ondersteuning voor het retourneren van een tuple zoals content, status, maar ik behandel het retourneren van foutstatussen met app.errorhandler in plaats daarvan.

import functools
from flask import jsonify
def return_json(f):
    @functools.wraps(f)
    def inner(**kwargs):
        return jsonify(f(**kwargs))
    return inner
@app.route('/test/<arg>')
@return_json
def test(arg):
    if arg == 'list':
        return [1, 2, 3]
    elif arg == 'dict':
        return {'a': 1, 'b': 2}
    elif arg == 'bool':
        return True
    return 'none of them'

Antwoord 9

Flask 1.1.x ondersteunt het retourneren van een JSON-dictaat zonder jsonify aan te roepen. Als je iets anders dan een dictaat wilt retourneren, moet je nog steeds jsonify bellen.

@app.route("/")
def index():
    return {
        "api_stuff": "values",
    }

is gelijk aan

@app.route("/")
def index():
    return jsonify({
        "api_stuff": "values",
    })

Zie het pull-verzoek dat dit heeft toegevoegd: https://github.com/pallets/flask /pull/3111


Antwoord 10

Voorafgaand aan Flask 0.11 stond jsonfiy niet toe dat een array rechtstreeks werd geretourneerd. Geef in plaats daarvan de lijst door als zoekwoordargument.

@app.route('/get_records')
def get_records():
    results = [
        {
          "rec_create_date": "12 Jun 2016",
          "rec_dietary_info": "nothing",
          "rec_dob": "01 Apr 1988",
          "rec_first_name": "New",
          "rec_last_name": "Guy",
        },
        {
          "rec_create_date": "1 Apr 2016",
          "rec_dietary_info": "Nut allergy",
          "rec_dob": "01 Feb 1988",
          "rec_first_name": "Old",
          "rec_last_name": "Guy",
        },
    ]
    return jsonify(results=list)

Antwoord 11

Als u in Flask 1.1 een woordenboek retourneert, wordt het automatisch geconverteerd naar JSON. Dus als make_summary() een woordenboek retourneert, kun je

from flask import Flask
app = Flask(__name__)
@app.route('/summary')
def summary():
    d = make_summary()
    return d

De SO die vraagt ​​over het opnemen van de statuscode is gesloten als een duplicaat van deze. Dus om die vraag ook te beantwoorden, kun je de statuscode opnemen door een tuple van de vorm (dict, int) te retourneren. Het dict wordt geconverteerd naar JSON en de int wordt de HTTP-statuscode. Zonder enige invoer is de Status de standaard 200. Dus in het bovenstaande voorbeeld zou de code 200 zijn. In het onderstaande voorbeeld is dit gewijzigd in 201.

from flask import Flask
app = Flask(__name__)
@app.route('/summary')
def summary():
    d = make_summary()
    return d, 201  # 200 is the default

U kunt de statuscode controleren met

curl --request GET "http://127.0.0.1:5000/summary" -w "\ncode: %{http_code}\n\n"

Antwoord 12

als het een dictaat is, kan flask het direct retourneren (versie 1.0.2)

def summary():
    d = make_summary()
    return d, 200

Antwoord 13

Het antwoord is hetzelfde als u de op klassen gebaseerde weergaven van Flask gebruikt.

from flask import Flask, request, jsonify
from flask.views import MethodView
app = Flask(__name__)
class Summary(MethodView):
    def get(self):
        d = make_summary()
        return jsonify(d)
app.add_url_rule('/summary/', view_func=Summary.as_view('summary'))

Antwoord 14

Ik hou van deze manier:

    @app.route("/summary")
    def summary():
        responseBody = { "message": "bla bla bla", "summary": make_summary() }
        return make_response(jsonify(responseBody), 200)

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Other episodes