Nouvelles

Jan 28, 2024

Premiers pas avec Flask, un microframework Python — SitePoint

Dans cet article, nous présenterons Flask, un microframework populaire pour Python qui

Dans cet article, nous présenterons Flask, un microframework populaire pour Python qui offre une alternative au géant qu'est Django.

Flask est conçu pour être léger et flexible, permettant aux développeurs de créer des applications Web rapidement et facilement. Dans cet article, nous allons couvrir ce qu'est Flask, ses fonctionnalités clés, les avantages de son API simple, sa flexibilité dans la prise en charge des extensions tierces, les extensions Flask les plus courantes, et quand est et n'est pas le bon moment pour utiliser Ballon.

Flask est un micro framework Web écrit en Python qui est utilisé pour développer des applications Web. Il repose sur une philosophie simple consistant à garder les choses simples et légères, en ne donnant aux développeurs que les outils les plus importants nécessaires pour créer des applications Web sans complexité inutile.

Il est construit sur la boîte à outils Werkzeug WSGI, qui fournit les fonctionnalités de serveur Web nécessaires pour gérer les demandes et les réponses, et le moteur de modélisation Jinja2, qui donne à Flask la possibilité de gérer des modèles HTML, permettant aux développeurs de créer des applications Web dynamiques.

Voici quelques-unes des fonctionnalités clés de Flask qui en font un excellent framework avec lequel travailler :

Dans l'ensemble, Flask fournit un cadre puissant, flexible et simple pour créer des applications Web. C'est un bon choix pour les développeurs Web débutants et expérimentés, et c'est l'un des frameworks Web les plus populaires de l'écosystème de développement Web Python.

Examinons maintenant plus en détail certains des avantages de l'utilisation de Flask dans le développement.

Simplicité . La philosophie de conception de Flask met l'accent sur la simplicité, ce qui facilite la compréhension et l'utilisation par les développeurs de tous niveaux. Cela signifie également que les développeurs ont une courbe d'apprentissage très minimale, car ils n'ont besoin d'apprendre que quelques concepts et API pour commencer à créer des applications Web.

La flexibilité . La nature micro de Flask - ne fournissant que les fonctionnalités de base d'un framework Web - donne aux développeurs le pouvoir de le personnaliser et de l'étendre en fonction de leurs besoins à l'aide d'extensions Flask ou de bibliothèques tierces.

Documentation . La documentation Flask est très complète, avec une bonne couverture des sujets de base à avancés, ce qui permet aux développeurs d'apprendre très facilement à utiliser le framework.

Compatibilité . Flask est compatible avec une large gamme de versions de Python, ce qui facilite son utilisation avec les bases de code Python existantes. Il prend également en charge plusieurs serveurs Web, ce qui facilite son déploiement sur diverses plates-formes d'hébergement.

Développement rapide . La simplicité et la flexibilité de Flask réduisent le passe-partout nécessaire pour configurer une application, permettant aux développeurs de démarrer rapidement.

Sur le Web, Flask est utilisé de nombreuses manières intéressantes. Quelques exemples notables sont :

La simplicité et la facilité d'utilisation de Flask en font un excellent choix pour un large éventail de projets Web :

Bien que Flask soit un excellent framework et présente un certain nombre d'avantages et de fonctionnalités intéressantes, il existe des situations dans lesquelles ces fonctionnalités fonctionnent contre lui. Explorons quelques-uns des projets qui conviennent mieux à d'autres types de frameworks.

Projets nécessitant des fonctionnalités intégrées . Étant un microframework, Flask ne fournit que les éléments de base nécessaires pour créer une application Web. Si un projet nécessite, par exemple, une interface d'administration, une authentification ou un ORM, alors Django est une meilleure option.

Projets avec des exigences de sécurité strictes . Comme Flask est un framework flexible, nous devons nous appuyer sur des extensions tierces pour implémenter un certain niveau de sécurité dans nos applications. Bien que cela fonctionne certainement, il est préférable de s'appuyer sur un cadre plus testé au combat qui adopte une approche plus sécurisée, comme Tornado ou Twisted.

Projets qui appliquent une norme de codage . En raison de la flexibilité de Flask, le développement d'applications sur celui-ci laisse aux développeurs le soin de créer des applications comme bon leur semble. Cependant, des frameworks comme Django garantissent que les développeurs suivent une convention particulière, ce qui signifie que les développeurs peuvent passer facilement d'un projet à un autre.

