Début avec Flask, un microframe Python

Cet article présente Flask, un mini-framework Python populaire qui fournit une alternative à l'énorme framework Django.

La philosophie de conception de Flask est légère et flexible, permettant aux développeurs de créer rapidement et facilement des applications Web. Cet article couvrira ce qu'est Flask, ses principales caractéristiques, les avantages d'une API simple, sa flexibilité pour soutenir les extensions tierces, les extensions de file les plus couramment utilisées, et lorsque le flacon doit ou ne doit pas être utilisé.

Points clés

1. Fonctionnalités du flacon et des cas d'utilisation Aperçu: Cet article présente Flask, en se concentrant sur ses fonctionnalités légères et flexibles et son applicabilité à une variété de projets Web. Il explore la simplicité de Flask, le support prolongé, les caractéristiques clés et les cas d'utilisation pratiques tels que le prototypage, les API reposants et les applications de commerce électronique.
2. Analyse comparative avec Django: Cet article compare le flacon avec Django, mettant l'accent sur l'approche de Flak-Framework, qui fournit les outils nécessaires sans structures complexes, ce qui en fait un besoin pour le minimalisme et l'approche autonome. .
3. Commencez par Flask: Cet article fournit un guide étape par étape sur la configuration d'un environnement de développement FLASK, la création et l'exécution d'applications de base et la mise en œuvre des fonctionnalités du flacon dans le routage, les modèles, les formulaires et les extensions.

Qu'est-ce que le flacon?

FLASK est un cadre Web miniature écrit en Python pour développer des applications Web. Il est construit sur un concept simple: garder les choses simples et légères, offrant aux développeurs les outils les plus importants dont ils ont besoin pour créer des applications Web sans complexité inutile.

Il est construit sur la boîte à outils WerkzEug WSGI, qui fournit les fonctionnalités du serveur Web requises pour gérer les demandes et les réponses, ainsi que le moteur de modèle Jinja2, qui permet à Flask de gérer les modèles HTML, permettant aux développeurs de créer des applications Web dynamiques.

Voici quelques fonctionnalités clés qui font de Flask un excellent cadre:

• Il a une API simple pour créer des demandes de routage et de gestion Web.
• Le modèle de modèle Jinja prend en charge les modèles HTML, permettant aux développeurs de créer facilement des pages Web.
• Puisqu'il prend en charge les extensions tierces, elle est très évolutive, afin que les développeurs puissent installer des extensions en fonction des besoins du projet.
• Il regroupe un serveur de développement qui permet des tests faciles et un débogage des applications.

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

Avantages du ballon

Laissez-nous maintenant regarder de plus près certains des avantages de l'utilisation du flacon en développement.

simplicité. La philosophie de conception de Flask met l'accent sur la simplicité, ce qui facilite les développeurs de tout niveau de le comprendre et de l'utiliser. Cela signifie également que les développeurs ont une courbe d'apprentissage très faible car ils n'ont qu'à apprendre quelques concepts et API pour commencer à créer des applications Web.

flexibilité. Les fonctionnalités miniatures de FLASK - fournissant uniquement les fonctionnalités de base du framework Web - ont constitué des développeurs pour les personnaliser et les étendre en utilisant des extensions FLASK ou des bibliothèques tierces pour répondre à leurs besoins.

Document. La documentation FLASK est très complète, couvrant le contenu des sujets de base aux sujets avancés, ce qui permet aux développeurs d'apprendre facilement à utiliser le cadre.

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

Développement rapide. La simplicité et la flexibilité de FLASK réduisent le code de passe-partout requis pour configurer votre application, permettant aux développeurs de commencer rapidement.

FLASK est utilisé de nombreuses manières intéressantes sur le Web. Certains exemples notables incluent:

• pgadmin. L'interface de gestion de Postgres s'exécute sur les instances FLASK, offrant aux développeurs une interface où ils peuvent gérer leur base de données Postgres.
• Twilio. Il s'agit d'une plate-forme de communication qui utilise Flask dans ses multiples API.
• Pinterest. Cette application de partage de photos utilise Flask dans sa pile de développement Web, permettant à son équipe de créer facilement des fonctionnalités et des intégrations personnalisées.

