Utiliser différents types de paramètres à l'intérieur de l'URL dans Flask

Nous apprendrons, avec cette explication, les convertisseurs d’URL dans l’application Flask, ce qui signifie la possibilité de passer des paramètres dans n’importe quelle URL. Nous apprendrons également à utiliser différents types de paramètres dans l’URL de l’application Flask.

Utiliser différents types de paramètres à l’intérieur de l’URL dans Flask

Nous allons maintenant discuter des paramètres d’URL et les démontrer ; nous allons commencer par la valeur par défaut, qui est l’exemple le plus basique. Pour cela, nous allons créer une route et passer dans la route() qui serait '/default/<params>'.

Le /default mènera à l’URL. La deuxième partie de l’URL est le paramètre, où nous spécifions le paramètre dans le symbole supérieur et inférieur à.

Ensuite, nous allons créer une fonction appelée DEFAULT() et passer le même nom pour le paramètre de fonction que nous avons défini dans notre route, donc dans ce cas, le paramètre serait params. Ensuite, nous renverrons la valeur et concatènerons la valeur avec cette chaîne.

from flask import Flask

app = Flask(__name__)


@app.route("/default/<params>")
def DEFAULT(params):
    return "The parameter is: " + params


if __name__ == "__main__":
    app.run(debug=True)

Démarrons notre application et ouvrons le navigateur, et après avoir tapé /default lorsque nous passons un nom, nous verrons la valeur d’un paramètre qui est une chaîne par défaut.

Nous vous montrerons les autres types de données que vous pouvez utiliser, mais pour l’analyse de la chaîne, nous vous montrerons que si nous passons un nombre et un nombre décimal, ils fonctionneront tous car ils seront convertis en chaîne. De cette façon, nous obtiendrons la valeur de tout ce que nous avons passé dans le point de terminaison.

Si nous ne passons pas le paramètre, nous obtenons une erreur introuvable car il attend un paramètre. Pour gérer ce cas, lorsque l’utilisateur ne passe rien, nous allons spécifier un autre itinéraire et le mettre juste au-dessus.

À l’intérieur de cette route, nous passerons un argument de mot-clé appelé defaults et prendrons params et sa valeur.

@app.route('/default', defaults={'params': 'John'})

Maintenant, nous allons le redémarrer, et si nous allons avec l’URL sans passer de paramètre, nous obtenons la valeur par défaut qui est John, mais si nous passons la valeur, nous obtiendrons cette valeur au lieu de la valeur par défaut.

Passons un type de données sous forme de chaîne dans nos routes pour spécifier qu’il ne peut s’agir que d’une chaîne. Nous mettons d’abord chaîne, puis deux-points, puis le nom du paramètre.

Nous allons définir une autre fonction pour cette route appelée String_Func() et retourner la chaîne et concaténer le paramètre que nous avons défini dans la route.

@app.route("/str-url/<string:str_params>")
def String_Func(str_params):
    return "The string parameter is: " + str_params

Nous pouvons voir que cela fonctionne de la même manière que la route par défaut car, par défaut, le type de paramètre est une chaîne.

Voyons maintenant ce qui se passe lorsque nous voulons traiter différents types de données, et le type de données suivant serait un entier. Définissons une autre route pass <int:int_params> ; le paramètre serait ce que vous l’appelez.

Ensuite, nous définissons une fonction comme d’habitude et la convertissons en un type de données chaîne car nous ne pouvons pas concaténer une chaîne à un entier.

@app.route("/int-url/<int:int_params>")
def Int_Func(int_params):
    return "The integer parameter is: " + str(int_params)

Production

Le prochain type de données que nous utiliserons serait un flottant, commençant par <float:float_params>.

@app.route("/float-url/<float:float_params>")
def Float_Func(float_params):
    return "The float parameter is: " + str(float_params)

Si nous passons 3.5, la page l’affichera, mais si nous ne passons que 3, nous obtenons une erreur car 3 est un entier, et le Flask ne le permet pas ainsi. Si vous voulez 3.0, vous devez passer 3.0 ou créer une autre route qui récupérera tous les entiers.

Une autre chose est une URL de chemin afin que nous définissions une nouvelle route pour celle-ci, et nous devrons passer le type de données de chemin et le nom du chemin tel que <chemin : notre_chemin>.

@app.route("/path-route/<path:our_path>")
def Path_Func(our_path):
    return "Our path is: " + our_path

Maintenant, nous allons aller à l’URL et lui donner le chemin, puis il l’affiche, mais si nous mettons des barres obliques et spécifions un autre sous-répertoire, il sélectionne tout et inclut les barres obliques.

La dernière chose que nous voulons vous montrer est que vous pouvez combiner plusieurs paramètres dans le même itinéraire. Nous combinerons des paramètres de chaîne et d’entier tels que <string:name>/<int:num>.

Définissons une fonction et spécifions les deux paramètres à l’intérieur de la fonction et renvoyons-la.

@app.route("/combine-route/<string:name>/<int:num>")
def Combine_Func(name, num):
    return "User name is: " + name + " and user id is: " + str(num)

Regardez la sortie pour mieux la comprendre.

Code source complet de l’application Flask :

from flask import Flask

app = Flask(__name__)
# This is the default route


@app.route("/default", defaults={"params": "John"})
@app.route("/default/<params>")
def DEFAULT(params):
    return "The string parameter is: " + params


# This route holds string data type
@app.route("/str-url/<string:str_params>")
def String_Func(str_params):
    return "The string parameter is: " + str_params


# This route holds int data type
@app.route("/int-url/<int:int_params>")
def Int_Func(int_params):
    return "The integer parameter is: " + str(int_params)


# This route holds float data type
@app.route("/float-url/<float:float_params>")
def Float_Func(float_params):
    return "The float parameter is: " + str(float_params)


# This route holds path data type
@app.route("/path-route/<path:our_path>")
def Path_Func(our_path):
    return "Our path is: " + our_path


# This route combine two parameters
@app.route("/combine-route/<string:name>/<int:num>")
def Combine_Func(name, num):
    return "User name is: " + name + " and user id is: " + str(num)


if __name__ == "__main__":
    app.run(debug=True)