Verkrijg de gegevens die zijn ontvangen in een Flask-verzoek

Ik wil de gegevens naar mijn Flask-app kunnen laten verzenden. Ik heb geprobeerd toegang te krijgen tot request.datamaar het is een lege string. Hoe krijg je toegang tot verzoekgegevens?

from flask import request
@app.route('/', methods=['GET', 'POST'])
def parse_request():
    data = request.data  # data is empty
    # need posted data here

Het antwoord op deze vraag bracht me ertoe om Onbewerkte POST-body in Python Flask te krijgen, ongeacht de Content-Type-header, die gaat over het verkrijgen van de onbewerkte gegevens in plaats van de geparseerde gegevens.


Antwoord 1, autoriteit 100%

De docsbeschrijven de attributen die beschikbaar zijn op het verzoek. In de meeste gevallen zal request.dataleeg zijn omdat het als reserve wordt gebruikt:

request.dataBevat de inkomende verzoekgegevens als tekenreeks voor het geval het werd geleverd met een mimetype dat Flask niet verwerkt.

  • request.args: de sleutel /waarde-paren in de URL-queryreeks
  • request.form: de sleutel /value-paren in de hoofdtekst, van een HTML-postformulier of JavaScript-verzoek dat niet JSON-gecodeerd is
  • request.files: de bestanden in de body, die Flask gescheiden houdt van form. HTML-formulieren moeten enctype=multipart/form-datagebruiken, anders worden bestanden niet geüpload.
  • request.values: gecombineerd argsen form, met voorkeur voor argsals sleutels elkaar overlappen
  • request.json: geparseerde JSON gegevens. Het verzoek moet het inhoudstype request.get_json(force=True)hebben, of gebruik request.get_json(force=True)om het inhoudstype te negeren.

Dit zijn allemaal MultiDict-instanties (behalve voor json). U kunt waarden openen met:

  • request.form['name']: gebruik indexering als u weet dat de sleutel bestaat
  • request.form.get('name'): gebruik getals de sleutel mogelijk niet bestaat
  • request.form.getlist('name'): gebruik getlistals de sleutel meerdere keren wordt verzonden en u een lijst met waarden wilt. getretourneert alleen de eerste waarde.

Antwoord 2, autoriteit 14%

Gebruik request.dataom de onbewerkte gegevens te krijgen . Dit werkt alleen als het niet als formuliergegevens kan worden geparseerd, anders is het leeg en heeft request.formde geparseerde gegevens.

from flask import request
request.data

Antwoord 3, autoriteit 13%

Gebruik request.argsvoor URL-queryparameters.

search = request.args.get("search")
page = request.args.get("page")

Gebruik request.formvoor geposte formulierinvoer.

email = request.form.get('email')
password = request.form.get('password')

Voor JSON die is gepost met inhoudstype request.get_json(force=True), gebruikt u request.get_json().

data = request.get_json()

Antwoord 4, autoriteit 8%

Hier is een voorbeeld van het ontleden van geposte JSON-gegevens en deze terug te echoën.

from flask import Flask, request, jsonify
app = Flask(__name__)
@app.route('/foo', methods=['POST']) 
def foo():
    data = request.json
    return jsonify(data)

JSON posten met curl:

curl -i -H "Content-Type: application/json" -X POST -d '{"userId":"1", "username": "fizz bizz"}' http://localhost:5000/foo

Of om Postman te gebruiken:

postbode gebruiken om JSON te posten


Antwoord 5, autoriteit 3%

Gebruik request.get_data()om de onbewerkte berichttekst te krijgen, ongeacht het inhoudstype. Als u request.datagebruikt, roept het request.get_data(parse_form_data=True)aan, dat het request.formMultiDicten laat dataleeg.


Antwoord 6, autoriteit 3%

Als je JSON post met inhoudstype request.get_json(force=True), gebruik dan request.get_json()om het in Flask te krijgen. Als het inhoudstype niet correct is, wordt Nonegeretourneerd. Als de gegevens geen JSON zijn, wordt er een fout gegenereerd.

@app.route("/something", methods=["POST"])
def do_something():
    data = request.get_json()

Antwoord 7, autoriteit 2%

Om request.formals een normaal woordenboek te krijgen, gebruikt u request.form.to_dict(flat=False).

Als u JSON-gegevens voor een API wilt retourneren, geeft u deze door aan jsonify.

Dit voorbeeld retourneert formuliergegevens als JSON-gegevens.

@app.route('/form_to_json', methods=['POST'])
def form_to_json():
    data = request.form.to_dict(flat=False)
    return jsonify(data)

Hier is een voorbeeld van POST-formuliergegevens met curl, terugkerend als JSON:

$ curl http://127.0.0.1:5000/data -d "name=ivanleoncz&role=Software Developer"
{
  "name": "ivanleoncz", 
  "role": "Software Developer"
}

Antwoord 8

Gebruik request.get_json()om geposte JSON-gegevens op te halen.

data = request.get_json()
name = data.get('name', '')

Gebruik request.formom gegevens op te halen bij het indienen van een formulier met de POST-methode.

name = request.form.get('name', '')

Gebruik request.argsom gegevens door te geven in de queryreeks van de URL, zoals bij het indienen van een formulier met de GET-methode.

request.args.get("name", "")

request.formenz. zijn dict-achtig, gebruik de get-methode om een waarde met een standaardwaarde te krijgen als deze niet is doorgegeven.


Antwoord 9

Gebruik request.get_json(force=True)om JSON gepost te krijgen zonder het inhoudstype request.get_json(force=True).

