Pobierz dane otrzymane w żądaniu Flask

Aby uzyskać surowe dane, Użyj request.data. Działa to tylko wtedy, gdy nie można go przetworzyć jako dane formularza, w przeciwnym razie będzie on pusty i request.form będzie miał przetworzone dane.

from flask import request
request.data

Dla parametrów zapytań URL użyj request.args.

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

Do wpisania formularza należy użyć request.form.

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

Dla JSON zamieszczonego z typem treści application/json, użyj request.get_json().

data = request.get_json()

Oto przykład parsowania opublikowanych danych JSON i cofania ich.

from flask import Flask, request, jsonify

app = Flask(__name__)

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

Aby dodać JSON z curl:

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

Lub użyć listonosza:

Jeśli umieścisz JSON z typem zawartości application/json, Użyj request.get_json(), aby uzyskać go w Flask. Jeśli typ zawartości jest nieprawidłowy, zwracane jest None. Jeśli dane nie są JSON, pojawia się błąd.

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

Aby uzyskać surowe ciało posta niezależnie od typu zawartości, użyj request.get_data(). Jeśli użyjesz request.data, wywoła request.get_data(parse_form_data=True), co wypełni request.form MultiDict i zostawić data puste.

Aby uzyskać request.form jako zwykły słownik, użyj request.form.to_dict(flat=False).

Aby zwrócić dane JSON dla API, przekaż je do jsonify.

Ten przykład zwraca dane formularza jako dane JSON.

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

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

Użyj request.get_json(), aby uzyskać opublikowane dane JSON.

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

Użyj request.form, Aby uzyskać dane podczas przesyłania formularza za pomocą metody POST.

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

Użyj request.args, aby uzyskać dane przekazane w ciągu zapytania URL, jak podczas przesyłania formularza za pomocą metody GET.

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

request.form itd. są podobne do dict, użyj metody get, aby uzyskać wartość z wartością domyślną, jeśli nie została przekazana.

Aby opublikować JSON bez typu zawartości application/json, Użyj 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)

Aby opublikować JSON z jQuery w JavaScript, użyj JSON.stringify do zrzutu danych i ustaw typ zawartości na 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");
    }   
});

Parse it in Flask with request.get_json().

data = request.get_json()

Surowe dane są przekazywane do aplikacji Flask z serwera WSGI jako request.stream. Długość strumienia jest w nagłówku Content-Length.

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

Jest zwykle bezpieczniejsze użycie request.get_data() zamiast tego.

Aby przetworzyć JSON, użyj request.get_json().

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

Oto przykład zamieszczania danych formularza, aby dodać użytkownika do bazy danych. Sprawdź request.method == "POST", aby sprawdzić, czy formularz został złożony. Użyj klawiszy z request.form, Aby pobrać dane formularza. Renderuj szablon HTML za pomocą <form> w przeciwnym razie. Pola w formularzu powinny mieć atrybuty name pasujące do kluczy w 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>

Jeśli typ zawartości jest rozpoznawany jako dane formularza, request.data przetworzy go do request.form i zwróci pusty łańcuch.

Aby uzyskać surowe dane niezależnie od typu zawartości, wywołaj request.get_data(). request.data wywołuje get_data(parse_form_data=True), podczas gdy domyślną wartością jest False, jeśli wywołujesz ją bezpośrednio.

Jeśli ciało zostanie rozpoznane jako dane formularza, będzie w request.form. Jeśli to JSON, to będzie w request.get_json(). W przeciwnym razie surowe dane będą w request.data. Jeśli nie jesteś pewien, w jaki sposób dane zostaną przesłane, możesz użyć łańcucha or, Aby uzyskać pierwszy z danymi.

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

request.args zawiera args przetwarzane z ciągu zapytania, niezależnie od tego, co było w ciele, więc można usunąć to z get_request_data(), Jeśli zarówno to, jak i ciało powinny dane w tym samym czasie.

Mój problem był podobny. Otrzymałem payload prośbę o POST, gdy użytkownik kliknął button z mojego slackbota. Content-Type było application/x-www-form-urlencoded. Użyłem kolby Python3.

Próbowałem tego rozwiązania i nie zadziałało

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

Moje rozwiązanie 1 było:

from urllib.parse import parse_qs
# Some code
@ app.route('/slack/request_handler', methods=['POST'])
def request_handler():    
    # request.get_data() returned a bytestring
    # parse_qs() returned a dict from a bytestring. This dict has 1 pair
    # I tried payload_dict.keys() to see what keys in the dict and it had one key only
    payload_dict = parse_qs(request.get_data())

    # Get the value of the key from payload_dict
    # Value of the key from payload_dict is an array, length = 1
    payload_dict_value_arr = payload_dict[b'payload']

    # Get data from the index[0] of the array payload_dict_value_arr
    data = payload_dict_value_arr[0]   

    # convert a string (representation of a Dict)) to a Dict
    # Note that if you have single quotes as a part of your keys or values this will
    # fail due to improper character replacement.
    # This solution is only recommended if you have a strong aversion 
    # to the eval solution.
    datajson = json.loads(data)

    # get value of key "channel"
    channel = datajson["channel"]
    print(channel) {'id': 'D01ACC2E8S3', 'name': 'directmessage'}

Moje rozwiązanie 2, trochę krótsze:

@ app.route('/slack/request_handler', methods=['POST'])
def request_handler():
   payload = request.form  # return an ImmutableMultiDict with 1 pair

   a1 = payload['payload']  # get value of key 'payload'

   # Note that if you have single quotes as a part of your keys or values this will
   # fail due to improper character replacement.
   # convert a string (representation of a Dict)) to a Dict
   a2 = json.loads(a1)

   # get value of key "channel"
   channel = a2["channel"] 
   print(channel) # {'id': 'D01ACC2E8S3', 'name': 'directmessage'}

Piersiówka.Prośba.get_data , Unicode in Flask

Wysyłając dane formularza za pomocą formularza HTML, upewnij się, że znaczniki input mają atrybuty name, w przeciwnym razie nie będą obecne w 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')])

Tylko wejście txt3 miało name, więc jest to jedyny klucz obecny w request.form.

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

request.data

Jest to świetne w użyciu, ale pamiętaj, że wchodzi jako ciąg znaków i będzie wymagał iteracji.