quand utiliser le flacon

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

• Conception du prototype. Sa facilité d'utilisation et sa flexibilité en font un excellent choix pour créer rapidement des prototypes, permettant aux développeurs de construire et de tester rapidement de nouvelles fonctionnalités.
• Créez une API RESTful. Sa propre API simple facilite la création et le traitement des demandes HTTP.
• Application de commerce électronique. Il est parfait pour créer des marchés en ligne et des plates-formes de commerce électronique.
• financier. Il peut être utilisé pour créer des applications financières, y compris la gestion des comptes, le traitement des transactions et le suivi des investissements.
• ai. Il fournit un moyen utile et simple de construire et de déployer des modèles de formation en IA.

Lors de ne pas utiliser de flacon

Alors que Flask est un excellent cadre et présente de nombreux avantages et fonctionnalités puissantes, dans certains cas, ces fonctionnalités peuvent y être préjudiciables. Explorons certains projets plus adaptés à d'autres types de cadres.

Projets qui nécessitent des fonctions intégrées. En tant que mini-framework, Flask ne fournit que les pièces principales nécessaires pour créer des applications Web. Si un projet nécessite, par exemple, une interface administrative, une authentification ou un ORM, alors Django est un meilleur choix.

Projets avec des exigences de sécurité strictes. Étant donné que Flask est un cadre flexible, nous devons compter sur des extensions tierces pour atteindre un certain niveau de sécurité dans nos applications. Bien que cela fonctionne certainement, il est préférable de compter sur un cadre plus testé qui adopte une approche plus sûre, comme la tornade ou Twisted.

Projets qui appliquent certaines normes de codage. En raison de la flexibilité de Flask, le développement d'applications permet aux développeurs de créer des applications comme ils le souhaitent. Cependant, des cadres comme Django garantissent que les développeurs suivent des conventions spécifiques, ce qui signifie que les développeurs peuvent facilement passer d'un projet à un autre.

Configurer l'environnement de développement du flacon

Voyons comment démarrer avec FLASK, de la configuration de l'environnement de développement, pour installer et enfin un lancement d'une application minimale.

Prérequis

Python doit être installé sur la machine de développement. Voici des instructions sur la façon d'installer Python (bien que nous puissions l'avoir installé).

Créer un environnement virtuel

L'environnement virtuel est un environnement python isolé où nous pouvons installer des packages pour un projet spécifique sans affecter l'installation globale de Python. (Ce qui suit est une discussion supplémentaire sur les raisons pour lesquelles un environnement virtuel est utile.) Il existe différents packages qui peuvent créer des environnements virtuels dans Python, tels que VirtualEnv, Venv ou Conda.

Dans cet article, nous utiliserons VirtualEnv. Nous pouvons l'installer en utilisant la commande suivante:

<code>pip install virtualenv</code>

Après l'installation de VirtualEnv, nous pouvons créer un répertoire où résidera notre application FLASK. Nous pouvons nommer le répertoire comme nous le souhaitons - sauf le flacon, car cela entraînera des conflits. Nous le nommerons flask_intro:

<code>mkdir flask_intro</code>

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

<code>cd flask_intro</code>

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

<code>virtualenv myenv</code>

La commande ci-dessus crée un environnement virtuel et le nommez Myenv. Activons-le afin que nous puissions y installer Flask. Pour activer un environnement virtuel sur Linux ou MacOS, utilisez la commande suivante:

<code>. myenv/bin/activate</code>

Sur Windows, utilisez cette commande:

<code>. myenv\Scripts\activate</code>

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

<code>(myenv)/~(path to your project directory)$</code>

Dans l'environnement virtuel activé, nous pouvons continuer à installer Flask en utilisant la commande suivante:

<code>pip install Flask</code>

Lorsque le ballon est installé, allons-y et créons une application minimale. Nous allons créer un module pour enregistrer notre application Flask. Pour plus de simplicité, nous l'appelons bonjour.py. Sur Linux ou MacOS, nous pouvons créer ce fichier dans notre répertoire FLASK_INTRO en utilisant la commande suivante:

<code>touch hello.py</code>

