Cómo obtener los datos recibidos en la solicitud Frasco

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.

Los documentos describen los atributos disponibles en la solicitud. En la mayoría de los casos comunes, request.data estará vacío porque se usa 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.
 from flask import request request.data 

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) 

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 cartero para la solicitud de correos:

introduzca la descripción de la imagen aquí

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

Flask tiene otro atajo para JSON:

Encabezamiento:

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

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

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

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 progtwig en lugar de la app ~~

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 .

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

Ahora, los datos son el cuerpo de la solicitud.

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

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

Esto es una especie de truco sucio para obtener todos los datos de la solicitud independientemente de cómo se envió, pero en serio solo uso:

 def get_request_info(): args = str(request.args) form = str(request.form) files = str(request.files) maybe_json = request.get_json(silent=True, cache=False) if maybe_json: thejson = json.dumps(maybe_json) else: thejson = "no json" return # whatever you want 

y luego simplemente devuelvo una cadena que concatena esto o, si me parece elegante, me salto las llamadas de cadena / volcado json y fusiono todos los dictados. entonces esto se puede registrar, devolver en una función de vista, lo que sea y realmente puede ver la solicitud completa sin importar lo que incluya.

 from flask import request content = request.get_json() name = content.get('name', '') 

obtenga datos si solicita el tipo json y también puede mencionar los parámetros predeterminados junto con ellos

 from flask import request content = request.form name = content.get('name', '') 

obtener datos si el formulario de solicitud de formulario

 from flask import request request.args.get("name", "") 

para obtener parámetros de url con una solicitud GET

Para aquellos como yo que se han olvidado (un poco) del HTML, asegúrese de que en su

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 """ 
""" 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([]) !

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