@app.route('/process_data', methods=['POST'])
def process_data():
    req_data = request.get_json(force=True)
    language = req_data['language']
    return 'The language value is: {}'.format(language)

Antwoord 10

Om JSON met jQuery in JavaScript te posten, gebruikt u JSON.stringifyom de gegevens te dumpen en stelt u het inhoudstype in op request.get_json(force=True).

var value_data = [1, 2, 3, 4];
$.ajax({
    type: 'POST',
    url: '/process',
    data: JSON.stringify(value_data),
    contentType: 'application/json',
    success: function (response_data) {
        alert("success");
    }   
});

Ontdek het in Flask met request.get_json().

data = request.get_json()

Antwoord 11

De onbewerkte gegevens worden vanaf de WSGI-server doorgegeven aan de Flask-toepassing als request.stream. De lengte van de stream staat in de kop Content-Length.

length = request.headers["Content-Length"]
data = request.stream.read(length)

Het is meestal veiliger om in plaats daarvan request.get_data()te gebruiken.


Antwoord 12

Gebruik request.get_json()om JSON te ontleden.

@app.route("/something", methods=["POST"])
def do_something():
    result = handle(request.get_json())
    return jsonify(data=result)

Antwoord 13

Hier is een voorbeeld van het plaatsen van formuliergegevens om een gebruiker aan een database toe te voegen. Controleer request.method == "POST"om te controleren of het formulier is verzonden. Gebruik de sleutels van request.formom de formuliergegevens op te halen. Render anders een HTML-sjabloon met een <form>. De velden in het formulier moeten name-attributen hebben die overeenkomen met de sleutels in request.form.

from flask import Flask, request, render_template
app = Flask(__name__)
@app.route("/user/add", methods=["GET", "POST"])
def add_user():
    if request.method == "POST":
        user = User(
            username=request.form["username"],
            email=request.form["email"],
        )
        db.session.add(user)
        db.session.commit()
        return redirect(url_for("index"))
    return render_template("add_user.html")
<form method="post">
    <label for="username">Username</label>
    <input type="text" name="username" id="username">
    <label for="email">Email</label>
    <input type="email" name="email" id="email">
    <input type="submit">
</form>

Antwoord 14

Als de hoofdtekst wordt herkend als formuliergegevens, staat deze in request.form. Als het JSON is, staat het in request.get_json(). Anders staan de onbewerkte gegevens in request.data. Als u niet zeker weet hoe gegevens worden ingediend, kunt u een or-keten gebruiken om de eerste met gegevens te krijgen.

def get_request_data():
    return (
        request.args
        or request.form
        or request.get_json(force=True, silent=True)
        or request.data
    )

request.argsbevat args die zijn geparseerd uit de queryreeks, ongeacht wat er in de hoofdtekst stond, dus u zou die uit get_request_data()verwijderen als zowel het als een body moet tegelijkertijd gegevens bevatten.


Antwoord 15

Bij het schrijven van een Slack-bot, die JSON-gegevens zou moeten verzenden, kreeg ik een payload waarbij het Content-Typeapplication/x-www-form-urlencodedwas .

Ik heb request.get_json()geprobeerd en het werkte niet.

@app.route('/process_data', methods=['POST'])
def process_data():
   req_data = request.get_json(force=True)

In plaats daarvan gebruikte ik request.formom het formuliergegevensveld te krijgen dat bevatteJSON, en laadde dat vervolgens.

from flask import json
@ app.route('/slack/request_handler', methods=['POST'])
def request_handler():
   req_data = json.loads(request.form["payload"])

Antwoord 16

Als het inhoudstype wordt herkend als formuliergegevens, zal request.datadat ontleden in request.formen een lege tekenreeks retourneren.

Als u de onbewerkte gegevens wilt ontvangen, ongeacht het inhoudstype, belt u request.get_data(). request.dataroept get_data(parse_form_data=True)aan, terwijl de standaard Falseis als je het rechtstreeks aanroept.


Antwoord 17

Als u formuliergegevens plaatst met een HTML-formulier, zorg er dan voor dat de input-tags name-attributen hebben, anders zullen ze niet aanwezig zijn in request.form.

@app.route('/', methods=['GET', 'POST'])
def index():
    print(request.form)
    return """
<form method="post">
    <input type="text">
    <input type="text" id="txt2">
    <input type="text" name="txt3" id="txt3">  
    <input type="submit">
</form>
"""
ImmutableMultiDict([('txt3', 'text 3')])

Alleen de txt3invoer had een name, dus het is de enige sleutel die aanwezig is in request.form.


Antwoord 18

Importverzoek:

from flask import request

URL-queryparameters:

name = request.args.get("name")
age = request.args.get("age")

Formulierinvoer:

name = request.form.get('name')
age = request.form.get('age')

OF (gebruik indexering als u weet dat de sleutel bestaat, geef de naam van de invoervelden op)

name = request.form['name']
age = request.form['age']

JSON-gegevens (voor inhoudstype application/json)

data = request.get_json()

Antwoord 19

@app.route('/addData', methods=['POST'])
def add_data():
     data_in = mongo.db.Data
     id = request.values.get("id")
     name = request.values.get("name")
     newuser = {'id' : id, 'name' : name}
     if voter.find({'id' : id, 'name' : name}).count() > 0:
            return "Data Exists"
     else:
            data_in.insert(newuser)
            return "Data Added"

Antwoord 20

request.data

Dit is geweldig om te gebruiken, maar onthoud dat het als een tekenreeks binnenkomt en moet worden herhaald.

Other episodes