La commande ci-dessus crée un fichier nommé hello.py. Nous pouvons également utiliser l'environnement de développement pour créer ce fichier. Après avoir créé le fichier, mettez le code suivant et enregistrez:

<code># hello.py
from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello_world():
    return 'Hello, World!'</code>

Dans le code ci-dessus, nous importons la classe FLASK à partir du module FLASK, puis créons une instance FLASK nommée application et passons la variable __name__.

Ensuite, nous avons le décorateur de route @ app.Route ("/"), ce qui signifie que la fonction hello_world () sera licenciée après que quelqu'un accède à la route racine de l'application.

Nous pouvons exécuter l'application de plusieurs façons, alors regardons certains. La première méthode consiste à fournir plusieurs paramètres à la commande FLASK: --App, puis à enregistrer le nom du module que notre application FLASK puis à exécuter. Voir ci-dessous:

<code>flask –app <the module="" name="" of="" your=""> run</the></code>

Exécutez notre exemple d'application avec l'exemple ci-dessus:

<code>pip install virtualenv</code>

Cela exécutera notre application sur le port par défaut 5000, de sorte que l'application sera disponible sur http: // localhost: 5000 / ou http://127.0.0.1:5000/. Si nous voulons que l'application soit disponible sur d'autres ports, nous pouvons spécifier le port à l'aide de l'option -p ou --port. Par exemple:

<code>mkdir flask_intro</code>

Cela exécutera le serveur sur le port 8080. Une autre façon d'exécuter l'application est d'utiliser simplement la commande FLASK RUN. Cependant, afin de pouvoir le faire, nous devons indiquer à FLUKE le nom du module qui contient l'instance FLASK, ce que nous faisons en définissant la variable d'environnement FLASK_APP. Ainsi, dans notre cas, l'application FLASK est incluse dans un fichier appelé hello.py. Nous pouvons donc le définir comme ceci:

<code>cd flask_intro</code>

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

<code>virtualenv myenv</code>

En utilisant ce code, nous exécutons maintenant une application Web. Cela démontre la philosophie de base du flacon: nous n'avons pas besoin de beaucoup de code passe-partout pour que les choses se passent bien. Cependant, l'application que nous avons créée ci-dessus n'est pas très pratique ou utile, car elle ne fait que la chaîne "Hello World!" Sur notre page Web. Pour faire quelque chose de plus utile, nous pouvons nous tourner vers les modèles. Ensuite, nous verrons comment les gérer.

Modèle de flacon

Le modèle FLASK est un moyen de créer des pages Web dynamiques qui peuvent afficher différents contenus en fonction de divers facteurs, tels que les données d'une base de données ou d'une entrée utilisateur. Les modèles dans le ballon sont une combinaison de HTML et d'espaces réservés spéciaux (appelés variables de modèle) qui sont remplacés par des valeurs réelles au moment de l'exécution.

Le modèle

est stocké dans le répertoire des modèles. Par conséquent, pour utiliser des modèles, nous devons importer la méthode Render_Template () de Flask. La méthode render_template () accepte le nom du modèle et toutes les données facultatives qui doivent être transmises au modèle.

Regardons un exemple de fonction qui utilise des modèles pour rendre les pages Web:

<code>. myenv/bin/activate</code>

Dans l'exemple ci-dessus, nous avons une fonction de vue - index () - qui est liée à l'URL racine ("/") via le décorateur @ app.Route (). La fonction a deux variables, titre et message. Enfin, nous passons le modèle index.html à 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 dans le répertoire des modèles. Par conséquent, le modèle ressemblera à ceci:

<code>. myenv\Scripts\activate</code>

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

Les modèles

peuvent également contenir une logique plus complexe, comme si les instructions et pour les boucles, qui permettent de générer des pages plus dynamiques.

Par conséquent, les modèles dans Flask offrent aux développeurs une option très puissante pour créer des pages Web dynamiques remplies d'informations générées par l'utilisateur.

routage du flacon

La plupart des applications Web auront plusieurs URL, nous devons donc avoir un moyen de savoir quelle fonction gère quelle URL. Dans Flask, ce mappage est appelé routage - le processus de liaison ou de cartographie des URL pour afficher les fonctions. Lind URL pour afficher les fonctions permettent à l'application de gérer différents types de demandes, telles que Get, Post, Put, Supprimer, etc. Il permet également à l'application de répondre à plusieurs demandes de différents clients.

