One place for hosting & domains

      So bearbeiten Sie eingehende Anfragedaten in Flask


      Einführung

      Webanwendungen erfordern häufig die Verarbeitung eingehender Anforderungsdaten von Benutzern. Diese Nutzdaten können in Form von Abfragezeichenfolgen, Formulardaten und JSON-Objekten vorliegen. Mit Flask können Sie wie mit jedem anderen Webframework auf die Anforderungsdaten zugreifen.

      In diesem Tutorial erstellen Sie eine Flask-Anwendung mit drei Routen, die entweder Abfragezeichenfolgen, Formulardaten oder JSON-Objekte akzeptieren.

      Voraussetzungen

      Um diesem Tutorial zu folgen, benötigen Sie:

      • Dieses Projekt erfordert die Installation von Python in einer lokalen Umgebung.
      • In diesem Projekt wird Pipenv verwendet, ein produktionsfähiges Tool, mit dem das Beste aus allen Verpackungswelten in die Python-Welt gebracht werden soll. Es nutzt Pipfile, pip und virtualenv in einem einzigen Befehl.
      • Das Herunterladen und Installieren eines Tools wie Postman wird benötigt, um API-Endpunkte zu testen.

      Dieses Tutorial wurde mit Pipenv v2020.11.15, Python v3.9.0 und Flask v1.1.2 verifiziert.

      Einrichten des Projekts

      Um die verschiedenen Verwendungsmöglichkeiten von Anforderungen zu demonstrieren, müssen Sie eine Flask-App erstellen. Obwohl die Beispiel-App eine vereinfachte Struktur für die Ansichtsfunktionen und -routen verwendet, kann das, was Sie in diesem Tutorial lernen, auf jede Methode zum Organisieren Ihrer Ansichten angewendet werden, z. B. auf klassenbasierte Ansichten, Blaupausen oder eine Erweiterung wie Flask-Via.

      Zuerst müssen Sie ein Projektverzeichnis erstellen. Öffnen Sie Ihren Terminal und führen Sie folgenden Befehl aus:

      • mkdir flask_request_example

      Navigieren Sie dann zum neuen Verzeichnis:

      Installieren Sie als nächstes Flask. Öffnen Sie Ihren Terminal und führen Sie folgenden Befehl aus:

      Der Befehl pipenv erstellt eine virtuelle Umgebung für dieses Projekt, eine Pipfile, eine Installations-flask und eine Pipfile.lock.

      Führen Sie den folgenden Befehl aus, um virtualenv des Projekts zu aktivieren:

      Um auf die eingehenden Daten in Flask zuzugreifen, müssen Sie das Anforderungsobjekt verwenden. Das Anforderungsobjekt enthält alle eingehenden Daten aus der Anforderung, einschließlich Mimetyp, Referrer, IP-Adresse, Rohdaten, HTTP-Methode und Überschriften.

      Obwohl alle Informationen, die das Anforderungsobjekt enthält, nützlich sein können, konzentrieren Sie sich für die Zwecke dieses Artikels auf die Daten, die normalerweise direkt vom Aufrufer des Endpunkts bereitgestellt werden.

      Um Zugriff auf das Anforderungsobjekt in Flask zu erhalten, müssen Sie es aus der Flask-Bibliothek importieren:

      from flask import request
      

      Sie können es dann in jeder Ihrer Ansichtsfunktionen verwenden.

      Verwenden Sie Ihren Code-Editor, um eine Datei app.py zu erstellen. Importieren Sie Flask und das Anforderungsobjekt. Und erstellen Sie auch Routen für query-example, form-example und json-example:

      app.py

      # import main Flask class and request object
      from flask import Flask, request
      
      # create the Flask app
      app = Flask(__name__)
      
      @app.route('/query-example')
      def query_example():
          return 'Query String Example'
      
      @app.route('/form-example')
      def form_example():
          return 'Form Data Example'
      
      @app.route('/json-example')
      def json_example():
          return 'JSON Object Example'
      
      if __name__ == '__main__':
          # run app in debug mode on port 5000
          app.run(debug=True, port=5000)
      

      Öffnen Sie als nächstes Ihr Terminal und starten Sie die App mit dem folgenden Befehl:

      Die App wird auf Port 5000 gestartet, sodass Sie jede Route in Ihrem Browser über die folgenden Links anzeigen können:

      http://127.0.0.1:5000/query-example (or localhost:5000/query-example)
      http://127.0.0.1:5000/form-example (or localhost:5000/form-example)
      http://127.0.0.1:5000/json-example (or localhost:5000/json-example)
      

      Der Code erstellt drei Routen und zeigt die Nachrichten „Beispiel für Abfragezeichenfolge“,„Beispiel für Formulardaten“ bzw. „Beispiel für JSON-Objekt“ an.

      Verwenden von Abfrageargumenten

      URL-Argumente, die Sie einer Abfragezeichenfolge hinzufügen, sind eine übliche Methode, um Daten an eine Webanwendung zu übergeben. Beim Surfen im Internet sind Sie wahrscheinlich schon einmal auf eine Abfragezeichenfolge gestoßen.

      Eine Abfragezeichenfolge ähnelt der folgenden:

      example.com?arg1=value1&arg2=value2
      

      Die Abfragezeichenfolge beginnt nach dem Fragezeichen (?) Zeichen:

      example.com?arg1=value1&arg2=value2
      

      Und hat Schlüssel-Wert-Paare, die durch ein kaufmännisches Und (&) getrennt sind:

      example.com?arg1=value1&arg2=value2
      

      Für jedes Paar folgt auf den Schlüssel ein Gleichheitszeichen (=) und dann der Wert.

      arg1 : value1
      arg2 : value2
      

      Abfragezeichenfolgen sind nützlich, um Daten zu übergeben, für die der Benutzer keine Maßnahmen ergreifen muss. Sie können irgendwo in Ihrer App eine Abfragezeichenfolge generieren und an eine URL anhängen. Wenn ein Benutzer eine Anfrage stellt, werden die Daten automatisch für ihn übergeben. Eine Abfragezeichenfolge kann auch von Formularen generiert werden, deren Methode GET ist.

      Fügen wir der Abfragebeispielroute eine Abfragezeichenfolge hinzu. In diesem hypothetischen Beispiel geben Sie den Namen einer Programmiersprache an, die auf dem Bildschirm angezeigt wird. Erstellen Sie einen Schlüssel für „Sprache“ und einen Wert für „Python“:

      http://127.0.0.1:5000/query-example?language=Python
      

      Wenn Sie die App ausführen und zu dieser URL navigieren, wird weiterhin die Meldung „Beispiel für eine Abfragezeichenfolge“ angezeigt.

      Sie müssen den Teil programmieren, der die Abfrageargumente verarbeitet. Dieser Code liest den Schlüssel Sprache durch Verwendung von request.args.get('language') oder request.args.get('language').

      Durch den Aufruf von request.args.get('language') wird die Anwendung weiterhin ausgeführt, wenn der Schlüssel Sprache nicht in der URL vorhanden ist. In diesem Fall ist das Ergebnis der Methode Keine.

      Durch den Aufruf von request.args['language'] gibt die App einen 400-Fehler zurück, wenn der Schlüssel Sprache nicht in der URL vorhanden ist.

      Beim Umgang mit Abfragezeichenfolgen wird empfohlen, request.args.get () zu verwenden, um zu verhindern, dass die App fehlschlägt.

      Lesen wir den Schlüssel Sprache und zeigen ihn als Ausgabe an.

      Ändern Sie die Route query-example in app.py mit dem folgenden Code:

      app.py

      @app.route('/query-example')
      def query_example():
          # if key doesn't exist, returns None
          language = request.args.get('language')
      
          return '''<h1>The language value is: {}</h1>'''.format(language)
      

      Führen Sie dann die App aus und navigieren Sie zur URL:

      http://127.0.0.1:5000/query-example?language=Python
      

      Der Browser sollte die folgende Nachricht anzeigen:

      Output

      The language value is: Python

      Das Argument aus der URL wird der Variable Sprache zugewiesen und dann an den Browser zurückgegeben.

      Um weitere Parameter für Abfragezeichenfolgen hinzuzufügen, können Sie ein kaufmännisches Und und die neuen Schlüssel-Wert-Paare an das Ende der URL anhängen. Erstellen Sie einen Schlüssel für „Framework“ und einen Wert für „Flask“:

      http://127.0.0.1:5000/query-example?language=Python&framework=Flask
      

      Wenn Sie mehr möchten, fügen Sie weiterhin ein kaufmännisches Und und Schlüssel-Wert-Paare hinzu. Erstellen Sie einen Schlüssel für „Framework“ und einen Wert für „Flask“:

      http://127.0.0.1:5000/query-example?language=Python&framework=Flask&website=DigitalOcean
      

      Um Zugriff auf diese Werte zu erhalten, verwenden Sie weiterhin entweder request.args.get() oder request.args[]. Verwenden wir beide, um zu demonstrieren, was passiert, wenn ein Schlüssel fehlt. Ändern Sie die Route query_example, um den Wert der Ergebnisse in Variablen zu zuweisen und sie dann anzuzeigen:

      @app.route('/query-example')
      def query_example():
          # if key doesn't exist, returns None
          language = request.args.get('language')
      
          # if key doesn't exist, returns a 400, bad request error
          framework = request.args['framework']
      
          # if key doesn't exist, returns None
          website = request.args.get('website')
      
          return '''
                    <h1>The language value is: {}</h1>
                    <h1>The framework value is: {}</h1>
                    <h1>The website value is: {}'''.format(language, framework, website)
      

      Führen Sie dann die App aus und navigieren Sie zur URL:

      http://127.0.0.1:5000/query-example?language=Python&framework=Flask&website=DigitalOcean
      

      Der Browser sollte die folgende Nachricht anzeigen:

      Output

      The language value is: Python The framework value is: Flask The website value is: DigitalOcean

      Entfernen Sie den Schlüssel Sprache aus der URL:

      http://127.0.0.1:5000/query-example?framework=Flask&website=DigitalOcean
      

      Der Browser sollte die folgende Nachricht mit Keine anzeigen, wenn ein Wert nicht für Sprache bereitgestellt wird:

      Output

      The language value is: None The framework value is: Flask The website value is: DigitalOcean

      Entfernen Sie den Schlüssel Framework aus der URL:

      http://127.0.0.1:5000/query-example?language=Python&website=DigitalOcean
      

      Der Browser sollte auf einen Fehler stoßen, da er einen Wert für Framework erwartet:

      Output

      werkzeug.exceptions.BadRequestKeyError werkzeug.exceptions.BadRequestKeyError: 400 Bad Request: The browser (or proxy) sent a request that this server could not understand. KeyError: 'framework'

      Jetzt verstehen Sie den Umgang mit Abfragezeichenfolgen. Fahren wir mit dem nächsten Typ eingehender Daten fort.

      Verwenden von Formulardaten

      Formulardaten stammen aus einem Formular, das als POST-Abfrage an eine Route gesendet wurde. Anstatt die Daten in der URL anzuzeigen (außer in Fällen, in denen das Formular mit einer GET-Abfrage gesendet wird), werden die Formulardaten hinter den Kulissen an die App übergeben. Obwohl Sie die Formulardaten nicht einfach sehen können, die übergeben werden, kann Ihre App sie weiterhin lesen.

      Um dies zu demonstrieren, ändern Sie die Formularbeispielroute in app.py, um sowohl GET- als auch POST-Abfragen zu akzeptieren, und geben Sie ein Formular zurück:

      app.py

      # allow both GET and POST requests
      @app.route('/form-example', methods=['GET', 'POST'])
      def form_example():
          return '''
                    <form method="POST">
                        <div><label>Language: <input type="text" name="language"></label></div>
                        <div><label>Framework: <input type="text" name="framework"></label></div>
                        <input type="submit" value="Submit">
                    </form>'''
      

      Führen Sie dann die App aus und navigieren Sie zur URL:

      http://127.0.0.1:5000/form-example
      

      Der Browser sollte ein Formular mit zwei Eingabefeldern - einem für Sprache und einem für Framework - und eine Senden-Taste übergeben.

      Das Wichtigste, was Sie über dieses Formular wissen müssen, ist, dass es eine POST-Abfrage an dieselbe Route ausführt, die das Formular generiert hat. Die Schlüssel, die in der App gelesen werden, stammen alle aus den Namensattributen in unseren Formulareingaben. In diesem Fall sind Sprache und Framework die Namen der Eingaben, sodass Sie Zugriff auf die in der App haben.

      Innerhalb der Ansichtsfunktion müssen Sie überprüfen, ob die Abfragemethode GET oder POST ist. Wenn es sich um eine GET-Abfrage handelt, können Sie das Formular anzeigen. Wenn es sich um eine POST-Abfrage handelt, möchten Sie die eingehenden Daten verarbeiten.

      Ändern Sie die Route form-example in app.py mit dem folgenden Code:

      app.py

      # allow both GET and POST requests
      @app.route('/form-example', methods=['GET', 'POST'])
      def form_example():
          # handle the POST request
          if request.method == 'POST':
              language = request.form.get('language')
              framework = request.form.get('framework')
              return '''
                        <h1>The language value is: {}</h1>
                        <h1>The framework value is: {}</h1>'''.format(language, framework)
      
          # otherwise handle the GET request
          return '''
                 <form method="POST">
                     <div><label>Language: <input type="text" name="language"></label></div>
                     <div><label>Framework: <input type="text" name="framework"></label></div>
                     <input type="submit" value="Submit">
                 </form>'''
      

      Führen Sie dann die App aus und navigieren Sie zur URL:

      http://127.0.0.1:5000/form-example
      

      Füllen Sie das Feld Sprache mit dem Wert von Python und das Feld Framework mit dem Wert von Flask aus. Drücken Sie dann Senden.

      Der Browser sollte die folgende Nachricht anzeigen:

      Output

      The language value is: Python The framework value is: Flask

      Jetzt verstehen Sie den Umgang mit Formulardaten. Fahren wir mit dem nächsten Typ eingehender Daten fort.

      Verwenden von JSON-Daten

      JSON-Daten werden normalerweise von einem Prozess erstellt, der die Route aufruft.

      Ein Beispiel-JSON-Objekt sieht folgendermaßen aus:

      {
        "language": "Python",
        "framework": "Flask",
        "website": "Scotch",
        "version_info": {
          "python": "3.9.0",
          "flask": "1.1.2"
        },
        "examples": ["query", "form", "json"],
        "boolean_test": true
      }
      

      Diese Struktur kann die Übergabe von viel komplizierteren Daten im Gegensatz zu Abfragezeichenfolgen und Formulardaten ermöglichen. Im Beispiel sehen Sie verschachtelte JSON-Objekte und eine Anordnung von Elementen. Flask kann dieses Format von Daten verarbeiten.

      Ändern Sie die Route form-example in app.py, um POST-Abfragen zu akzeptieren und andere Abfragen wie GET zu ignorieren:

      app.py

      @app.route('/json-example', methods=['POST'])
      def json_example():
          return 'JSON Object Example'
      

      Im Gegensatz zu dem Webbrowser, der für Abfragezeichenfolgen und Formulardaten zum Senden eines JSON-Objekts in diesem Artikel verwendet wird, verwenden Sie Postman, um benutzerdefinierte Anforderungen an URLs zu senden.

      Hinweis: Wenn Sie Hilfe benötigen, um Postman für Abfragen zu navigieren, konsultieren Sie die offizielle Dokumentation.

      Fügen Sie in Postman die URL hinzu und ändern Sie den Typ in POST. Wechseln Sie auf der Registerkarte Body zu raw und wählen Sie JSON aus der Dropdown-Liste aus.

      Diese Einstellungen sind erforderlich, sodass Postman JSON-Daten richtig senden kann und Ihre Flask-App versteht, dass sie JSON empfängt:

      POST http://127.0.0.1:5000/json-example
      Body
      raw JSON
      

      Kopieren Sie als Nächstes das frühere JSON-Beispiel in die Texteingabe.

      Senden Sie die Abfrage und Sie sollten „Beispiel eines JSON-Objekts“ als Antwort erhalten. Das ist ziemlich antiklimatisch, aber zu erwarten, da der Code für die Verarbeitung der JSON-Datenantwort noch nicht geschrieben wurde.

      Um die Daten zu lesen, müssen Sie verstehen, wie Flask JSON-Daten in Python-Datenstrukturen übersetzt:

      • Alles, was ein Objekt ist, wird in ein Python-Diktat konvertiert. {"key": value "} in JSON entspricht somedict['key'], das in Python einen Wert zurückgibt.
      • Eine Anordnung in JSON wird in Python in eine Liste konvertiert. Da die Syntax die gleiche ist, ist hier eine Beispielliste: [1,2,3,4,5]
      • Die Werte in Anführungszeichen im JSON-Objekt werden Zeichenfolgen in Python.
      • Boolean wahr und falsch werden in Python zu Wahr und Falsch.
      • Abschließend werden Zahlen ohne Anführungszeichen in Python zu Zahlen.

      Arbeiten wir nun an dem Code, um die eingehenden JSON-Daten zu lesen.

      Zuerst weisen wir alles aus dem JSON-Objekt mit request.get_json() einer Variable zu.

      request.get_json() konvertiert das JSON-Objekt in Python-Daten. Weisen wir die eingehenden Abfragedaten den Variablen zu, und geben sie zurück, indem wir die folgenden Änderungen an der Route json-example vornehmen:

      app.py

      # GET requests will be blocked
      @app.route('/json-example', methods=['POST'])
      def json_example():
          request_data = request.get_json()
      
          language = request_data['language']
          framework = request_data['framework']
      
          # two keys are needed because of the nested object
          python_version = request_data['version_info']['python']
      
          # an index is needed because of the array
          example = request_data['examples'][0]
      
          boolean_test = request_data['boolean_test']
      
          return '''
                 The language value is: {}
                 The framework value is: {}
                 The Python version is: {}
                 The item at index 0 in the example list is: {}
                 The boolean value is: {}'''.format(language, framework, python_version, example, boolean_test)
      

      Beachten Sie, wie Sie auf Elemente zugreifen, die nicht auf der oberen Ebene sind. ['version']['python'] wird verwendet, da Sie ein verschachteltes Objekt eingeben. Und ['examples'][0] wird verwendet, um auf den 0. Index in der Anordnung der Beispiele zuzugreifen.

      Wenn das mit der Abfrage gesendete JSON-Objekt keinen Schlüssel hat, auf den in Ihrer Ansichtsfunktion zugegriffen wird, wird die Abfrage fehlschlagen. Wenn Sie nicht möchten, dass es fehlschlägt, wenn ein Schlüssel nicht vorhanden ist, müssen Sie überprüfen, ob der Schlüssel vorhanden ist, bevor Sie versuchen, darauf zuzugreifen.

      app.py

      # GET requests will be blocked
      @app.route('/json-example', methods=['POST'])
      def json_example():
          request_data = request.get_json()
      
          language = None
          framework = None
          python_version = None
          example = None
          boolean_test = None
      
          if request_data:
              if 'language' in request_data:
                  language = request_data['language']
      
              if 'framework' in request_data:
                  framework = request_data['framework']
      
              if 'version_info' in request_data:
                  if 'python' in request_data['version_info']:
                      python_version = request_data['version_info']['python']
      
              if 'examples' in request_data:
                  if (type(request_data['examples']) == list) and (len(request_data['examples']) > 0):
                      example = request_data['examples'][0]
      
              if 'boolean_test' in request_data:
                  boolean_test = request_data['boolean_test']
      
          return '''
                 The language value is: {}
                 The framework value is: {}
                 The Python version is: {}
                 The item at index 0 in the example list is: {}
                 The boolean value is: {}'''.format(language, framework, python_version, example, boolean_test)
      

      Führen Sie die App aus und senden Sie die Beispiel-JSON-Abfrage mit Postman. In der Antwort erhalten Sie die folgende Ausgabe:

      Output

      The language value is: Python The framework value is: Flask The Python version is: 3.9 The item at index 0 in the example list is: query The boolean value is: false

      Jetzt verstehen Sie die Verarbeitung von JSON-Objekten.

      Zusammenfassung

      In diesem Artikel haben Sie eine Flask-Anwendung mit drei Routen erstellt, die entweder Abfragezeichenfolgen, Formulardaten oder JSON-Objekte akzeptieren.

      Denken Sie auch daran, dass alle Ansätze die wiederkehrende Überlegung berücksichtigen mussten, ob ein Schlüssel ordnungsgemäß fehlschlägt, wenn ein Schlüssel fehlt.

      Warnung: ein Thema, das in diesem Artikel nicht behandelt wurde, war die Bereinigung von Benutzereingaben. Durch die Bereinigung von Benutzereingaben wird sichergestellt, dass von der Anwendung gelesene Daten nicht unerwartet fehlschlagen oder Sicherheitsmaßnahmen umgehen.

      Wenn Sie mehr über Flask erfahren möchten, lesen Sie unsere Themenseite zu Flask für Übungen und Programmierprojekte.



      Source link

      Cómo procesar los datos de solicitud entrantes en Flask


      Introducción

      Las aplicaciones web requieren con frecuencia el procesamiento de los datos de las solicitudes entrantes de los usuarios. Esta carga útil puede tener la forma de cadenas de consulta, datos de formulario y objetos JSON. Flask, como cualquier otro marco web, le permite acceder a los datos de la solicitud.

      En este tutorial, se creará una aplicación Flask con tres rutas que aceptan cadenas de consulta, datos de formulario u objetos JSON.

      Requisitos previos

      Para completar este tutorial, necesitará lo siguiente:

      • Este proyecto requerirá que Python se instale en un entorno local.
      • Este proyecto usará Pipenv, una herramienta preparada para la producción que pretende traer lo mejor de todos los mundos de empaquetado al mundo de Python. Aprovecha Pipfile, pip, y virtualenv en un solo comando.
      • Se requerirá descargar e instalar una herramienta como Postman para probar los puntos finales de API.

      Este tutorial se verificó con Pipenv v2020.11.15, Python v3.9.0 y Flask v1.1.2.

      Configuración del proyecto

      Para demostrar las diferentes formas de usar solicitudes, deberá crear una aplicación Flask. Aunque la aplicación de ejemplo utiliza una estructura simplificada para las funciones y las rutas de vista, lo que se aprende en este tutorial puede aplicarse a cualquier método de organización de las vistas, como las vistas basadas en clases, los planos o una extensión como Flask-Via.

      Primero, deberá crear un directorio de proyecto. Abra su terminal y ejecute el siguiente comando:

      • mkdir flask_request_example

      Luego, diríjase al nuevo directorio:

      Luego, instale Flask. Abra su terminal y ejecute el siguiente comando:

      El comando pipenv creará un virtualenv para este proyecto, un Pipfile, para instalar flask y un Pipfile.lock.

      Para activar el virtualenv del proyecto, ejecute el siguiente comando:

      Para acceder a los datos entrantes en Flask, tiene que usar el objeto request. El objeto request contiene todos los datos entrantes de la solicitud, que incluye el mimetype, recomendante, dirección IP, datos sin procesar, HTTP y encabezados, entre otras cosas.

      Aunque toda la información que contiene el objeto de solicitud puede ser útil, para los propósitos de este artículo, se centrará en los datos que normalmente son suministrados directamente por la persona que llama al punto final.

      Para obtener acceso al objeto de solicitud en Flask, deberá importarlo desde la biblioteca Flask:

      from flask import request
      

      Luego, podrá usarlo en cualquiera de sus funciones de vista.

      Utilice su editor de código para crear un archivo app.py. Importe Flask y el objeto request. Y también establezca rutas para query-example, form-example, y json-example:

      app.py

      # import main Flask class and request object
      from flask import Flask, request
      
      # create the Flask app
      app = Flask(__name__)
      
      @app.route('/query-example')
      def query_example():
          return 'Query String Example'
      
      @app.route('/form-example')
      def form_example():
          return 'Form Data Example'
      
      @app.route('/json-example')
      def json_example():
          return 'JSON Object Example'
      
      if __name__ == '__main__':
          # run app in debug mode on port 5000
          app.run(debug=True, port=5000)
      

      Luego, abra su terminal e inicie la aplicación con el siguiente comando:

      La aplicación se iniciará en el puerto 5000, por lo que puede ver cada ruta en su navegador con los siguientes enlaces:

      http://127.0.0.1:5000/query-example (or localhost:5000/query-example)
      http://127.0.0.1:5000/form-example (or localhost:5000/form-example)
      http://127.0.0.1:5000/json-example (or localhost:5000/json-example)
      

      El código establece tres rutas y visitar cada una de ellas mostrará los mensajes de "Query String Example", "Form Data Example" y "JSON Object Example", respectivamente.

      Uso de argumentos Query

      Los argumentos de URL que se añaden a una cadena de consulta son una forma común de pasar los datos a una aplicación web. Al navegar por la web, es probable que haya encontrado alguna vez una cadena de consulta.

      Una cadena de consulta se parece a lo siguiente:

      example.com?arg1=value1&arg2=value2
      

      La cadena de consulta comienza después del carácter de signo de interrogación (?) :

      example.com?arg1=value1&arg2=value2
      

      Y tiene pares clave-valor separados por un carácter de “y” comercial (&):

      example.com?arg1=value1&arg2=value2
      

      Para cada par, la clave va seguida por un signo de igualdad (=) y, a continuación, el valor.

      arg1 : value1
      arg2 : value2
      

      Las cadenas de consulta son útiles para pasar datos que no requieren que el usuario realice ninguna acción. Puede generar una cadena de consulta en algún lugar de su aplicación y añadirla a una URL para que cuando un usuario realice una solicitud, los datos se pasen automáticamente para ellos. Una cadena de consulta también puede generarse a través de formularios que tienen GET como método.

      Vamos a añadir una cadena de consulta a la ruta query-example. En este ejemplo hipotético, se proporcionará el nombre de un lenguaje de programación que se mostrará en la pantalla. Cree una clave de "language" y un valor de "Python":

      http://127.0.0.1:5000/query-example?language=Python
      

      Si ejecuta la aplicación y navega a esa URL, verá que sigue mostrando un mensaje de "Query String Example".

      Tendrá que programar la parte que maneja los argumentos de la consulta. Este código leerá la clave de language usando request.args.get('language') o request.args['language'].

      Al invocar request.args.get('language'), la aplicación continuará ejecutándose si la clave de language no existe en la URL. En ese caso, el resultado del método será None.

      Al invocar request.args['language'], la aplicación mostrará un error 400 si la clave de language no existe en la URL.

      Cuando se trata de cadenas de consulta, se recomienda usar request.args.get() para evitar que la aplicación falle.

      Vamos a leer la clave language y mostrarla como resultado.

      Modifique la ruta query-example en app.py con el siguiente código:

      app.py

      @app.route('/query-example')
      def query_example():
          # if key doesn't exist, returns None
          language = request.args.get('language')
      
          return '''<h1>The language value is: {}</h1>'''.format(language)
      

      Luego, ejecute la aplicación y diríjase a la URL:

      http://127.0.0.1:5000/query-example?language=Python
      

      El navegador debe mostrar el siguiente mensaje:

      Output

      The language value is: Python

      El argumento de la URL se asigna a la variable language y luego se devuelve al navegador.

      Para añadir más parámetros de cadena de consulta, puede añadir ampersands y los nuevos pares clave-valor al final de la URL. Cree una clave de "framework" y un valor de "Flask":

      http://127.0.0.1:5000/query-example?language=Python&framework=Flask
      

      Y si desea más, continúe añadiendo ampersands y pares clave-valor. Cree una clave de "website" y un valor de "DigitalOcean":

      http://127.0.0.1:5000/query-example?language=Python&framework=Flask&website=DigitalOcean
      

      Para obtener acceso a esos valores, seguirá usando request.args.get() o request.args[]. Vamos a usar ambos para demostrar lo que sucede cuando falta una clave. Modifique la ruta query_example para asignar el valor de los resultados a variables y luego mostrarlos:

      @app.route('/query-example')
      def query_example():
          # if key doesn't exist, returns None
          language = request.args.get('language')
      
          # if key doesn't exist, returns a 400, bad request error
          framework = request.args['framework']
      
          # if key doesn't exist, returns None
          website = request.args.get('website')
      
          return '''
                    <h1>The language value is: {}</h1>
                    <h1>The framework value is: {}</h1>
                    <h1>The website value is: {}'''.format(language, framework, website)
      

      Luego, ejecute la aplicación y diríjase a la URL:

      http://127.0.0.1:5000/query-example?language=Python&framework=Flask&website=DigitalOcean
      

      El navegador debe mostrar el siguiente mensaje:

      Output

      The language value is: Python The framework value is: Flask The website value is: DigitalOcean

      Elimine la clave de language de la URL:

      http://127.0.0.1:5000/query-example?framework=Flask&website=DigitalOcean
      

      El navegador debe mostrar el siguiente mensaje con None cuando no se proporciona un valor para language:

      Output

      The language value is: None The framework value is: Flask The website value is: DigitalOcean

      Elimine la clave de framework de la URL:

      http://127.0.0.1:5000/query-example?language=Python&website=DigitalOcean
      

      El navegador debería encontrar un error porque está esperando un valor para framework:

      Output

      werkzeug.exceptions.BadRequestKeyError werkzeug.exceptions.BadRequestKeyError: 400 Bad Request: The browser (or proxy) sent a request that this server could not understand. KeyError: 'framework'

      Ahora, ya comprende cómo se manejan las cadenas de consulta. Continuemos con el siguiente tipo de datos entrantes.

      Uso de datos de formulario

      Los datos de formulario provienen de un formulario que ha sido enviado como solicitud POST a una ruta. Por lo tanto, en lugar de ver los datos en la URL (excepto en los casos en que el formulario se envía con una solicitud GET), los datos del formulario pasarán a la aplicación entre bastidores. Aunque no se pueden ver fácilmente los datos del formulario que se pasan, su aplicación puede leerlos.

      Para demostrarlo, modifique la ruta de form-example en app.py para aceptar las solicitudes GET y POST, y devolver un formulario:

      app.py

      # allow both GET and POST requests
      @app.route('/form-example', methods=['GET', 'POST'])
      def form_example():
          return '''
                    <form method="POST">
                        <div><label>Language: <input type="text" name="language"></label></div>
                        <div><label>Framework: <input type="text" name="framework"></label></div>
                        <input type="submit" value="Submit">
                    </form>'''
      

      Luego, ejecute la aplicación y diríjase a la URL:

      http://127.0.0.1:5000/form-example
      

      El navegador debe mostrar un formulario con dos campos de entrada, uno para language y otro para framework, así como para un botón de envío.

      Lo más importante que hay que saber sobre este formulario es que realiza una solicitud POST a la misma ruta que generó el formulario. Las claves que se leerán en la aplicación provienen de los atributos de nombre de las entradas de nuestro formulario. En este caso, language y framework son los nombres de las entradas, por lo que tendrá acceso a ellos en la aplicación.

      Dentro de la función de vista, deberá verificar si el método de solicitud es GET o POST. Si es una solicitud GET, puede mostrar el formulario. De lo contrario, si se trata de una solicitud POST, entonces querrá procesar los datos entrantes.

      Modifique la ruta de form-example en app.py con el siguiente código:

      app.py

      # allow both GET and POST requests
      @app.route('/form-example', methods=['GET', 'POST'])
      def form_example():
          # handle the POST request
          if request.method == 'POST':
              language = request.form.get('language')
              framework = request.form.get('framework')
              return '''
                        <h1>The language value is: {}</h1>
                        <h1>The framework value is: {}</h1>'''.format(language, framework)
      
          # otherwise handle the GET request
          return '''
                 <form method="POST">
                     <div><label>Language: <input type="text" name="language"></label></div>
                     <div><label>Framework: <input type="text" name="framework"></label></div>
                     <input type="submit" value="Submit">
                 </form>'''
      

      Luego, ejecute la aplicación y diríjase a la URL:

      http://127.0.0.1:5000/form-example
      

      Complete el campo de language con el valor de Python y el campo de framework con el valor de Flask. Luego, presione Submit (Enviar).

      El navegador debe mostrar el siguiente mensaje:

      Output

      The language value is: Python The framework value is: Flask

      Ahora, entiende cómo manejar los datos del formulario. Continuaremos con el siguiente tipo de datos entrantes.

      Uso de datos JSON

      Los datos JSON generalmente se construye a través de un proceso que invoca la ruta.

      Un ejemplo de objeto JSON tiene el siguiente aspecto:

      {
        "language": "Python",
        "framework": "Flask",
        "website": "Scotch",
        "version_info": {
          "python": "3.9.0",
          "flask": "1.1.2"
        },
        "examples": ["query", "form", "json"],
        "boolean_test": true
      }
      

      Esta estructura puede permitir que se pasen datos mucho más complicados en lugar de las cadenas de consulta y los datos del formulario. En el ejemplo, se ve los objetos JSON anidados y una matriz de elementos. Flask puede gestionar este formato de datos.

      Modifique la ruta de form-example en app.py para aceptar las solicitudes POST e ignore otras solicitudes como GET:

      app.py

      @app.route('/json-example', methods=['POST'])
      def json_example():
          return 'JSON Object Example'
      

      A diferencia del navegador web que se utiliza para las cadenas de consulta y los datos de formulario, para los fines de este artículo, para enviar un objeto JSON, se utilizará Postman para enviar solicitudes personalizadas a las URL.

      Nota: Si necesita ayuda para navegar por la interfaz de Postman para las solicitudes, consulte la documentación oficial.

      En Postman, añada la URL y cambie el tipo a POST. En la pestaña de cuerpo, cambie a raw y seleccione JSON en el menú desplegable.

      Estos ajustes son necesarios para que Postman pueda enviar datos JSON correctamente, y para que su aplicación Flask comprenda que está recibiendo JSON:

      POST http://127.0.0.1:5000/json-example
      Body
      raw JSON
      

      Luego, copie el ejemplo JSON anterior en la entrada de texto.

      Envíe la solicitud y debería obtener "JSON Object Example" como respuesta. Eso es bastante decepcionante, pero es de esperar porque el código para gestionar la respuesta de los datos JSON aún no se ha escrito.

      Para leer los datos, debe entender cómo Flask traduce los datos JSON en las estructuras de datos de Python:

      • Cualquier cosa que sea un objeto se convierte en una dictadura de Python. {"key" : "value"} en JSON corresponde a somedict['key'], que devuelve un valor en Python.
      • Una matriz en JSON se convierte en una lista en Python. Dado que la sintaxis es la misma, aquí hay un ejemplo de una lista: [1,2,3,4,5].
      • Los valores dentro de las comillas en el objeto JSON se convierten en cadenas en Python.
      • Los booleanos true y false se convierten en True y False en Python.
      • Por último, los números sin comillas se convierten en números en Python.

      Ahora vamos a trabajar en el código para leer los datos JSON entrantes.

      Primero, vamos a asignar todo desde el objeto JSON a una variable usando request.get_json().

      request.get_json() convierte el objeto JSON en datos de Python. Asignemos los datos de la solicitud entrante a las variables y devolvámoslos haciendo los siguientes cambios en la ruta json-example:

      app.py

      # GET requests will be blocked
      @app.route('/json-example', methods=['POST'])
      def json_example():
          request_data = request.get_json()
      
          language = request_data['language']
          framework = request_data['framework']
      
          # two keys are needed because of the nested object
          python_version = request_data['version_info']['python']
      
          # an index is needed because of the array
          example = request_data['examples'][0]
      
          boolean_test = request_data['boolean_test']
      
          return '''
                 The language value is: {}
                 The framework value is: {}
                 The Python version is: {}
                 The item at index 0 in the example list is: {}
                 The boolean value is: {}'''.format(language, framework, python_version, example, boolean_test)
      

      Tenga en cuenta cómo se accede a los elementos que no están en el nivel superior. Se utiliza ['version']['python'] porque se está entrando en un objeto anidado. Y ['examples'][0] se utiliza para acceder al índice 0 en la matriz de ejemplos.

      Si el objeto JSON enviado con la solicitud no tiene una clave a la que se accede en su función de vista, entonces la solicitud fallará. Si no quiere que la solicitud falle cuando no existe una clave, tendrá que verificar si la clave existe antes de intentar ingresarla.

      app.py

      # GET requests will be blocked
      @app.route('/json-example', methods=['POST'])
      def json_example():
          request_data = request.get_json()
      
          language = None
          framework = None
          python_version = None
          example = None
          boolean_test = None
      
          if request_data:
              if 'language' in request_data:
                  language = request_data['language']
      
              if 'framework' in request_data:
                  framework = request_data['framework']
      
              if 'version_info' in request_data:
                  if 'python' in request_data['version_info']:
                      python_version = request_data['version_info']['python']
      
              if 'examples' in request_data:
                  if (type(request_data['examples']) == list) and (len(request_data['examples']) > 0):
                      example = request_data['examples'][0]
      
              if 'boolean_test' in request_data:
                  boolean_test = request_data['boolean_test']
      
          return '''
                 The language value is: {}
                 The framework value is: {}
                 The Python version is: {}
                 The item at index 0 in the example list is: {}
                 The boolean value is: {}'''.format(language, framework, python_version, example, boolean_test)
      

      Ejecute la aplicación y envíe la solicitud JSON de ejemplo usando Postman. En la respuesta, obtendrá el siguiente resultado:

      Output

      The language value is: Python The framework value is: Flask The Python version is: 3.9 The item at index 0 in the example list is: query The boolean value is: false

      Ahora comprende cómo se manejan los objetos JSON.

      Conclusión

      En este artículo, se creó una aplicación Flask con tres rutas que aceptan cadenas de consulta, datos de formulario u objetos JSON.

      Además, recuerde que todos los enfoques tuvieron que abordar la consideración recurrente de fallar con gracia cuando falta una clave.

      Advertencia: Un tema que no se cubrió en este artículo fue cómo desinfectar la entrada de los usuarios. La sanitización de la entrada de lo usuario garantizaría que los datos leídos por la aplicación no causen un fallo inesperado o que se salten las medidas de seguridad.

      Si desea obtener más información sobre Flask, consulte nuestra página del tema Flask para consultar ejercicios y proyectos de programación.



      Source link

      Comment traiter les données des requêtes entrantes dans Flask


      Introduction

      Les applications web doivent souvent traiter les données des requêtes entrantes fournies par les utilisateurs. Cette charge utile peut prendre la forme de chaînes de requête, de données de formulaires et d’objets JSON. Flask, comme tout autre framework web, vous permet d’accéder aux données d’une requête.

      Au cours de ce tutoriel, vous allez créer une application Flask avec trois itinéraires qui acceptent soit les chaînes de requête, les données de formulaire ou les objets JSON.

      Conditions préalables

      Pour suivre ce tutoriel, vous aurez besoin de :

      Ce tutoriel a été vérifié avec Pipenv v2020.11.15, Python v3.9.0 et Flask v1.1.2.

      Créer le projet

      Afin de pouvoir découvrir les différentes façons d’utiliser des requêtes, vous devrez créer une application Flask. Même si l’application donnée en exemple utilise une structure simplifiée pour les fonctions et les itinéraires de visualisation, vous pouvez appliquer tout ce que vous apprendrez au cours de ce tutoriel à toute méthode qui permet d’organiser vos affichages sous forme, par exemple, d’un affichage par catégories, de plans d’action ou d’une extension comme Flask-Via.

      Vous devrez tout d’abord créer un répertoire de projet. Ouvrez votre terminal et exécutez la commande suivante :

      • mkdir flask_request_example

      Ensuite, naviguez vers le nouveau répertoire :

      Ensuite, installez Flask. Ouvrez votre terminal et exécutez la commande suivante :

      La commande pipenv créera un virtualenv pour ce projet, un Pipfile, installera flask et un Pipfile.lock.

      Pour activer le virtualenv du projet, exécutez la commande suivante :

      Pour accéder aux données entrantes dans Flask, vous devez utiliser l'objet request. L'objet request contient toutes les données entrantes de la requête, qui incluent, entre autres, le typemime, le référent, l'adresse IP, les données brutes, la méthode HTTP et les en-têtes.

      Bien que toutes les informations que contient l'objet request soient utiles, pour les besoins de cet article, vous allez vous concentrer sur les données qui sont normalement fournies directement par l'appelant du terminal.

      Pour accéder à l'objet de requête dans Flask, vous devez l'importer à partir de la bibliothèque Flask :

      from flask import request
      

      Vous aurez alors la possibilité de l'utiliser dans l'une de vos fonctions d'affichage.

      Utilisez votre éditeur de code pour créer un fichier app.py. Importez Flask et l'objet request. Configurez également des itinéraires pour query-example, form-example et json-example:

      app.py

      # import main Flask class and request object
      from flask import Flask, request
      
      # create the Flask app
      app = Flask(__name__)
      
      @app.route('/query-example')
      def query_example():
          return 'Query String Example'
      
      @app.route('/form-example')
      def form_example():
          return 'Form Data Example'
      
      @app.route('/json-example')
      def json_example():
          return 'JSON Object Example'
      
      if __name__ == '__main__':
          # run app in debug mode on port 5000
          app.run(debug=True, port=5000)
      

      Ensuite, ouvrez votre terminal et démarrez l'application avec la commande suivante :

      L'application démarrera sur le port 5000. Vous pourrez alors visualiser chaque itinéraire dans votre navigateur en utilisant les liens suivants :

      http://127.0.0.1:5000/query-example (or localhost:5000/query-example)
      http://127.0.0.1:5000/form-example (or localhost:5000/form-example)
      http://127.0.0.1:5000/json-example (or localhost:5000/json-example)
      

      Le code établit trois itinéraires. En visualisant chaque itinéraire, les messages « Requy String Example », « Form Data example » et « JSON Object example » s'afficheront respectivement.

      Utiliser les arguments de requête

      On utilise souvent les arguments URL que vous ajoutez à une chaîne de requête pour transmettre des données à une application web. Alors qu'en navigant sur le Web, vous rencontrerez probablement une chaîne de requête auparavant.

      Une chaîne de requête ressemble à ce qui suit :

      example.com?arg1=value1&arg2=value2
      

      La chaîne de requête commence après le caractère du point d'interrogation (?) :

      example.com?arg1=value1&arg2=value2
      

      Et intègre des paires de valeurs clés séparées par un caractère de perluète (&) :

      example.com?arg1=value1&arg2=value2
      

      Pour chaque pair, la clé est suivie du caractère égal (=), puis de la valeur.

      arg1 : value1
      arg2 : value2
      

      Les chaînes de requête vous seront utiles pour transmettre les données sur lesquelles l'utilisateur n'a pas besoin d'agir. Vous pouvez générer une chaîne de requête quelque part dans votre application et l'ajouter à une URL afin que, lorsqu'un utilisateur soumet une requête, les données soient automatiquement transmises pour elles. Une chaîne de requête peut également être générée par les formulaires qui ont pour méthode GET.

      Ajoutons une chaîne de requête à l'itinéraire query-example. Dans cet exemple hypothétique, vous allez renseigner le nom d'un langage de programmation qui s'affichera à l'écran. Créez une clé de « langage » et une valeur de « Python » :

      http://127.0.0.1:5000/query-example?language=Python
      

      Si vous exécutez l'application et que vous naviguez vers cette URL, vous verrez qu'elle affiche toujours le message « Request String Example ».

      Vous devrez alors programmer la partie qui gère les arguments de la requête. Ce code lira le contenu de la clé language en utilisant soit request.args.get('language') ou request.args['language'].

      En appelant request.args.get('language'), l'exécution de l'application continuera si la clé language n'existe pas dans l'URL. Le cas échéant, la méthode affichira le résultat None.

      En appelant request.args['language'], l'application renverra une erreur 400 si la clé de la langue n'existe pas dans l'URL.

      Lorsque vous travaillez avec des chaînes de requête, nous vous recommandons d'utiliser request.args.get() pour empêcher l'application d'entrer en échec.

      Lisons la clé language et affichons-la comme la sortie.

      Modifiez l'itinéraire query-example dans app.py en utilisant le code suivant :

      app.py

      @app.route('/query-example')
      def query_example():
          # if key doesn't exist, returns None
          language = request.args.get('language')
      
          return '''<h1>The language value is: {}</h1>'''.format(language)
      

      Ensuite, exécutez l'application et naviguez jusqu'à l'URL :

      http://127.0.0.1:5000/query-example?language=Python
      

      Le navigateur devrait afficher le message suivant :

      Output

      The language value is: Python

      L'argument provenant de l'URL est affecté à la variable language et ensuite renvoyé au navigateur.

      Pour ajouter d'autres paramètres de chaîne de requête, vous pouvez ajouter les perluètes et de nouvelles paires clé-valeur à la fin de l'URL. Créez une clé « framework » et une valeur « Flask » :

      http://127.0.0.1:5000/query-example?language=Python&framework=Flask
      

      Et si vous en voulez plus, continuez à ajouter des perluettes et des paires clé-valeur. Créez une clé « website » et une valeur « DigitalOcean » :

      http://127.0.0.1:5000/query-example?language=Python&framework=Flask&website=DigitalOcean
      

      Pour accéder à ces valeurs, vous devrez à nouveau utiliser soit request.args.get() ou request.args[]. Utilisons-les toutes les deux pour voir ce qu'il se passe lorsqu'une clé est manquante. Modifiez l'itinéraire query_example pour attribuer la valeur des résultats à des variables, puis affichez-les :

      @app.route('/query-example')
      def query_example():
          # if key doesn't exist, returns None
          language = request.args.get('language')
      
          # if key doesn't exist, returns a 400, bad request error
          framework = request.args['framework']
      
          # if key doesn't exist, returns None
          website = request.args.get('website')
      
          return '''
                    <h1>The language value is: {}</h1>
                    <h1>The framework value is: {}</h1>
                    <h1>The website value is: {}'''.format(language, framework, website)
      

      Ensuite, exécutez l'application et naviguez jusqu'à l'URL :

      http://127.0.0.1:5000/query-example?language=Python&framework=Flask&website=DigitalOcean
      

      Le navigateur devrait afficher le message suivant :

      Output

      The language value is: Python The framework value is: Flask The website value is: DigitalOcean

      Supprimez la clé language de l'URL :

      http://127.0.0.1:5000/query-example?framework=Flask&website=DigitalOcean
      

      Le navigateur devrait afficher le message suivant accompagné de None si aucune valeur language n'est fournie :

      Output

      The language value is: None The framework value is: Flask The website value is: DigitalOcean

      Supprimez la clé framework de l'URL :

      http://127.0.0.1:5000/query-example?language=Python&website=DigitalOcean
      

      Le navigateur devrait rencontrer une erreur, étant donné qu'il s'attend à trouver une valeur pour framework :

      Output

      werkzeug.exceptions.BadRequestKeyError werkzeug.exceptions.BadRequestKeyError: 400 Bad Request: The browser (or proxy) sent a request that this server could not understand. KeyError: 'framework'

      Vous comprenez maintenant de quelle manière sont traitées les chaînes de requête. Passons au prochain type de données entrantes.

      Utiliser les données de formulaire

      Les données des formulaires proviennent d'un formulaire qui a été envoyé en tant que requête POST à un itinéraire. Par conséquent, au lieu de voir les données dans l'URL (sauf si le formulaire est soumis avec une requête GET), les données du formulaire seront transmises à l'application en coulisses. Même si vous ne pouvez pas facilement voir les données du formulaire qui sont transmises, votre application est tout de même en capacité de les lire.

      Pour le démontrer, modifiez l'itinéraire form-example dans app.py pour accepter les requêtes à la fois GET et POST. Le formulaire suivant est renvoyé :

      app.py

      # allow both GET and POST requests
      @app.route('/form-example', methods=['GET', 'POST'])
      def form_example():
          return '''
                    <form method="POST">
                        <div><label>Language: <input type="text" name="language"></label></div>
                        <div><label>Framework: <input type="text" name="framework"></label></div>
                        <input type="submit" value="Submit">
                    </form>'''
      

      Ensuite, exécutez l'application et naviguez jusqu'à l'URL :

      http://127.0.0.1:5000/form-example
      

      Le navigateur devrait afficher un formulaire avec deux champs de saisie (un pour language et un pour framework) et un bouton Submit.

      Le plus important à savoir sur ce formulaire, c'est qu'il effectue une requête POST sur le même itinéraire qui a généré le formulaire. Les clés qui seront lues dans l'application proviennent toutes des attributs name qui se trouvent sur nos entrées de formulaire. Dans ce cas, langage et framework correspondent aux noms des entrées. Vous y aurez donc accès dans l'application.

      Dans la fonction d'affichage, vous devrez alors vérifier si la méthode de requête est GET ou POST. S'il s'agit d'une requête GET, vous pouvez afficher le formulaire. Dans le cas contraire, s’il s'agit d'une requête POST, vous devrez alors traiter les données entrantes.

      Modifiez l'itinéraire form-example dans app.py en utilisant le code suivant :

      app.py

      # allow both GET and POST requests
      @app.route('/form-example', methods=['GET', 'POST'])
      def form_example():
          # handle the POST request
          if request.method == 'POST':
              language = request.form.get('language')
              framework = request.form.get('framework')
              return '''
                        <h1>The language value is: {}</h1>
                        <h1>The framework value is: {}</h1>'''.format(language, framework)
      
          # otherwise handle the GET request
          return '''
                 <form method="POST">
                     <div><label>Language: <input type="text" name="language"></label></div>
                     <div><label>Framework: <input type="text" name="framework"></label></div>
                     <input type="submit" value="Submit">
                 </form>'''
      

      Ensuite, exécutez l'application et naviguez jusqu'à l'URL :

      http://127.0.0.1:5000/form-example
      

      Renseignez le champ language avec la valeur Python et le champ framework avec la valeur Flask. Ensuite, appuyez sur Submit.

      Le navigateur devrait afficher le message suivant :

      Output

      The language value is: Python The framework value is: Flask

      Vous comprenez maintenant de quelle manière sont traitées les chaînes de requête. Passons au prochain type de données entrantes.

      Utiliser des données JSON

      Les données JSON sont généralement construites par un processus qui appelle l'itinéraire.

      Voici à quoi ressemble un exemple d'objet JSON :

      {
        "language": "Python",
        "framework": "Flask",
        "website": "Scotch",
        "version_info": {
          "python": "3.9.0",
          "flask": "1.1.2"
        },
        "examples": ["query", "form", "json"],
        "boolean_test": true
      }
      

      Cette structure peut permettre la transmission de données bien plus complexes par opposition aux chaînes de requête et aux données de formulaires. Dans l'exemple, vous voyez des objets JSON imbriqués et un tableau d'éléments. Flask peut gérer ce format de données.

      Modifiez l'itinéraire form-example dans app.py pour accepter les requêtes POST et ignorer les autres requêtes comme GET :

      app.py

      @app.route('/json-example', methods=['POST'])
      def json_example():
          return 'JSON Object Example'
      

      Contrairement au navigateur web qui sert à interroger les chaînes et les données de formulaire, pour les besoins de cet article, afin d'envoyer un objet JSON, vous utiliserez Postman pour envoyer des requêtes personnalisées aux URL.

      Remarque : si vous avez besoin d'aide pour naviguer sur l'interface Postman pour les requêtes, consultez la documentation officielle.

      Dans Postman, ajoutez l'URL et configurez le type sur POST. Sur l'onglet body, changez la valeur sur raw et sélectionnez JSON dans la liste déroulante.

      Ces paramètres sont nécessaires pour permettre à Postman d'envoyer les données JSON correctement. Par conséquent, votre application Flask comprendra qu'elle reçoit JSON :

      POST http://127.0.0.1:5000/json-example
      Body
      raw JSON
      

      Ensuite, copiez l'exemple JSON précédent dans la saisie de texte.

      Envoyez la requête. Vous devriez recevoir la réponse « JSON Object Example ». Il s'agit d'une approche assez étrange, mais il faudra vous y attendre, car il reste encore à écrire le code qui permet de gérer la réponse des données JSON.

      Pour lire les données, vous devez comprendre de quelle manière Flask traduit les données JSON en structures de données Python :

      • Tout ce qui est un objet est converti en un dict. Python {"key" : "value"}, dans JSON cela correspond à somedict['key'] qui renvoie une valeur dans Python.
      • Un tableau dans JSON est converti en une liste dans Python. Étant donné que la syntaxe est la même, voici un exemple de liste : [1,2,3,4,5]
      • Les valeurs entre crochets dans l'objet JSON deviennent des chaînes dans Python.
      • Les valeurs booléennes true et false deviennent True et False dans Python.
      • Enfin, les numéros sans parenthèse se transforment en numéros dans Python.

      Travaillons maintenant sur le code afin de pouvoir lire les données JSON entrantes.

      Tout d'abord, attribuons tout ce qui se trouve dans l'objet JSON à une variable en utilisant request.get_json().

      request.get_json() convertit l'objet JSON en données Python. Attribuons maintenant les données des requêtes entrantes aux variables et renvoyons-les en apportant les modifications suivantes à l'itinéraire json-example :

      app.py

      # GET requests will be blocked
      @app.route('/json-example', methods=['POST'])
      def json_example():
          request_data = request.get_json()
      
          language = request_data['language']
          framework = request_data['framework']
      
          # two keys are needed because of the nested object
          python_version = request_data['version_info']['python']
      
          # an index is needed because of the array
          example = request_data['examples'][0]
      
          boolean_test = request_data['boolean_test']
      
          return '''
                 The language value is: {}
                 The framework value is: {}
                 The Python version is: {}
                 The item at index 0 in the example list is: {}
                 The boolean value is: {}'''.format(language, framework, python_version, example, boolean_test)
      

      Notez de quelle manière vous accédez aux éléments qui ne sont pas au niveau supérieur. ['version']['python'] est utilisé, car vous êtes en train de saisir un objet imbriqué. Et ['example'][0] permet d'accéder à l'index 0 dans le tableau des exemples.

      Si l'objet JSON envoyé avec la requête n'est pas accessible dans votre fonction de visualisation, cela signifie que la requête échouera. Si vous ne souhaitez pas qu'elle échoue en l'absence d'une clé, il vous faudra préalablement vérifier si la clé existe avant d'essayer d'y accéder.

      app.py

      # GET requests will be blocked
      @app.route('/json-example', methods=['POST'])
      def json_example():
          request_data = request.get_json()
      
          language = None
          framework = None
          python_version = None
          example = None
          boolean_test = None
      
          if request_data:
              if 'language' in request_data:
                  language = request_data['language']
      
              if 'framework' in request_data:
                  framework = request_data['framework']
      
              if 'version_info' in request_data:
                  if 'python' in request_data['version_info']:
                      python_version = request_data['version_info']['python']
      
              if 'examples' in request_data:
                  if (type(request_data['examples']) == list) and (len(request_data['examples']) > 0):
                      example = request_data['examples'][0]
      
              if 'boolean_test' in request_data:
                  boolean_test = request_data['boolean_test']
      
          return '''
                 The language value is: {}
                 The framework value is: {}
                 The Python version is: {}
                 The item at index 0 in the example list is: {}
                 The boolean value is: {}'''.format(language, framework, python_version, example, boolean_test)
      

      Exécutez l'application et envoyez l'exemple de requête JSON en utilisant Postman. Dans la réponse, vous obtiendrez la sortie suivante :

      Output

      The language value is: Python The framework value is: Flask The Python version is: 3.9 The item at index 0 in the example list is: query The boolean value is: false

      Désormais, vous comprenez de quelle manière sont manipulés les objets JSON.

      Conclusion

      Au cours de ce tutoriel, vous avez créé une application Flask avec trois itinéraires qui acceptent soit les chaînes de requête, les données de formulaire ou les objets JSON.

      En outre, n'oubliez pas que toutes les approches ont bien pris en compte la problématique récurrente de l'échec normal généré par l'absence d'une clé.

      Avertissement : le nettoyage des entrées des utilisateurs n'a pas été abordé dans cet article. Le nettoyage des entrées des utilisateurs permet de garantir que les données lues par l'application ne génèrent pas la défaillance inattendue d'un élément ou ne contournent pas les mesures de sécurité.

      Si vous souhaitez en savoir plus sur Flask, veuillez consulter notre page thématique Flask dans laquelle vous trouverez des exercices et des projets de programmation.



      Source link