Voyons maintenant comment démarrer avec Flask, de la configuration de l'environnement de développement à l'installation, et enfin à la création d'une application minimale.

Python doit être installé sur la machine de développement. Voici les instructions pour cela (bien que nous l'ayons peut-être déjà installé).

Un environnement virtuel est un environnement Python isolé dans lequel nous pouvons installer des packages pour un projet donné sans affecter l'installation globale de Python. (Voici une discussion plus approfondie sur l'utilité des environnements virtuels.) Il existe différents packages pour créer des environnements virtuels en Python, tels que virtualenv, venv ou Conda.

Dans cet article, nous utiliserons virtualenv. Nous pouvons l'installer avec la commande suivante :

Une fois virtualenv installé, nous pouvons créer un répertoire où résidera notre application Flask. Nous pouvons appeler le répertoire comme nous le voulons - autre que Flask, car cela provoquera des conflits. Nous appellerons le nôtre flask_intro :

Ensuite, accédez à ce répertoire afin que nous puissions commencer à l'utiliser :

Dans ce répertoire, créons maintenant notre environnement virtuel, en utilisant la commande suivante :

La commande ci-dessus crée un environnement virtuel et l'appelle myenv. Activons-le pour pouvoir y installer Flask. Pour activer l'environnement virtuel surLinuxoumacOS, utilisez la commande suivante :

Surles fenêtres, utilisez cette commande :

Une fois que notre environnement virtuel a été activé, il affichera le nom de l'environnement virtuel à l'invite du shell, similaire à la sortie ci-dessous :

Dans notre environnement virtuel activé, nous pouvons continuer et installer Flask à l'aide de la commande suivante :

Une fois l'installation de Flask terminée, continuons et créons une application minimale. Nous allons créer un module qui contiendra notre application Flask. Par souci de simplicité, appelons-le hello.py. SurLinuxoumacOSnous pouvons utiliser la commande suivante pour créer le fichier dans notre répertoire flask_intro :

La commande ci-dessus crée un fichier nommé hello.py. Nous pourrions également utiliser un environnement de développement pour créer le fichier. Une fois le fichier créé, insérez-y le code ci-dessous et enregistrez-le :

Dans le code ci-dessus, nous importons la classe Flask à partir du module flask, puis créons une instance de Flask que nous appelons app et transmettons la variable __name__.