Pour configurer l'itinéraire dans Flask, nous utilisons le décorateur de route (). Le décorateur lie l'URL à la fonction de vue - donc lorsque l'utilisateur accède à une URL qui existe dans l'application, Flask déclenche la fonction de vue associée pour gérer la demande.

Prenons un exemple:

<code>pip install virtualenv</code>

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

Jusqu'à présent, même si ces exemples renvoient différentes pages, ils utilisent tous uniquement les demandes HTTP. Pour pouvoir traiter toute demande spécifique, nous pouvons spécifier la méthode HTTP en tant que paramètre facultatif au décorateur de route ().

Regardons un exemple de demande de put:

<code>mkdir flask_intro</code>

Dans cet exemple, nous définissons une route pour gérer les demandes de put pour mettre à jour les détails de l'utilisateur compte tenu de son user_id. Nous utilisons dans notre itinéraire pour indiquer que l'ID utilisateur doit être un entier.

Dans la fonction update_user (), nous utilisons la méthode request.get_json () pour obtenir des données utilisateur à partir du corps de la demande. Nous effectuons certaines actions sur les données utilisateur, telles que la mise à jour des utilisateurs dans la base de données, puis renvoyant une réponse indiquant le succès ou l'échec et un code d'état HTTP (dans ce cas 200, indiquant le succès).

En général, le routage permet à Flask de pouvoir gérer différents types de demandes et permet à nos applications de traiter et de traiter les données de différentes manières en fonction des URL accessibles par l'utilisateur.

Formes et vérification du flacon

En plus d'afficher des données pour les utilisateurs, le modèle de file d'attente peut également recevoir une entrée utilisateur pour un traitement ou un stockage ultérieur. Pour ce faire, 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 fournit un moyen flexible et puissant de traiter les données des formulaires et d'effectuer la validation. Cependant, la bibliothèque ne fait pas partie d'une installation standard du flacon, nous devons donc l'installer en utilisant la commande suivante:

<code>cd flask_intro</code>

Après avoir installé WTFORMS, pour utiliser des formulaires dans FLASK, nous devons définir une classe de formulaire qui héritera de flask_wtf.flaskform. Cette classe contiendra des champs sur le formulaire et toutes les règles de validation qui devraient leur être appliquées.

Regardons un exemple de formulaire de connexion:

<code>virtualenv myenv</code>

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

Après avoir défini la classe de formulaire, nous pouvons l'utiliser dans la fonction de vision de connexion pour rendre le formulaire et traiter les données de formulaire soumises par l'utilisateur. Regardons un exemple de fonction de vue:

<code>pip install virtualenv</code>

Dans l'exemple ci-dessus, nous avons une vue de connexion qui accepte deux méthodes HTTP (obtenir et publier), donc lorsque l'utilisateur accède à l'URL à partir du navigateur, la connexion se rendra comme un formulaire HTML à l'aide de la méthode Render_Template, lorsque l'utilisateur Soumet le formulaire lorsque nous utilisons la méthode valide_on_submit pour vérifier si le formulaire est valide. Si le formulaire est valide, nous accéderons à l'e-mail et au mot de passe.

Le formulaire Login.html peut ressembler à ceci:

<code>mkdir flask_intro</code>

Le modèle ci-dessus rendra les champs e-mail et mot de passe et leurs étiquettes, ainsi qu'un bouton de soumission avec le texte "Connexion". Le champ Form.csrf_token est inclus pour empêcher les attaques de contrefaçon de demande de site croisé (CSRF). La boucle {% pour%} est utilisée pour afficher toutes les erreurs de validation qui peuvent se produire.

En utilisant des formulaires FLASK, nous avons un moyen puissant de traiter la saisie des utilisateurs et nous pourrons vérifier les données qu'ils ont entrées.

Extension du flacon

