python - meaning - Cómo obtener los datos recibidos en la solicitud Frasco

flask wikipedia (14)

Doy un ejemplo completo de aplicación / json :

from flask import Flask, abort, request import json app = Flask(__name__) @app.route(''/foo'', methods=[''POST'']) def foo(): if not request.json: abort(400) print request.json return json.dumps(request.json) if __name__ == ''__main__'': app.run(host=''0.0.0.0'', port=5000, debug=True)

utilizar el Postman para la solicitud de correos:

usa el comando curl :

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

PS Para el ejemplo del parámetro Consulta de URL, puede ver mi respuesta en Múltiples parámetros en Aprobado del matraz

Quiero poder recibir los datos enviados a mi aplicación Flask. He intentado acceder a request.data pero es una cadena vacía. ¿Cómo accede a los datos de solicitud?

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

La respuesta a esta pregunta me llevó a preguntar a continuación Obtener el cuerpo POST sin procesar en Python Flask, independientemente del encabezado Content-Type , que trata de obtener los datos sin procesar en lugar de los datos analizados.

En pocas palabras, puede obtener datos de la siguiente manera:

@app.before_request def before_request(): g.data = request.get_json() or request.values

Ahora, g.data es una instancia de werkzeug.ImmutableMultiDict . Luego puede usar g.data que puede manejar la mayoría de sus requerimientos. Por ejemplo, puedes usarlo así:

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

Por supuesto, puedes usar el programa en lugar de la app ~~

Es simplemente como sigue

Para el parámetro de consulta de URL , use request.args

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

Para la entrada de formulario , use request.form

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

Para el tipo de datos application / json , use request.data

# data in string format and you have to parse into dictionary data = request.data dataDict = json.loads(data)

Flask tiene otro atajo para JSON:

Encabezamiento:

{Content-Type: application/json} @app.route("/something", methods=["POST"]) def do_something(): data = request.get_json()

Los docs describen los atributos disponibles en la solicitud. En la mayoría de los casos comunes, request.data estará vacío porque se utiliza como un recurso alternativo:

request.data Contiene los datos de la solicitud entrante como una cadena en caso de que venga con un mimetype que Flask no maneja.

request.args : los pares clave / valor en la cadena de consulta de URL
request.form : los pares clave / valor en el cuerpo, desde un formulario de publicación HTML, o una solicitud de JavaScript que no está codificada en JSON
request.files : los archivos en el cuerpo, que Flask mantiene separados de la form . Los formularios HTML deben usar enctype=multipart/form-data o los archivos no se cargarán.
request.values : args y form combinados, prefiriendo args si las claves se superponen

Todas estas son instancias de MultiDict . Puede acceder a los valores utilizando:

request.form[''name''] : use indexación si sabe que la clave existe
request.form.get(''name'') : use get si la clave no existe
request.form.getlist(''name'') : use getlist si la clave se envía varias veces y desea una lista de valores. get solo devuelve el primer valor.

Para aquellos como yo que se han olvidado (un poco) del HTML, asegúrese de que <input> en su <form> tenga un atributo name="" !

from flask import Flask, request app = Flask(__name__) @app.route(''/'', methods=[''GET'', ''POST'']) def index(): print("Posted data : {}".format(request.form)) return """ <form method="post"> <input type="text"> <input type="text" id="idtxt2"> <input type="text" name="txt3" id="idtxt3"> <input type="submit" Value="Hopla!"> </form> """ if __name__ == "__main__": app.run()

Resultado en la consola:

freezed@machine % python3 run.py * Serving Flask app "flaskstuff.views" (lazy loading) * Environment: production WARNING: Do not use the development server in a production environment. Use a production WSGI server instead. * Debug mode: on * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit) * Restarting with stat * Debugger is active! * Debugger PIN: 268-634-781 127.0.0.1 - - [20/Aug/2018 16:52:59] "POST / HTTP/1.1" 200 - Posted data : ImmutableMultiDict([(''txt3'', ''text 3'')])

Sin atributo de nombre = sin datos en ImmutableMultiDict([]) !

Si desea el cuerpo de la werkzeug.ImmutableMultiDict formato independientemente del tipo de contenido, debe usar request.get_data() , porque request.form se convierte a formato werkzeug.ImmutableMultiDict .

Si se reconoce el tipo mime, tanto request.data como request.get_data() devolverán cadenas vacías.

Para obtener el contenido completo independientemente, debe llamar a request.get_data(as_text=True) .

Ver http://flask.pocoo.org/docs/1.0/api/#flask.Request.get_data

Utilizando request.form .

En lugar de obtener datos de un solo formulario ( request.form["field_name"] ), puede obtener todos los datos publicados, analizando el ImmutableDict proporcionado por el objeto request.form , como este:

Frasco (Ruta)

@app.route(''/data'', methods=[''POST'']) def f_data(): if request.method == "POST": fields = [k for k in request.form] values = [request.form[k] for k in request.form] data = dict(zip(fields, values)) return jsonify(data)

Cáscara

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

Para más detalles, este Gist .

En javascript:

var value_data = [1,2,3,4]; $.ajax({ type: ''POST'', url: ''/'', data:JSON.stringify(value_data), success: function (response) { alert("Data added successfully"); }, });

En python:

client_data = request.get_data()

@app.route(''/'', methods=[''POST'']) def process_data(): req_data = request.get_json(force=True) # force=True will make sure this works even if a client does not specify application/json language = req_data[''language''] # or whatever key you have in your json return ''''''The language value is: {}''''''.format(language)

from flask import Flask, request, jsonify @app.route(''/added'', methods=[''POST'']) def add(): data = request.get_json(force=True) l = {''name'': data[''name'']} lingual.append(l) return jsonify({''lang'': lingual})

from flask import request request.data

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

Ahora, los datos son el cuerpo de la solicitud.