Ensuite, nous avons le décorateur de route @app.route("\"), ce qui signifie que la fonction hello_world() sera déclenchée lorsque quelqu'un visitera la route racine de notre application une fois qu'elle sera exécutée.

Il existe différentes manières d'exécuter l'application, alors examinons-en quelques-unes. La première consiste à fournir à la commande flask un certain nombre d'arguments : --app, puis le nom du module qui contient, notre application Flask, puis run. Voir ci-dessous:

En utilisant l'exemple ci-dessus pour exécuter notre exemple d'application :

Cela exécutera notre application sur le port par défaut 5000 afin que l'application soit disponible sur http://localhost:5000/ ou sur http://127.0.0.1:5000/. Si nous voulons que l'application soit disponible sur un port différent, nous pouvons spécifier le port en utilisant l'option -p ou --port. Par exemple:

Cela exécutera le serveur sur le port 8080. L'autre façon d'exécuter l'application consiste simplement à utiliser les commandes flask run. Cependant, pour que nous puissions le faire, nous devons indiquer à Flask le nom du module qui contiendra l'instance de Flask, et nous le faisons en définissant la variable d'environnement FLASK_APP. Donc dans notre cas, l'application Flask est contenue dans un fichier nommé hello.py. Nous pouvons donc le définir de cette façon:

Maintenant que nous avons défini la variable d'environnement FLASK_APP, nous pouvons exécuter le serveur de développement comme suit :

Avec ce code, nous avons maintenant une application Web en cours d'exécution. Cela démontre la philosophie de base de Flask : nous n'avons pas besoin de beaucoup de code passe-partout pour faire avancer les choses. Cependant, l'application que nous avons configurée ci-dessus n'est pas très fonctionnelle ou utile, car elle n'affiche que la chaîne "Hello World!" sur notre page Internet. Pour faire quelque chose de plus utile, nous pouvons nous tourner vers des modèles. Nous verrons ensuite comment les gérer.

Gabarits de flacons sont un moyen de créer des pages Web dynamiques pouvant afficher différents contenus en fonction de divers facteurs, tels que les données d'une base de données ou les entrées de l'utilisateur. Les modèles dans Flask sont une combinaison de HTML et d'espaces réservés spéciaux appelésvariables de modèlequi sont remplacées par des valeurs réelles lors de l'exécution.

Les modèles sont stockés dans le répertoire des modèles. Donc, pour utiliser des modèles, nous devons importer la méthode render_template() de flask. La méthode render_template() prend un nom de modèle et toutes les données facultatives qui doivent être transmises au modèle.

Voyons un exemple de fonction qui utilise un modèle pour afficher une page Web :

Dans l'exemple ci-dessus, nous avons une fonction d'affichage — index() — qui est liée à l'URL racine ("/") par le décorateur @app.route(). La fonction a deux variables, titre et message. Enfin, nous passons le modèle index.html au render_template(), ainsi que les variables de titre et de message.

Pour que le code ci-dessus fonctionne, nous devons avoir un modèle index.html résidant dans un répertoire de modèles. Ainsi, le modèle ressemblera à ceci :

Dans le fichier index.html, les espaces réservés {{title}} et {{ message }} sont remplacés par les valeurs transmises au modèle dans la méthode render_template().

Les modèles peuvent également inclure une logique plus complexe, telle que des instructions if et des boucles for, qui permettent de générer des pages plus dynamiques.

Ainsi, les modèles dans Flask offrent aux développeurs une option très puissante pour créer des pages Web dynamiques riches en informations générées par les utilisateurs.

La plupart des applications Web auront plus d'une URL, nous devons donc avoir un moyen de savoir quelle fonction gère quelle URL. Dans Flask, ce mappage est connu sous le nom deroutage — le processus de liaison ou de mappage des URL pour afficher les fonctions. La liaison des URL aux fonctions d'affichage permet à l'application de gérer différents types de requêtes, telles que GET, POST, PUT, DELETE, etc. Il permet également à l'application de gérer plusieurs demandes de différents clients.

Pour configurer des routes dans Flask, nous utilisons le décorateur route(). Le décorateur lie une URL à une fonction d'affichage. Ainsi, lorsqu'un utilisateur visite une URL qui existe sur notre application, Flask déclenche la fonction d'affichage associée pour gérer la demande.

Voyons un exemple :

Dans l'exemple ci-dessus, nous définissons une URL about (/about). Lorsque l'application reçoit une demande d'URL à propos, Flask appelle la fonction about(), qui renvoie la chaîne "Ceci est la page à propos".

Jusqu'à présent, même si ces exemples renvoient des pages différentes, ils utilisent tous simplement la requête HTTP GET. Afin de pouvoir gérer toute requête spécifique, nous pouvons spécifier la méthode HTTP comme argument optionnel du décorateur route().

Voyons un exemple de requête PUT :

Dans cet exemple, nous définissons une route qui gère une demande PUT pour mettre à jour les détails de l'utilisateur en fonction de leur user_id. Nous utilisons dans la route pour indiquer que l'ID utilisateur doit être un entier.

Dans la fonction update_user(), nous obtenons les données utilisateur du corps de la requête à l'aide de la méthode request.get_json(). Nous faisons quelque chose avec les données utilisateur, comme mettre à jour l'utilisateur dans la base de données, puis renvoyons une réponse indiquant le succès ou l'échec avec un code d'état HTTP (un 200 dans ce cas pour montrer le succès).

Dans l'ensemble, le routage permet à Flask de gérer différents types de requêtes et permet à notre application de gérer et d'agir différemment sur les données, en fonction de l'URL qu'un utilisateur visite.

En plus d'afficher des données pour les utilisateurs, les modèles Flask peuvent également recevoir des informations des utilisateurs pour un traitement ou un stockage ultérieur. Pour cela, Flask fournit une prise en charge intégrée pour le traitement des formulaires HTML et la gestion des entrées utilisateur. Les formulaires Flask sont basés sur la bibliothèque WTForms, qui offre un moyen flexible et puissant de gérer les données de formulaire et d'effectuer des validations. Cependant, la bibliothèque ne fait pas partie de l'installation standard de Flask, nous devons donc l'installer à l'aide de la commande suivante :

Une fois que nous avons installé WTForms, pour utiliser les formulaires dans Flask, nous devons définir une classe de formulaire qui héritera de flask_wtf.FlaskForm. La classe contiendra les champs qui seront sur le formulaire et toutes les règles de validation qui devraient leur être appliquées.

Voyons un exemple de formulaire de connexion :

Dans l'exemple ci-dessus, nous définissons un formulaire de connexion avec deux champs - e-mail et mot de passe - et un bouton d'envoi. Nous avons également un argument validateurs qui est utilisé pour spécifier les règles de validation pour chaque champ. Par exemple, dans ce cas, nous exigeons que le champ e-mail contienne une adresse e-mail valide et que le champ mot de passe contienne un mot de passe d'au moins six caractères.

Une fois que nous avons défini la classe de formulaire, nous pouvons l'utiliser dans la fonction d'affichage de connexion pour rendre le formulaire et traiter les données de formulaire soumises par l'utilisateur. Voyons un exemple de la fonction view :

Dans l'exemple ci-dessus, nous avons une vue de connexion qui accepte deux méthodes HTTP (GET et POST), donc lorsque les utilisateurs accèdent à l'URL à partir d'un navigateur, le LoginForm est rendu sous forme de formulaire HTML à l'aide de la méthode render_template, et lorsqu'un utilisateur soumet le formulaire nous vérifions si le formulaire est valide en utilisant la méthode validate_on_submit. Si le formulaire est valide, nous accédons à l'e-mail et au mot de passe.

Le formulaire login.html pourrait ressembler à ceci :

Le modèle ci-dessus affichera les champs d'e-mail et de mot de passe, ainsi que leurs étiquettes, et un bouton d'envoi avec le texte "Connexion". Le champ form.csrf_token est inclus pour empêcher les attaques de falsification de requête intersite (CSRF). Les boucles {% for %} sont utilisées pour afficher les erreurs de validation qui peuvent se produire.

En utilisant les formulaires Flask, nous disposons d'un moyen puissant de gérer les entrées des utilisateurs et nous pourrons valider les données qu'ils saisissent.

Comme nous l'avons vu, Flask est un microframework qui ne comprend que les parties les plus importantes nécessaires à la création d'une application Web. Cependant, si nous devons ajouter des fonctionnalités qui ne sont pas proposées par Flask, nous devons ajouter des packages à l'installation. Les extensions Flask sont la façon dont nous fournissons cette fonctionnalité supplémentaire. Nous pouvons simplement installer le package dont nous avons besoin. Il existe de nombreuses extensions faites par la communauté Flask.

Voici quelques-uns des plus populaires :

Il existe des centaines d'extensions créées par la communauté Flask pour gérer différentes fonctionnalités. L'utilisation des extensions est généralement simple. Tout d'abord, nous devons installer l'extension que nous voulons en utilisant pip.

Voyons un exemple d'utilisation de Flask-SQLAlchemy. Tout d'abord, nous devons l'installer :

Ensuite, nous devons le configurer. Par exemple:

Dans l'exemple ci-dessus, nous avons un modèle User avec un nom d'utilisateur et un champ email. Nous configurons également SQLALCHEMY_DATABASE_URI, indiquant que nous utilisons une base de données SQLite située à example.db. Avec cet ensemble, nous avons maintenant accès à l'objet db qui nous permet d'interagir avec la base de données. Par exemple, nous pourrions créer un nouvel utilisateur et l'ajouter à la base de données, comme ceci :

Avec les extensions Flask, notre application est capable d'avoir plus de fonctionnalités qu'elle n'en aurait normalement avec l'implémentation principale de Flask.

Dans cet article, nous avons présenté Flask, un framework Web léger et flexible pour Python. Nous avons discuté des avantages de l'utilisation de Flask pour le développement Web, notamment sa simplicité, sa flexibilité et sa facilité d'utilisation. Nous avons également expliqué comment configurer un environnement de développement, créer des itinéraires, utiliser des modèles, gérer des formulaires et utiliser des extensions telles que Flask-SQLAlchemy.

Pour résumer, Flask est un excellent choix pour créer des applications Web de toute taille, des petits projets personnels aux applications commerciales à grande échelle. Il est facile à apprendre et à utiliser, mais offre également des fonctionnalités avancées grâce à ses nombreuses extensions.

Si vous souhaitez en savoir plus sur Flask, voici quelques ressources supplémentaires :

Si vous souhaitez en savoir plus sur Django et Flask et leurs meilleurs cas d'utilisation, consultez Développement Web Python avec Django et Flask.

Kabaki est un ingénieur logiciel full-stack et un rédacteur technique passionné par la création d'expériences numériques innovantes. Lorsqu'il ne code pas, il aime partager ses connaissances avec les autres en écrivant des articles techniques pour aider les développeurs à perfectionner leurs compétences.