Comme nous pouvons le voir, Flask est un cadre miniature qui ne contient que les pièces les plus importantes nécessaires pour créer une application Web. Cependant, si nous devons ajouter les fonctionnalités que Flask elle-même ne fournit pas, nous devons ajouter des packages à l'installation. Les extensions de flacon sont notre façon de fournir cette fonctionnalité supplémentaire. Nous pouvons simplement installer les packages requis. La communauté Flask a créé de nombreuses extensions.

Voici quelques-unes des extensions les plus populaires:

• FLASK-SQLALCHEMY: Fournit l'intégration avec la boîte à outils SQLALCHEMY pour interagir facilement avec la base de données.
• Flask-Login: fournit une authentification des utilisateurs et une gestion de session pour Flask.
• Flask-Mail: fournit une interface simple pour envoyer des e-mails de Flask.

La communauté Flask a créé des centaines d'extensions pour gérer différentes fonctionnalités. L'utilisation d'extensions est généralement simple. Tout d'abord, nous devons installer les extensions requises en utilisant PIP.

Regardons un exemple à l'aide de Flask-Sqlalchemy. Tout d'abord, nous devons l'installer:

<code>cd flask_intro</code>

Ensuite, nous devons le configurer. Par exemple:

<code>virtualenv myenv</code>

Dans l'exemple ci-dessus, nous avons un modèle utilisateur avec le nom d'utilisateur et les champs de messagerie. Nous avons également configuré SQLALCHEMY_DATABASE_URI, nous demandant d'utiliser la base de données SQLite située dans Example.DB. Après la configuration, nous pouvons désormais utiliser des objets DB pour 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 suit:

<code>. myenv/bin/activate</code>

Avec l'extension FLASK, nos applications peuvent avoir plus de fonctionnalités qu'elles ne seraient normalement implémentées avec Core Flask.

Conclusion

Dans cet article, nous introduisons Flask, un framework Web Python léger et flexible. Nous discutons des avantages de l'utilisation de Flask pour le développement Web, y compris sa simplicité, sa flexibilité et sa facilité d'utilisation. Nous avons également couvert comment configurer un environnement de développement, créer des itinéraires, utiliser des modèles, traiter les formulaires et utiliser des extensions telles que Flask-Sqlalchemy.

Dans l'ensemble, Flask est un excellent choix pour créer des applications Web de toute taille, des petits projets personnels aux grandes applications commerciales. Il est facile à apprendre et à utiliser, mais offre également des fonctionnalités avancées à travers ses nombreuses extensions.

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

• Document FLASK
• FLASK MEGA-TUTORIAL PAR MIGUEL GRINBERG
• Miguel Grinberg's Flask Web Development
• Un tutoriel d'application FLASK simple
• Real Python Flask Tutorial

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

Vous pouvez également afficher ces plaques de chaudières FLASK gratuites pour créer votre première application Web.

FAQ sur Flask (Python Framework)

Qu'est-ce que le flacon?

FLASK est un cadre Web miniature pour Python. Il est conçu pour être léger et facile à utiliser, ce qui en fait un excellent choix pour développer des applications Web et des API.

Comment installer Flask?

Vous pouvez installer Flask à l'aide de PIP (Python's Package Manager). Utilisez la commande <code>pip install Flask</code> pour installer Flask sur votre système.

Quelles sont les principales caractéristiques de Flask?

FLASK est connu pour sa simplicité, sa flexibilité et son minimalisme. Il fournit des fonctionnalités telles que le routage d'URL, le traitement des demandes et le rendu des modèles, tout en permettant aux développeurs de sélectionner et d'intégrer d'autres composants au besoin.

Comment Flask se compare-t-il à d'autres frameworks Web Python tels que Django?

FLASK est un cadre miniature, tandis que Django est un cadre Web complet. Flask offre une plus grande flexibilité et liberté de choisir vos composants, tandis que Django est livré avec de nombreuses fonctionnalités et conventions intégrées.

Puis-je construire une API reposante avec Flask?

Oui, Flask est idéal pour construire des API RESTful. Sa simplicité et sa prise en charge des méthodes HTTP en font un choix populaire pour créer des points de terminaison API.

Le ballon est-il adapté aux grandes applications Web?

Le flacon peut être utilisé pour les grandes applications, mais il peut nécessiter plus de configuration manuelle et d'intégration des composants que les cadres complètes comme Django.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!