Obtenez les données reçues dans une demande Flask

737

Je veux pouvoir envoyer les données à mon application Flask. J'ai essayé d'accéder request.datamais c'est une chaîne vide. Comment accédez-vous aux données de demande?

from flask import request

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

La réponse à cette question m'a amené à demander Get corps brut POST dans Python Flask indépendamment de l'en-tête Content-Type suivant, qui consiste à obtenir les données brutes plutôt que les données analysées.

ddinchev
la source

Réponses:

1270

Les documents décrivent les attributs disponibles sur la demande. Dans la plupart des cas, request.datail sera vide car il est utilisé comme solution de rechange:

request.data Contient les données de demande entrantes sous forme de chaîne au cas où elles seraient fournies avec un flacon de type mimetype non géré.

  • request.args: les paires clé / valeur dans la chaîne de requête URL
  • request.form: les paires clé / valeur dans le corps, à partir d'un formulaire de publication HTML ou d'une requête JavaScript non codée JSON
  • request.files: les fichiers dans le corps, dont Flask se sépare form. Les formulaires HTML doivent utiliser enctype=multipart/form-dataou les fichiers ne seront pas téléchargés.
  • request.values: combiné argset form, préférant argssi les clés se chevauchent
  • request.json: données JSON analysées. La demande doit avoir le application/jsontype de contenu ou utiliser request.get_json(force=True)pour ignorer le type de contenu.

Tous ces éléments sont des MultiDictinstances (à l'exception de json). Vous pouvez accéder aux valeurs en utilisant:

  • request.form['name']: utilisez l'indexation si vous savez que la clé existe
  • request.form.get('name'): utiliser getsi la clé n'existe pas
  • request.form.getlist('name'): à utiliser getlistsi la clé est envoyée plusieurs fois et que vous souhaitez une liste de valeurs. getrenvoie uniquement la première valeur.
Robert
la source
205

Pour obtenir les données brutes, utilisez request.data. Cela ne fonctionne que s'il ne peut pas être analysé en tant que données de formulaire, sinon il sera vide et request.formcontiendra les données analysées.

from flask import request
request.data
clyfish
la source
178

Pour les paramètres de requête d'URL, utilisez request.args.

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

Pour la saisie de formulaire publiée, utilisez request.form.

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

Pour JSON publié avec un type de contenu application/json, utilisez request.get_json().

data = request.get_json()
Fizer Khan
la source
98

Voici un exemple d'analyse des données JSON publiées et de leur retour.

from flask import Flask, request, jsonify

app = Flask(__name__)

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

Pour publier du JSON avec curl:

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

Ou pour utiliser Postman:

utiliser postman pour publier JSON

Little Roys
la source
36

Si vous publiez du JSON avec un type de contenu application/json, utilisez-le request.get_json()pour l'obtenir dans Flask. Si le type de contenu n'est pas correct, Noneest renvoyé. Si les données ne sont pas JSON, une erreur est générée.

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

Pour obtenir le corps brut de la publication, quel que soit le type de contenu, utilisez request.get_data(). Si vous utilisez request.data, il appelle request.get_data(parse_form_data=True), ce qui remplira request.form MultiDictet laissera datavide.

Xiao
la source
18

Pour obtenir request.formun dictionnaire normal, utilisez request.form.to_dict(flat=False).

Pour renvoyer des données JSON pour une API, transmettez-les à jsonify.

Cet exemple renvoie des données de formulaire en tant que données JSON.

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

Voici un exemple de données de formulaire POST avec curl, renvoyant au format JSON:

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

Utilisez request.get_json()pour obtenir des données JSON publiées.

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

Permet request.formd'obtenir des données lors de la soumission d'un formulaire avec la méthode POST.

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

Utilisez request.argspour obtenir les données transmises dans la chaîne de requête de l'URL, comme lors de la soumission d'un formulaire avec la méthode GET.

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

request.formetc. sont de type dict, utilisez la getméthode pour obtenir une valeur avec une valeur par défaut si elle n'a pas été transmise.

Ravin Gupta
la source
10

Pour que JSON soit publié sans le application/jsontype de contenu, utilisez 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)
Tarik Fojnica
la source
10

Les données brutes sont transmises à l'application Flask à partir du serveur WSGI en tant que request.stream. La longueur du flux est dans l'en- Content-Lengthtête.

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

Il est généralement plus sûr d'utiliser à la request.get_data()place.

Daniel
la source
9

Pour publier JSON avec jQuery en JavaScript, utilisez JSON.stringifypour vider les données et définissez le type de contenu sur application/json.

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");
    }   
});

Analyser dans Flask avec request.get_json().

data = request.get_json()
vaishali chaudhari
la source
8

Pour analyser JSON, utilisez request.get_json().

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

Voici un exemple de publication de données de formulaire pour ajouter un utilisateur à une base de données. Cochez request.method == "POST"pour vérifier si le formulaire a été envoyé. Utilisez les touches de request.formpour obtenir les données du formulaire. Rendre un modèle HTML avec un <form>sinon. Les champs du formulaire doivent avoir des nameattributs qui correspondent aux clés 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>
Dulangi_Kanchana
la source
4

Si le type de contenu est reconnu en tant que données de formulaire, request.datal'analysera enrequest.form et renverra une chaîne vide.

Pour obtenir les données brutes quel que soit le type de contenu, appelez request.get_data() . request.dataappels get_data(parse_form_data=True), tandis que la valeur par défaut est Falsesi vous l'appelez directement.

Zavec
la source
4

Si le corps est reconnu en tant que donnée de formulaire, il le sera request.form. Si c'est JSON, ce sera dedans request.get_json(). Sinon, les données brutes seront entrées request.data. Si vous n'êtes pas sûr de la façon dont les données seront soumises, vous pouvez utiliser une orchaîne pour obtenir la première avec des données.

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

request.argscontient des arguments analysés à partir de la chaîne de requête, quel que soit le contenu du corps, vous devez donc le supprimer get_request_data()si lui et un corps doivent contenir des données en même temps.

Paul Gowder
la source
2

Lorsque vous publiez des données de formulaire avec un formulaire HTML, assurez-vous que les inputbalises ont des nameattributs, sinon ils ne seront pas présents dans 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')])

Seule l' txt3entrée avait un name, c'est donc la seule clé présente request.form.

gelé
la source