Parámetros de consulta de solicitud GET con Flask

En esta guía, veremos cómo obtener los parámetros/argumentos de consulta, manejar los valores faltantes, establecer valores predeterminados y convertir parámetros a diferentes tipos de datos. en Flask: un marco ligero de Pyton para el desarrollo web.

Los Parámetros de consulta forman parte de la Cadena de consulta, una sección de la URL que contiene pares de parámetros clave-valor. Por lo general, los parámetros se envían junto con las solicitudes GET para especificar más filtros en la operación:

1
www.example.com/search?name=John&location=Miami

Los parámetros se definen después del carácter ? y cada par clave-valor se separa con un &. Los espacios se representan como %20 y también se pueden representar como +. Estos se asignan a un conjunto de clave-valor de:

1
2
name=John
location=Miami

Es fácil manipular la URL con JavaScript, por lo que la mayoría de las veces, los parámetros de consulta se agregan como filtros a las búsquedas. Además, al ajustar el contenido en la pantalla en función de parámetros reproducibles, en lugar del cuerpo de una solicitud, los resultados se pueden compartir entre los usuarios con solo enviar un enlace con los parámetros.

Por ejemplo, en AirBnB: si eres completamente flexible en cuanto a la ubicación, las fechas y deseas una sugerencia automática, un clic en un botón te lleva a:

1
https://www.airbnb.com/s/homes?refinement_paths%5B%5D=%2Fhomes&date_picker_type=flexible_dates&search_mode=flex_destinations_search&search_type=AUTOSUGGEST

Aquí hay algunos parámetros, como refinement_paths, date_picker_type, search_mode y search_type, cada uno con un valor.

En esta breve guía, veremos cómo obtener los parámetros de consulta de una solicitud GET en Flask.

Obtener parámetros de consulta en Flask

1
2
3
4
5
6
from flask import Flask, request
# ...
@app.route('/search', methods=['GET'])
def search():
    args = request.args
    return args

El campo request.args es un ImmutableMultiDict:

1
2
print(type(args))
# <class 'werkzeug.datastructures.ImmutableMultiDict'>

Se puede convertir fácilmente en un diccionario regular a través de:

1
2
print(type(args.to_dict()))
# <class 'dict'>

Además, puede buscar una clave específica en el diccionario a través del método get(), devolviendo un error si la clave no coincide con la lista de argumentos preconcebidos:

1
2
print(args.get("name"))
# John

Además, puede transmitir el valor a un tipo diferente, como int o str mientras lo obtiene. También puede establecer un valor predeterminado si el valor aún no está presente. Por ejemplo, un parámetro ’nombre’ probablemente será una cadena, pero el parámetro ‘precio’ podría ser un número entero:

1
2
args.get("name", default="", type=str)
args.get("price", default=0, type=int)

Si busca una clave inexistente, se devuelve Ninguna. De esta forma, puede verificar si falta un parámetro de consulta y actuar en consecuencia, asignando un valor predeterminado o simplemente no usándolo.

Enviemos una solicitud GET al punto final con un nombre y ubicación:

1
$ curl "localhost:5000/search?name=John&location=Miami"

Esto resulta en:

1
{"location":"Miami","name":"John"}

Comprobar si los parámetros de consulta no son ninguno

Cuando opere con parámetros, normalmente querrá comprobar si son “Ninguno” y actuar en consecuencia. ¡Afortunadamente, esto se puede hacer fácilmente obteniendo una clave esperada y verificando si está presente en el diccionario!

Vamos a crear una base de datos simulada, solo un diccionario de usuarios y sus ubicaciones. Luego, en función de los parámetros pasados ​​en la URL, filtraremos este diccionario y devolveremos los usuarios coincidentes que se ajustan a los criterios definidos por los parámetros:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
from flask import Flask, request
# ...
db_users = {
    "John" : "Miami",
    "David" : "Miami",
    "Jane" : "London",
    "Gabriella" : "Paris",
    "Tanaka" : "Tokyo"
}

@app.route('/search', methods=['GET'])
def search():
    args = request.args
    name = args.get('name')
    location = args.get('location')

    # result = db_users
    if None not in (name, location):
        result = {key: value for key, value in db_users.items() if key == name and value == location}
    elif name is not None:
        result = {key: value for key, value in db_users.items() if key == name}
    elif location is not None:
        result = {key: value for key, value in db_users.items() if value == location}

    return result

Aquí, extraemos el nombre y la ubicación de la lista de parámetros. Si no hay ninguno presente, es posible que desee devolver todos los usuarios, o ninguno en absoluto. Si desea devolverlos todos, descomente la línea result = db_users.

Si tanto el nombre como la ubicación están presentes, filtramos db_users por ambos parámetros. Si solo hay uno presente, lo filtramos solo usando el parámetro actual.

Ahora, si enviamos una solicitud GET con ambos o un solo parámetro, seremos recibidos con:

1
2
3
4
5
6
7
8
$ curl "localhost:5000/search?name=John&location=Miami"
{"John":"Miami"}

$ curl "localhost:5000/search?name=John"
{"John":"Miami"}

$ curl "localhost:5000/search?location=Miami"
{"David":"Miami","John":"Miami"}

Dos personas están ubicadas en Miami, por lo que solo usar el parámetro de búsqueda único nos da dos usuarios. Solo hay un John en el diccionario, por lo que solo se devuelve John para las dos primeras consultas.

Conclusión

En esta guía, hemos analizado cómo obtener los parámetros de consulta de una solicitud HTTP GET en Flask.

También hemos analizado cómo verificar si los parámetros son “Ninguno” y cómo manejar la falta de los mismos con una base de datos simulada.