Flacon - Guide rapide

Qu'est-ce que Web Framework?

Web Application Framework ou simplement Web Framework représente une collection de bibliothèques et de modules qui permet à un développeur d'applications Web d'écrire des applications sans avoir à se soucier des détails de bas niveau tels que les protocoles, la gestion des threads, etc.

Qu'est-ce que Flask?

Flask est un framework d'application Web écrit en Python. Il est développé parArmin Ronacher, qui dirige un groupe international de passionnés de Python nommé Pocco. Flask est basé sur la boîte à outils Werkzeug WSGI et le moteur de modèles Jinja2. Les deux sont des projets Pocco.

WSGI

L'interface de passerelle de serveur Web (WSGI) a été adoptée comme norme pour le développement d'applications Web Python. WSGI est une spécification pour une interface universelle entre le serveur Web et les applications Web.

Werkzeug

Il s'agit d'une boîte à outils WSGI, qui implémente des requêtes, des objets de réponse et d'autres fonctions utilitaires. Cela permet de créer un framework Web par-dessus. Le framework Flask utilise Werkzeug comme l'une de ses bases.

Jinja2

Jinja2 est un moteur de création de modèles populaire pour Python. Un système de modèles Web combine un modèle avec une certaine source de données pour rendre des pages Web dynamiques.

Flask est souvent appelé un micro-cadre. Il vise à garder le cœur d'une application simple mais extensible. Flask n'a pas de couche d'abstraction intégrée pour la gestion de la base de données, ni de support de validation. Au lieu de cela, Flask prend en charge les extensions pour ajouter de telles fonctionnalités à l'application. Certaines des extensions Flask populaires sont abordées plus loin dans le didacticiel.

Prérequis

Python 2.6 ou supérieur est généralement requis pour l'installation de Flask. Bien que Flask et ses dépendances fonctionnent bien avec Python 3 (à partir de Python 3.3), de nombreuses extensions Flask ne le prennent pas en charge correctement. Par conséquent, il est recommandé que Flask soit installé sur Python 2.7.

Installer virtualenv pour l'environnement de développement

virtualenvest un constructeur d'environnement virtuel Python. Il aide un utilisateur à créer plusieurs environnements Python côte à côte. Ainsi, il peut éviter les problèmes de compatibilité entre les différentes versions des bibliothèques.

La commande suivante installe virtualenv

pip install virtualenv

Cette commande nécessite des privilèges d'administrateur. Ajoutersudo avant pipsur Linux / Mac OS. Si vous êtes sous Windows, connectez-vous en tant qu'administrateur. Sur Ubuntuvirtualenv peut être installé à l'aide de son gestionnaire de paquets.

Sudo apt-get install virtualenv

Une fois installé, un nouvel environnement virtuel est créé dans un dossier.

mkdir newproj
cd newproj
virtualenv venv

Pour activer l'environnement correspondant, sur Linux/OS X, utilisez ce qui suit -

venv/bin/activate

Sur Windows, suivant peut être utilisé

venv\scripts\activate

Nous sommes maintenant prêts à installer Flask dans cet environnement.

pip install Flask

La commande ci-dessus peut être exécutée directement, sans environnement virtuel pour une installation à l'échelle du système.

Afin de tester Flask installation, tapez le code suivant dans l'éditeur comme Hello.py

from flask import Flask
app = Flask(__name__)

@app.route('/')
def hello_world():
   return 'Hello World’

if __name__ == '__main__':
   app.run()

L'importation du module flask dans le projet est obligatoire. Un objet de la classe Flask est notreWSGI application.

Le constructeur de flacon prend le nom de current module (__name__) comme argument.

le route() La fonction de la classe Flask est un décorateur, qui indique à l'application quelle URL doit appeler la fonction associée.

app.route(rule, options)

le rule Le paramètre représente la liaison d'URL avec la fonction.
le options est une liste de paramètres à transmettre à l'objet Rule sous-jacent.

Dans l'exemple ci-dessus, ‘/’ L'URL est liée à hello_world()fonction. Par conséquent, lorsque la page d'accueil du serveur Web est ouverte dans le navigateur, la sortie de cette fonction sera rendue.

Finalement, le run() La méthode de la classe Flask exécute l'application sur le serveur de développement local.

app.run(host, port, debug, options)

Tous les paramètres sont facultatifs

N ° Sr.	Paramètres et description
1	host Nom d'hôte à écouter. La valeur par défaut est 127.0.0.1 (localhost). Défini sur «0.0.0.0» pour que le serveur soit disponible en externe
2	port La valeur par défaut est 5000
3	debug La valeur par défaut est false. S'il est défini sur true, fournit des informations de débogage
4	options À transmettre au serveur Werkzeug sous-jacent.

Le ci-dessus donné Python Le script est exécuté à partir du shell Python.

Python Hello.py

Un message dans le shell Python vous informe que

* Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

Ouvrez l'URL ci-dessus (localhost:5000) dans le navigateur. ‘Hello World’ message sera affiché dessus.

Mode débogage

UNE Flask l'application est lancée en appelant le run()méthode. Cependant, pendant que l'application est en cours de développement, elle doit être redémarrée manuellement pour chaque modification du code. Pour éviter ce désagrément, activezdebug support. Le serveur se rechargera ensuite si le code change. Il fournira également un débogueur utile pour suivre les erreurs, le cas échéant, dans l'application.

le Debug le mode est activé en définissant le debug propriété du application objecter à True avant d'exécuter ou de transmettre le paramètre de débogage au run() méthode.

app.debug = True
app.run()
app.run(debug = True)

Les infrastructures Web modernes utilisent la technique de routage pour aider un utilisateur à se souvenir des URL d'application. Il est utile d'accéder directement à la page souhaitée sans avoir à naviguer depuis la page d'accueil.

le route()decorator dans Flask est utilisé pour lier l'URL à une fonction. Par exemple -

@app.route(‘/hello’)
def hello_world():
   return ‘hello world’

Ici, URL ‘/hello’ la règle est liée à la hello_world()fonction. En conséquence, si un utilisateur visitehttp://localhost:5000/hello URL, la sortie du hello_world() La fonction sera rendue dans le navigateur.

le add_url_rule() fonction d'un objet application est également disponible pour lier une URL avec une fonction comme dans l'exemple ci-dessus, route() est utilisé.

Le but d'un décorateur est également servi par la représentation suivante -

def hello_world():
   return ‘hello world’
app.add_url_rule(‘/’, ‘hello’, hello_world)

Il est possible de créer une URL de manière dynamique, en ajoutant des parties variables au paramètre de règle. Cette partie variable est marquée comme<variable-name>. Il est passé en tant qu'argument mot-clé à la fonction à laquelle la règle est associée.

Dans l'exemple suivant, le paramètre de règle de route() décorateur contient <name> partie variable attachée à l'URL ‘/hello’. Par conséquent, si lehttp://localhost:5000/hello/TutorialsPoint est entré comme un URL dans le navigateur, ‘TutorialPoint’ sera fourni à hello() fonction comme argument.

from flask import Flask
app = Flask(__name__)

@app.route('/hello/<name>')
def hello_name(name):
   return 'Hello %s!' % name

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

Enregistrez le script ci-dessus sous hello.pyet exécutez-le à partir du shell Python. Ensuite, ouvrez le navigateur et entrez l'URLhttp://localhost:5000/hello/TutorialsPoint.

La sortie suivante sera affichée dans le navigateur.

Hello TutorialsPoint!

En plus de la partie variable de chaîne par défaut, les règles peuvent être construites à l'aide des convertisseurs suivants -

N ° Sr.	Convertisseurs et description
1	int accepte un entier
2	float Pour une valeur à virgule flottante
3	path accepte les barres obliques utilisées comme séparateur de répertoire

Dans le code suivant, tous ces constructeurs sont utilisés.

from flask import Flask
app = Flask(__name__)

@app.route('/blog/<int:postID>')
def show_blog(postID):
   return 'Blog Number %d' % postID

@app.route('/rev/<float:revNo>')
def revision(revNo):
   return 'Revision Number %f' % revNo

if __name__ == '__main__':
   app.run()

Exécutez le code ci-dessus à partir de Python Shell. Visitez l'URLhttp://localhost:5000/blog/11 dans le navigateur.

Le nombre donné est utilisé comme argument du show_blog()fonction. Le navigateur affiche la sortie suivante -

Blog Number 11

Entrez cette URL dans le navigateur - http://localhost:5000/rev/1.1

le revision()function prend le nombre à virgule flottante comme argument. Le résultat suivant apparaît dans la fenêtre du navigateur -

Revision Number 1.100000

Les règles d'URL de Flask sont basées sur Werkzeug’smodule de routage. Cela garantit que les URL formées sont uniques et basées sur les précédents établis par Apache.

Considérez les règles définies dans le script suivant -

from flask import Flask
app = Flask(__name__)

@app.route('/flask')
def hello_flask():
   return 'Hello Flask'

@app.route('/python/')
def hello_python():
   return 'Hello Python'

if __name__ == '__main__':
   app.run()

Les deux règles semblent similaires, mais dans la deuxième règle, barre oblique de fin (/)est utilisé. En conséquence, il devient une URL canonique. Par conséquent, en utilisant/python ou /python/renvoie la même sortie. Cependant, dans le cas de la première règle,/flask/ L'URL entraîne 404 Not Found page.

le url_for()La fonction est très utile pour créer dynamiquement une URL pour une fonction spécifique. La fonction accepte le nom d'une fonction comme premier argument, et un ou plusieurs arguments de mot-clé, chacun correspondant à la partie variable de l'URL.

Le script suivant illustre l'utilisation de url_for() fonction.

from flask import Flask, redirect, url_for
app = Flask(__name__)

@app.route('/admin')
def hello_admin():
   return 'Hello Admin'

@app.route('/guest/<guest>')
def hello_guest(guest):
   return 'Hello %s as Guest' % guest

@app.route('/user/<name>')
def hello_user(name):
   if name =='admin':
      return redirect(url_for('hello_admin'))
   else:
      return redirect(url_for('hello_guest',guest = name))

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

Le script ci-dessus a une fonction user(name) qui accepte une valeur à son argument à partir de l'URL.

le User() la fonction vérifie si un argument reçu correspond ‘admin’ou pas. S'il correspond, l'application est redirigée vers lehello_admin() fonction utilisant url_for(), sinon au hello_guest() fonction en lui passant l'argument reçu en tant que paramètre invité.

Enregistrez le code ci-dessus et exécutez à partir du shell Python.

Ouvrez le navigateur et entrez l'URL sous la forme - http://localhost:5000/user/admin

La réponse de l'application dans le navigateur est -

Hello Admin

Entrez l'URL suivante dans le navigateur - http://localhost:5000/user/mvl

La réponse de l'application change maintenant en -

Hello mvl as Guest

Le protocole HTTP est la base de la communication de données sur le World Wide Web. Différentes méthodes de récupération de données à partir de l'URL spécifiée sont définies dans ce protocole.

Le tableau suivant résume les différentes méthodes http -

N ° Sr.	Méthodes et description
1	GET Envoie les données sous forme non chiffrée au serveur. Méthode la plus courante.
2	HEAD Identique à GET, mais sans corps de réponse
3	POST Utilisé pour envoyer des données de formulaire HTML au serveur. Les données reçues par la méthode POST ne sont pas mises en cache par le serveur.
4	PUT Remplace toutes les représentations actuelles de la ressource cible par le contenu téléchargé.
5	DELETE Supprime toutes les représentations actuelles de la ressource cible données par une URL

Par défaut, la route Flask répond au GETdemandes. Cependant, cette préférence peut être modifiée en fournissant un argument de méthodes àroute() décorateur.

Afin de démontrer l'utilisation de POST méthode dans le routage d'URL, créons d'abord un formulaire HTML et utilisons le POST méthode pour envoyer des données de formulaire à une URL.

Enregistrez le script suivant sous login.html

<html>
   <body>
      <form action = "http://localhost:5000/login" method = "post">
         <p>Enter Name:</p>
         <p><input type = "text" name = "nm" /></p>
         <p><input type = "submit" value = "submit" /></p>
      </form>
   </body>
</html>

Entrez maintenant le script suivant dans le shell Python.

from flask import Flask, redirect, url_for, request
app = Flask(__name__)

@app.route('/success/<name>')
def success(name):
   return 'welcome %s' % name

@app.route('/login',methods = ['POST', 'GET'])
def login():
   if request.method == 'POST':
      user = request.form['nm']
      return redirect(url_for('success',name = user))
   else:
      user = request.args.get('nm')
      return redirect(url_for('success',name = user))

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

Une fois le serveur de développement démarré, ouvrez login.html dans le navigateur, saisissez le nom dans le champ de texte et cliquez sur Submit.

Les données du formulaire sont POSTÉES à l'URL dans la clause action de la balise form.

http://localhost/login est mappé au login()fonction. Puisque le serveur a reçu des données parPOST méthode, la valeur du paramètre 'nm' obtenue à partir des données de formulaire est obtenue par -

user = request.form['nm']

Il est passé à ‘/success’URL en tant que partie variable. Le navigateur affiche unwelcome message dans la fenêtre.

Remplacez le paramètre de méthode par ‘GET’ dans login.htmlet ouvrez-le à nouveau dans le navigateur. Les données reçues sur le serveur proviennent duGETméthode. La valeur du paramètre 'nm' est maintenant obtenue par -

User = request.args.get(‘nm’)

Ici, argsest un objet dictionnaire contenant une liste de paires de paramètres de formulaire et sa valeur correspondante. La valeur correspondant au paramètre 'nm' est transmise à l'URL '/ success' comme précédemment.

Il est possible de renvoyer la sortie d'une fonction liée à une certaine URL sous forme de HTML. Par exemple, dans le script suivant,hello() la fonction rendra ‘Hello World’ avec <h1> étiquette qui y est attachée.

from flask import Flask
app = Flask(__name__)

@app.route('/')
def index():
   return '<html><body><h1>Hello World</h1></body></html>'

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

Cependant, générer du contenu HTML à partir du code Python est fastidieux, en particulier lorsque des données variables et des éléments du langage Python tels que des conditions ou des boucles doivent être placés. Cela nécessiterait des échappements fréquents du HTML.

C'est là que l'on peut profiter de Jinja2moteur de template, sur lequel Flask est basé. Au lieu de renvoyer du code HTML à partir de la fonction, un fichier HTML peut être rendu par lerender_template() fonction.

from flask import Flask
app = Flask(__name__)

@app.route('/')
def index():
   return render_template(‘hello.html’)

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

Flask essaiera de trouver le fichier HTML dans le dossier des modèles, dans le même dossier dans lequel ce script est présent.

Dossier d'application
- Hello.py
- templates
  - hello.html

Le terme ‘web templating system’fait référence à la conception d'un script HTML dans lequel les données variables peuvent être insérées dynamiquement. Un système de modèle Web comprend un moteur de modèle, une sorte de source de données et un processeur de modèle.

Utilisations du flacon Jinja2moteur de modèle. Un modèle Web contient des espaces réservés de syntaxe HTML intercalés pour les variables et les expressions (dans ce cas les expressions Python) qui sont des valeurs remplacées lorsque le modèle est rendu.

Le code suivant est enregistré sous hello.html dans le dossier des modèles.

<!doctype html>
<html>
   <body>
   
      <h1>Hello {{ name }}!</h1>
      
   </body>
</html>

Ensuite, exécutez le script suivant à partir du shell Python.

from flask import Flask, render_template
app = Flask(__name__)

@app.route('/hello/<user>')
def hello_name(user):
   return render_template('hello.html', name = user)

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

Lorsque le serveur de développement démarre, ouvrez le navigateur et entrez l'URL sous la forme - http://localhost:5000/hello/mvl

le variable une partie de l'URL est insérée à {{ name }} espace réservé.

le Jinja2 Le moteur de modèle utilise les délimiteurs suivants pour s'échapper du HTML.

{% ...%} pour les déclarations
{{...}} pour que les expressions s'impriment dans la sortie du modèle
{# ... #} pour les commentaires non inclus dans la sortie du modèle
# ... ## pour les instructions de ligne

Dans l'exemple suivant, l'utilisation d'une instruction conditionnelle dans le modèle est illustrée. La règle d'URL vers lehello()La fonction accepte le paramètre entier. Il est transmis auhello.htmlmodèle. À l'intérieur, la valeur du nombre reçu (points) est comparée (supérieure ou inférieure à 50) et en conséquence le HTML est rendu conditionnellement.

Le script Python est le suivant -

from flask import Flask, render_template
app = Flask(__name__)

@app.route('/hello/<int:score>')
def hello_name(score):
   return render_template('hello.html', marks = score)

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

Script de modèle HTML de hello.html est comme suit -

<!doctype html>
<html>
   <body>
      {% if marks>50 %}
         <h1> Your result is pass!</h1>
      {% else %}
         <h1>Your result is fail</h1>
      {% endif %}
   </body>
</html>

Notez que les instructions conditionnelles if-else et endif sont entourés d'un délimiteur {%..%}.

Exécutez le script Python et visitez l'URL http://localhost/hello/60 et alors http://localhost/hello/30 pour voir la sortie du HTML changer conditionnellement.

Les constructions de boucle Python peuvent également être utilisées dans le modèle. Dans le script suivant, leresult() la fonction envoie un objet dictionnaire au modèle results.html quand URL http://localhost:5000/result est ouvert dans le navigateur.

La partie Template de result.html emploie un for loop pour rendre les paires clé et valeur d'un objet dictionnaire result{} sous forme de cellules d'un tableau HTML.

Exécutez le code suivant à partir du shell Python.

from flask import Flask, render_template
app = Flask(__name__)

@app.route('/result')
def result():
   dict = {'phy':50,'che':60,'maths':70}
   return render_template('result.html', result = dict)

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

Enregistrez le script HTML suivant sous result.html dans le dossier des modèles.

<!doctype html>
<html>
   <body>
      <table border = 1>
         {% for key, value in result.items() %}
            <tr>
               <th> {{ key }} </th>
               <td> {{ value }} </td>
            </tr>
         {% endfor %}
      </table>
   </body>
</html>

Ici, à nouveau les instructions Python correspondant à la For boucle sont entourés de {% ..%} alors que les expressions key and value sont mis à l'intérieur {{ }}.

Une fois le développement lancé, ouvrez http://localhost:5000/result dans le navigateur pour obtenir la sortie suivante.

Une application Web nécessite souvent un fichier statique tel qu'un javascript fichier ou un CSSfichier prenant en charge l'affichage d'une page Web. Habituellement, le serveur Web est configuré pour les servir pour vous, mais pendant le développement, ces fichiers sont servis à partir du dossier statique de votre package ou à côté de votre module et il sera disponible sur/static sur l'application.

Un point de terminaison spécial «statique» est utilisé pour générer une URL pour les fichiers statiques.

Dans l'exemple suivant, un javascript fonction définie dans hello.js est appelé OnClick événement du bouton HTML dans index.html, qui est rendu sur ‘/’ URL de l'application Flask.

from flask import Flask, render_template
app = Flask(__name__)

@app.route("/")
def index():
   return render_template("index.html")

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

Le script HTML de index.html est donnée ci-dessous.

<html>
   <head>
      <script type = "text/javascript" 
         src = "{{ url_for('static', filename = 'hello.js') }}" ></script>
   </head>
   
   <body>
      <input type = "button" onclick = "sayHello()" value = "Say Hello" />
   </body>
</html>

hello.js contient sayHello() fonction.

function sayHello() {
   alert("Hello World")
}

Les données de la page Web d'un client sont envoyées au serveur en tant qu'objet de requête global. Afin de traiter les données de la demande, elles doivent être importées depuis le module Flask.

Les attributs importants de l'objet de requête sont répertoriés ci-dessous -

Form - Il s'agit d'un objet dictionnaire contenant des paires clé et valeur de paramètres de formulaire et leurs valeurs.
args - contenu analysé de la chaîne de requête qui fait partie de l'URL après le point d'interrogation (?).
Cookies - objet dictionnaire contenant les noms et valeurs des cookies.
files - les données relatives au fichier téléchargé.
method - méthode de demande actuelle.

Nous avons déjà vu que la méthode http peut être spécifiée dans la règle URL. leForm les données reçues par la fonction déclenchée peuvent les collecter sous la forme d'un objet dictionnaire et les transmettre à un modèle pour les rendre sur une page Web correspondante.

Dans l'exemple suivant, ‘/’URL rend une page Web (student.html) qui a un formulaire. Les données qui y sont remplies sont publiées dans le‘/result’ URL qui déclenche le result() fonction.

le results() la fonction collecte les données de formulaire présentes dans request.form dans un objet dictionnaire et l'envoie pour rendu à result.html.

Le modèle restitue dynamiquement un tableau HTML de form Les données.

Ci-dessous le code d'application Python -

from flask import Flask, render_template, request
app = Flask(__name__)

@app.route('/')
def student():
   return render_template('student.html')

@app.route('/result',methods = ['POST', 'GET'])
def result():
   if request.method == 'POST':
      result = request.form
      return render_template("result.html",result = result)

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

Ci-dessous, le script HTML de student.html.

<html>
   <body>
      <form action = "http://localhost:5000/result" method = "POST">
         <p>Name <input type = "text" name = "Name" /></p>
         <p>Physics <input type = "text" name = "Physics" /></p>
         <p>Chemistry <input type = "text" name = "chemistry" /></p>
         <p>Maths <input type ="text" name = "Mathematics" /></p>
         <p><input type = "submit" value = "submit" /></p>
      </form>
   </body>
</html>

Code de modèle (result.html) est donné ci-dessous -

<!doctype html>
<html>
   <body>
      <table border = 1>
         {% for key, value in result.items() %}
            <tr>
               <th> {{ key }} </th>
               <td> {{ value }} </td>
            </tr>
         {% endfor %}
      </table>
   </body>
</html>

Exécutez le script Python et entrez l'URL http://localhost:5000/ dans le navigateur.

Quand le Submit bouton est cliqué, les données du formulaire sont rendues sur result.html sous forme de tableau HTML.

Un cookie est stocké sur l'ordinateur d'un client sous la forme d'un fichier texte. Son objectif est de mémoriser et de suivre les données relatives à l'utilisation d'un client pour une meilleure expérience des visiteurs et des statistiques sur le site.

UNE Request objectcontient l'attribut d'un cookie. C'est un objet dictionnaire de toutes les variables de cookie et de leurs valeurs correspondantes, un client a transmis. En plus de cela, un cookie stocke également son heure d'expiration, son chemin et son nom de domaine du site.

Dans Flask, les cookies sont définis sur l'objet de réponse. Utilisationmake_response()fonction pour obtenir un objet de réponse à partir de la valeur de retour d'une fonction de vue. Après cela, utilisez leset_cookie() fonction de l'objet de réponse pour stocker un cookie.

La relecture d'un cookie est facile. leget() méthode de request.cookies L'attribut est utilisé pour lire un cookie.

Dans l'application Flask suivante, un simple formulaire s'ouvre lors de votre visite ‘/’ URL.

@app.route('/')
def index():
   return render_template('index.html')

Cette page HTML contient une entrée de texte.

<html>
   <body>
      <form action = "/setcookie" method = "POST">
         <p><h3>Enter userID</h3></p>
         <p><input type = 'text' name = 'nm'/></p>
         <p><input type = 'submit' value = 'Login'/></p>
      </form>
   </body>
</html>

Le formulaire est publié sur ‘/setcookie’URL. La fonction d'affichage associée définit un nom de cookieuserID et rend une autre page.

@app.route('/setcookie', methods = ['POST', 'GET'])
def setcookie():
   if request.method == 'POST':
   user = request.form['nm']
   
   resp = make_response(render_template('readcookie.html'))
   resp.set_cookie('userID', user)
   
   return resp

‘readcookie.html’ contient un lien hypertexte vers une autre fonction d'affichage getcookie(), qui lit et affiche la valeur du cookie dans le navigateur.

@app.route('/getcookie')
def getcookie():
   name = request.cookies.get('userID')
   return '<h1>welcome '+name+'</h1>'

Exécutez l'application et visitez http://localhost:5000/

Le résultat de la configuration d'un cookie est affiché comme ceci -

La sortie du cookie de lecture est indiquée ci-dessous.

Comme le cookie, les données de session sont stockées sur le client. La session est l'intervalle de temps pendant lequel un client se connecte à un serveur et se déconnecte. Les données, qui doivent être conservées tout au long de cette session, sont stockées dans le navigateur client.

Une session avec chaque client se voit attribuer un Session ID. Les données de session sont stockées au-dessus des cookies et le serveur les signe de manière cryptographique. Pour ce chiffrement, une application Flask a besoin d'unSECRET_KEY.

L'objet session est également un objet dictionnaire contenant des paires clé-valeur de variables de session et les valeurs associées.

Par exemple, pour définir un ‘username’ variable de session utiliser l'instruction -

Session[‘username’] = ’admin’

Pour libérer une variable de session, utilisez pop() méthode.

session.pop('username', None)

Le code suivant est une simple démonstration des travaux de session dans Flask. URL‘/’ invite simplement l'utilisateur à se connecter, en tant que variable de session ‘username’ n'est pas défini.

@app.route('/')
def index():
   if 'username' in session:
      username = session['username']
         return 'Logged in as ' + username + '<br>' + \
         "<b><a href = '/logout'>click here to log out</a></b>"
   return "You are not logged in <br><a href = '/login'></b>" + \
      "click here to log in</b></a>"

Lorsque l'utilisateur navigue vers '/ login', la fonction de vue login (), car elle est appelée via la méthode GET, ouvre un formulaire de connexion.

Un formulaire est renvoyé à ‘/login’et maintenant la variable de session est définie. L'application est redirigée vers‘/’. Cette variable de session de temps‘username’ est trouvé.

@app.route('/login', methods = ['GET', 'POST'])
def login():
   if request.method == 'POST':
      session['username'] = request.form['username']
      return redirect(url_for('index'))
   return '''
	
   <form action = "" method = "post">
      <p><input type = text name = username/></p>
      <p<<input type = submit value = Login/></p>
   </form>
	
   '''

L'application contient également un logout() fonction d'affichage, qui apparaît ‘username’variable de session. Par conséquent,‘/’ L'URL affiche à nouveau la page d'ouverture.

@app.route('/logout')
def logout():
   # remove the username from the session if it is there
   session.pop('username', None)
   return redirect(url_for('index'))

Exécutez l'application et visitez la page d'accueil. (Assurez-vous de définirsecret_key de l'application)

from flask import Flask, session, redirect, url_for, escape, request
app = Flask(__name__)
app.secret_key = 'any random string’

La sortie sera affichée comme indiqué ci-dessous. Cliquer sur le lien“click here to log in”.

Le lien sera dirigé vers un autre écran. Tapez «admin».

L'écran vous montrera le message, ‘Logged in as admin’.

La classe Flask a un redirect()fonction. Lorsqu'il est appelé, il renvoie un objet de réponse et redirige l'utilisateur vers un autre emplacement cible avec le code d'état spécifié.

Prototype de redirect() la fonction est comme ci-dessous -

Flask.redirect(location, statuscode, response)

Dans la fonction ci-dessus -

location paramètre est l'URL vers laquelle la réponse doit être redirigée.
statuscode envoyé à l'en-tête du navigateur, par défaut à 302.
response Le paramètre est utilisé pour instancier la réponse.

Les codes d'état suivants sont normalisés -

HTTP_300_MULTIPLE_CHOICES
HTTP_301_MOVED_PERMANENTLY
HTTP_302_FOUND
HTTP_303_SEE_OTHER
HTTP_304_NOT_MODIFIED
HTTP_305_USE_PROXY
HTTP_306_RESERVED
HTTP_307_TEMPORARY_REDIRECT

le default status le code est 302, qui est pour ‘found’.

Dans l'exemple suivant, le redirect() La fonction est utilisée pour afficher à nouveau la page de connexion lorsqu'une tentative de connexion échoue.

from flask import Flask, redirect, url_for, render_template, request
# Initialize the Flask application
app = Flask(__name__)

@app.route('/')
def index():
   return render_template('log_in.html')

@app.route('/login',methods = ['POST', 'GET']) 
def login(): 
   if request.method == 'POST' and request.form['username'] == 'admin' :
      return redirect(url_for('success'))
   else:
      return redirect(url_for('index'))

@app.route('/success')
def success():
   return 'logged in successfully'
	
if __name__ == '__main__':
   app.run(debug = True)

La classe Flask a abort() fonction avec un code d'erreur.

Flask.abort(code)

le Code paramètre prend l'une des valeurs suivantes -

400 - pour mauvaise demande
401 - pour non authentifié
403 - pour Interdit
404 - pour non trouvé
406 - pour non acceptable
415 - pour le type de support non pris en charge
429 - Trop de demandes

Faisons un léger changement dans le login()fonction dans le code ci-dessus. Au lieu de réafficher la page de connexion, si‘Unauthourized’ doit être affichée, remplacez-la par appel à abort(401).

from flask import Flask, redirect, url_for, render_template, request, abort
app = Flask(__name__)

@app.route('/')
def index():
   return render_template('log_in.html')

@app.route('/login',methods = ['POST', 'GET'])
def login():
   if request.method == 'POST':
      if request.form['username'] == 'admin' :
         return redirect(url_for('success'))
      else:
         abort(401)
   else:
      return redirect(url_for('index'))

@app.route('/success')
def success():
   return 'logged in successfully'

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

Une bonne application basée sur l'interface graphique fournit des commentaires à un utilisateur sur l'interaction. Par exemple, les applications de bureau utilisent une boîte de dialogue ou une boîte de message et JavaScript utilise des alertes à des fins similaires.

La génération de tels messages informatifs est facile dans l'application Web Flask. Le système clignotant du framework Flask permet de créer un message dans une vue et de le rendre dans une fonction de vue appeléenext.

Un module Flask contient flash()méthode. Il transmet un message à la requête suivante, qui est généralement un modèle.

flash(message, category)

Ici,

message Le paramètre est le message réel à clignoter.
categoryle paramètre est facultatif. Il peut s'agir de «erreur», «info» ou «avertissement».

Afin de supprimer le message de la session, les appels de modèle get_flashed_messages().

get_flashed_messages(with_categories, category_filter)

Les deux paramètres sont facultatifs. Le premier paramètre est un tuple si les messages reçus sont de catégorie. Le deuxième paramètre est utile pour afficher uniquement des messages spécifiques.

Le suivant clignote les messages reçus dans un modèle.

{% with messages = get_flashed_messages() %}
   {% if messages %}
      {% for message in messages %}
         {{ message }}
      {% endfor %}
   {% endif %}
{% endwith %}

Voyons maintenant un exemple simple, démontrant le mécanisme de clignotement dans Flask. Dans le code suivant, un‘/’ L'URL affiche le lien vers la page de connexion, sans message à clignoter.

@app.route('/')
def index():
   return render_template('index.html')

Le lien conduit un utilisateur à ‘/login’URL qui affiche un formulaire de connexion. Une fois soumis, lelogin() La fonction de visualisation vérifie un nom d'utilisateur et un mot de passe et clignote en conséquence un ‘success’ message ou crée ‘error’ variable.

@app.route('/login', methods = ['GET', 'POST'])
def login():
   error = None
   
   if request.method == 'POST':
      if request.form['username'] != 'admin' or \
         request.form['password'] != 'admin':
         error = 'Invalid username or password. Please try again!'
      else:
         flash('You were successfully logged in')
         return redirect(url_for('index'))
   return render_template('login.html', error = error)

En cas de error, le modèle de connexion est réaffiche avec un message d'erreur.

Login.html

<!doctype html>
<html>
   <body>
      <h1>Login</h1>

      {% if error %}
         <p><strong>Error:</strong> {{ error }}
      {% endif %}
      
      <form action = "" method = post>
         <dl>
            <dt>Username:</dt>
            <dd>
               <input type = text name = username 
                  value = "{{request.form.username }}">
            </dd>
            <dt>Password:</dt>
            <dd><input type = password name = password></dd>
         </dl>
         <p><input type = submit value = Login></p>
      </form>
   </body>
</html>

D'autre part, si login réussit, un message de réussite est affiché sur le modèle d'index.

Index.html

<!doctype html>
<html>
   <head>
      <title>Flask Message flashing</title>
   </head>
   <body>
      {% with messages = get_flashed_messages() %}
         {% if messages %}
            <ul>
               {% for message in messages %}
               <li<{{ message }}</li>
               {% endfor %}
            </ul>
         {% endif %}
      {% endwith %}
		
      <h1>Flask Message Flashing Example</h1>
      <p>Do you want to <a href = "{{ url_for('login') }}">
         <b>log in?</b></a></p>
   </body>
</html>

Un code complet pour l'exemple de clignotement de message Flask est donné ci-dessous -

Flash.py

from flask import Flask, flash, redirect, render_template, request, url_for
app = Flask(__name__)
app.secret_key = 'random string'

@app.route('/')
def index():
   return render_template('index.html')

@app.route('/login', methods = ['GET', 'POST'])
def login():
   error = None
   
   if request.method == 'POST':
      if request.form['username'] != 'admin' or \
         request.form['password'] != 'admin':
         error = 'Invalid username or password. Please try again!'
      else:
         flash('You were successfully logged in')
         return redirect(url_for('index'))
			
   return render_template('login.html', error = error)

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

Après avoir exécuté les codes ci-dessus, vous verrez l'écran comme indiqué ci-dessous.

Lorsque vous cliquez sur le lien, vous serez dirigé vers la page de connexion.

Entrez le nom d'utilisateur et le mot de passe.

Cliquez sur Login. Un message s'affiche «Vous avez été connecté avec succès».

La gestion du téléchargement de fichiers dans Flask est très simple. Il a besoin d'un formulaire HTML avec son attribut enctype défini sur «multipart / form-data», publiant le fichier sur une URL. Le gestionnaire d'URL récupère le fichier à partir derequest.files[] objet et l'enregistre à l'emplacement souhaité.

Chaque fichier téléchargé est d'abord enregistré dans un emplacement temporaire sur le serveur, avant d'être enregistré dans son emplacement final. Le nom du fichier de destination peut être codé en dur ou peut être obtenu à partir de la propriété filename derequest.files[file]objet. Cependant, il est recommandé d'en obtenir une version sécurisée en utilisant lesecure_filename() fonction.

Il est possible de définir le chemin du dossier de téléchargement par défaut et la taille maximale du fichier téléchargé dans les paramètres de configuration de l'objet Flask.

app.config ['UPLOAD_FOLDER']	Définit le chemin du dossier de téléchargement
app.config ['MAX_CONTENT_PATH']	Spécifie la taille maximale du fichier à télécharger - en octets

Le code suivant a ‘/upload’ Règle d'URL qui s'affiche ‘upload.html’ dans le dossier des modèles, et ‘/upload-file’ Règle d'URL qui appelle uploader() processus de téléchargement de gestion des fonctions.

‘upload.html’ a un bouton de sélection de fichier et un bouton d'envoi.

<html>
   <body>
      <form action = "http://localhost:5000/uploader" method = "POST" 
         enctype = "multipart/form-data">
         <input type = "file" name = "file" />
         <input type = "submit"/>
      </form>
   </body>
</html>

Vous verrez l'écran comme indiqué ci-dessous.

Cliquez sur Submitaprès avoir choisi le fichier. La méthode de publication du formulaire invoque‘/upload_file’URL. La fonction sous-jacenteuploader() effectue l'opération de sauvegarde.

Voici le code Python de l'application Flask.

from flask import Flask, render_template, request
from werkzeug import secure_filename
app = Flask(__name__)

@app.route('/upload')
def upload_file():
   return render_template('upload.html')
	
@app.route('/uploader', methods = ['GET', 'POST'])
def upload_file():
   if request.method == 'POST':
      f = request.files['file']
      f.save(secure_filename(f.filename))
      return 'file uploaded successfully'
		
if __name__ == '__main__':
   app.run(debug = True)

Flask est souvent appelé un micro-framework, car une fonctionnalité de base comprend WSGI et le routage basé sur Werkzeug et moteur de modèle basé sur Jinja2. En outre, le framework Flask prend en charge les cookies et les sessions ainsi que des assistants Web tels queJSON, fichiers statiques, etc. Évidemment, cela ne suffit pas pour le développement d'une application Web à part entière. C'est là que les extensions Flask entrent en scène. Les extensions Flask donnent de l'extensibilité au framework Flask.

Il existe un grand nombre d'extensions Flask disponibles. Une extension Flask est un module Python, qui ajoute un type spécifique de prise en charge à l'application Flask. Flask Extension Registry est un répertoire d'extensions disponibles. L'extension requise peut être téléchargée parpip utilitaire.

Dans ce didacticiel, nous aborderons les extensions Flask importantes suivantes:

Flask Mail - fournit une interface SMTP à l'application Flask
Flask WTF - ajoute le rendu et la validation des WTForms
Flask SQLAlchemy - ajoute la prise en charge de SQLAlchemy à l'application Flask
Flask Sijax - Interface pour Sijax - Bibliothèque Python / jQuery qui rend AJAX facile à utiliser dans les applications Web

Chaque type d'extension fournit généralement une documentation complète sur son utilisation. Puisqu'une extension est un module Python, elle doit être importée pour pouvoir être utilisée. Les extensions Flask sont généralement nommées flask-foo. Importer,

from flask_foo import [class, function]

Pour les versions de Flask ultérieures à 0.7, vous pouvez également utiliser la syntaxe -

from flask.ext import foo

Pour cette utilisation, un module de compatibilité doit être activé. Il peut être installé en exécutant flaskext_compat.py

import flaskext_compat
flaskext_compat.activate()
from flask.ext import foo

Une application basée sur le Web est souvent nécessaire pour avoir une fonction d'envoi de courrier aux utilisateurs / clients. Flask-Mail L'extension permet de configurer très facilement une interface simple avec n'importe quel serveur de messagerie.

Au début, l'extension Flask-Mail doit être installée à l'aide de l'utilitaire pip.

pip install Flask-Mail

Ensuite, Flask-Mail doit être configuré en définissant les valeurs des paramètres d'application suivants.

Sr. Non	Paramètres et description
1	MAIL_SERVER Nom / adresse IP du serveur de messagerie
2	MAIL_PORT Numéro de port du serveur utilisé
3	MAIL_USE_TLS Activer / désactiver le chiffrement de la couche de sécurité du transport
4	MAIL_USE_SSL Activer / désactiver le cryptage Secure Sockets Layer
5	MAIL_DEBUG Prise en charge du débogage. La valeur par défaut est l'état de débogage de l'application Flask
6	MAIL_USERNAME Nom d'utilisateur de l'expéditeur
sept	MAIL_PASSWORD mot de passe de l'expéditeur
8	MAIL_DEFAULT_SENDER définit l'expéditeur par défaut
9	MAIL_MAX_EMAILS Définit le nombre maximal de mails à envoyer
dix	MAIL_SUPPRESS_SEND Envoi supprimé si app.testing défini sur true
11	MAIL_ASCII_ATTACHMENTS Si défini sur true, les noms de fichiers attachés sont convertis en ASCII

Le module flask-mail contient les définitions des classes importantes suivantes.

Classe de courrier

Il gère les exigences de messagerie électronique. Le constructeur de classe prend la forme suivante -

flask-mail.Mail(app = None)

Le constructeur prend l'objet d'application Flask comme paramètre.

Méthodes de classe Mail

Sr. Non	Méthodes et description
1	send() Envoie le contenu de l'objet de classe Message
2	connect() Ouvre la connexion avec l'hôte de messagerie
3	send_message() Envoie un objet de message

Classe de message

Il encapsule un message électronique. Le constructeur de classe de message a plusieurs paramètres -

flask-mail.Message(subject, recipients, body, html, sender, cc, bcc, 
   reply-to, date, charset, extra_headers, mail_options, rcpt_options)

Méthodes de classe de message

attach()- ajoute une pièce jointe au message. Cette méthode prend les paramètres suivants -

filename - nom du fichier à joindre
content_type - Type de fichier MIME
data - données de fichier brutes
disposition - disposition du contenu, le cas échéant.

add_recipient() - ajoute un autre destinataire au message

Dans l'exemple suivant, le serveur SMTP du service gmail de Google est utilisé comme MAIL_SERVER pour la configuration Flask-Mail.

Step 1 - Importez la classe Mail et Message du module flask-mail dans le code.

from flask_mail import Mail, Message

Step 2 - Ensuite, Flask-Mail est configuré selon les paramètres suivants.

app.config['MAIL_SERVER']='smtp.gmail.com'
app.config['MAIL_PORT'] = 465
app.config['MAIL_USERNAME'] = '[email protected]'
app.config['MAIL_PASSWORD'] = '*****'
app.config['MAIL_USE_TLS'] = False
app.config['MAIL_USE_SSL'] = True

Step 3 - Créez une instance de la classe Mail.

mail = Mail(app)

Step 4 - Configurer un objet Message dans une fonction Python mappée par une règle d'URL (‘/’).

@app.route("/")
def index():
   msg = Message('Hello', sender = '[email protected]', recipients = ['[email protected]'])
   msg.body = "This is the email body"
   mail.send(msg)
   return "Sent"

Step 5- Le code complet est donné ci-dessous. Exécutez le script suivant dans Python Shell et visitezhttp://localhost:5000/.

from flask import Flask
from flask_mail import Mail, Message

app =Flask(__name__)
mail=Mail(app)

app.config['MAIL_SERVER']='smtp.gmail.com'
app.config['MAIL_PORT'] = 465
app.config['MAIL_USERNAME'] = '[email protected]'
app.config['MAIL_PASSWORD'] = '*****'
app.config['MAIL_USE_TLS'] = False
app.config['MAIL_USE_SSL'] = True
mail = Mail(app)

@app.route("/")
def index():
   msg = Message('Hello', sender = '[email protected]', recipients = ['[email protected]'])
   msg.body = "Hello Flask message sent from Flask-Mail"
   mail.send(msg)
   return "Sent"

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

Notez que les fonctionnalités d'insécurité intégrées du service Gmail peuvent bloquer cette tentative de connexion. Vous devrez peut-être diminuer le niveau de sécurité. Veuillez vous connecter à votre compte Gmail et visiter ce lien pour diminuer la sécurité.

L'un des aspects essentiels d'une application Web est de présenter une interface utilisateur pour l'utilisateur. HTML fournit un<form>tag, qui est utilisé pour concevoir une interface. UNEForm’s des éléments tels que la saisie de texte, la radio, la sélection, etc. peuvent être utilisés de manière appropriée.

Les données saisies par un utilisateur sont soumises sous la forme d'un message de requête Http au script côté serveur par la méthode GET ou POST.

Le script côté serveur doit recréer les éléments de formulaire à partir des données de requête http. Donc, en fait, les éléments de formulaire doivent être définis deux fois - une fois en HTML et à nouveau dans le script côté serveur.
Un autre inconvénient de l'utilisation d'un formulaire HTML est qu'il est difficile (voire impossible) de rendre les éléments du formulaire de manière dynamique. Le HTML lui-même ne fournit aucun moyen de valider l'entrée d'un utilisateur.

C'est ici que WTForms, une bibliothèque flexible de formulaires, de rendu et de validation est pratique. L'extension Flask-WTF fournit une interface simple avec ceWTForms bibliothèque.

En utilisant Flask-WTF, nous pouvons définir les champs de formulaire dans notre script Python et les rendre à l'aide d'un modèle HTML. Il est également possible d'appliquer la validation auWTF champ.

Voyons comment fonctionne cette génération dynamique de HTML.

Tout d'abord, l'extension Flask-WTF doit être installée.

pip install flask-WTF

Le package installé contient un Form class, qui doit être utilisé comme parent pour le formulaire défini par l'utilisateur.

WTformspackage contient les définitions de divers champs de formulaire. CertainsStandard form fields sont énumérés ci-dessous.

Sr. Non	Champs de formulaire standard et description
1	TextField Représente l'élément de formulaire HTML <input type = 'text'>
2	BooleanField Représente l'élément de formulaire HTML <input type = 'checkbox'>
3	DecimalField Champ de texte pour afficher le nombre avec des décimales
4	IntegerField TextField pour afficher un entier
5	RadioField Représente l'élément de formulaire HTML <input type = 'radio'>
6	SelectField Représente l'élément de formulaire de sélection
sept	TextAreaField Représente l'élément de formulaire HTML <testarea>
8	PasswordField Représente l'élément de formulaire HTML <input type = 'password'>
9	SubmitField Représente l'élément de formulaire <input type = 'submit'>

Par exemple, un formulaire contenant un champ de texte peut être conçu comme ci-dessous -

from flask_wtf import Form
from wtforms import TextField

class ContactForm(Form):
   name = TextField("Name Of Student")

En plus de ‘name’, un champ masqué pour le jeton CSRF est créé automatiquement. C'est pour empêcherCross Site Request Forgery attaque.

Une fois rendu, cela se traduira par un script HTML équivalent, comme indiqué ci-dessous.

<input id = "csrf_token" name = "csrf_token" type = "hidden" />
<label for = "name">Name Of Student</label><br>
<input id = "name" name = "name" type = "text" value = "" />

Une classe de formulaire définie par l'utilisateur est utilisée dans une application Flask et le formulaire est rendu à l'aide d'un modèle.

from flask import Flask, render_template
from forms import ContactForm
app = Flask(__name__)
app.secret_key = 'development key'

@app.route('/contact')
def contact():
   form = ContactForm()
   return render_template('contact.html', form = form)

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

Le package WTForms contient également une classe de validation. Il est utile pour appliquer la validation aux champs de formulaire. La liste suivante montre les validateurs couramment utilisés.

Sr. Non	Classe et description des validateurs
1	DataRequired Vérifie si le champ de saisie est vide
2	Email Vérifie si le texte du champ respecte les conventions d'ID d'e-mail
3	IPAddress Valide l'adresse IP dans le champ de saisie
4	Length Vérifie si la longueur de la chaîne dans le champ d'entrée est dans la plage donnée
5	NumberRange Valide un nombre dans le champ de saisie dans une plage donnée
6	URL Valide l'URL saisie dans le champ de saisie

Nous allons maintenant appliquer ‘DataRequired’ règle de validation pour le name champ dans le formulaire de contact.

name = TextField("Name Of Student",[validators.Required("Please enter your name.")])

le validate()La fonction de l'objet de formulaire valide les données du formulaire et renvoie les erreurs de validation si la validation échoue. leErrorles messages sont envoyés au modèle. Dans le modèle HTML, les messages d'erreur sont rendus dynamiquement.

{% for message in form.name.errors %}
   {{ message }}
{% endfor %}

L'exemple suivant illustre les concepts donnés ci-dessus. La conception deContact form est donné ci-dessous (forms.py).

from flask_wtf import Form
from wtforms import TextField, IntegerField, TextAreaField, SubmitField, RadioField,
   SelectField

from wtforms import validators, ValidationError

class ContactForm(Form):
   name = TextField("Name Of Student",[validators.Required("Please enter 
      your name.")])
   Gender = RadioField('Gender', choices = [('M','Male'),('F','Female')])
   Address = TextAreaField("Address")
   
   email = TextField("Email",[validators.Required("Please enter your email address."),
      validators.Email("Please enter your email address.")])
   
   Age = IntegerField("age")
   language = SelectField('Languages', choices = [('cpp', 'C++'), 
      ('py', 'Python')])
   submit = SubmitField("Send")

Les validateurs sont appliqués au Name et Email des champs.

Ci-dessous, le script d'application Flask (formexample.py).

from flask import Flask, render_template, request, flash
from forms import ContactForm
app = Flask(__name__)
app.secret_key = 'development key'

@app.route('/contact', methods = ['GET', 'POST'])
def contact():
   form = ContactForm()
   
   if request.method == 'POST':
      if form.validate() == False:
         flash('All fields are required.')
         return render_template('contact.html', form = form)
      else:
         return render_template('success.html')
      elif request.method == 'GET':
         return render_template('contact.html', form = form)

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

Le script du modèle (contact.html) est comme suit -

<!doctype html>
<html>
   <body>
      <h2 style = "text-align: center;">Contact Form</h2>
		
      {% for message in form.name.errors %}
         <div>{{ message }}</div>
      {% endfor %}
      
      {% for message in form.email.errors %}
         <div>{{ message }}</div>
      {% endfor %}
      
      <form action = "http://localhost:5000/contact" method = post>
         <fieldset>
            <legend>Contact Form</legend>
            {{ form.hidden_tag() }}
            
            <div style = font-size:20px; font-weight:bold; margin-left:150px;>
               {{ form.name.label }}<br>
               {{ form.name }}
               <br>
               
               {{ form.Gender.label }} {{ form.Gender }}
               {{ form.Address.label }}<br>
               {{ form.Address }}
               <br>
               
               {{ form.email.label }}<br>
               {{ form.email }}
               <br>
               
               {{ form.Age.label }}<br>
               {{ form.Age }}
               <br>
               
               {{ form.language.label }}<br>
               {{ form.language }}
               <br>
               {{ form.submit }}
            </div>
            
         </fieldset>
      </form>
   </body>
</html>

Courir formexample.py dans le shell Python et visitez l'URL http://localhost:5000/contact. leContact Le formulaire sera affiché comme indiqué ci-dessous.

S'il y a des erreurs, la page ressemblera à ceci -

S'il n'y a pas d'erreurs, ‘success.html’ sera rendu.

Python a un support intégré pour SQlite. Le module SQlite3 est livré avec la distribution Python. Pour un didacticiel détaillé sur l'utilisation de la base de données SQLite en Python, veuillez consulter ce lien . Dans cette section, nous verrons comment une application Flask interagit avec SQLite.

Créer une base de données SQLite ‘database.db’ et créez-y une table d'étudiants.

import sqlite3

conn = sqlite3.connect('database.db')
print "Opened database successfully";

conn.execute('CREATE TABLE students (name TEXT, addr TEXT, city TEXT, pin TEXT)')
print "Table created successfully";
conn.close()

Notre application Flask a trois View les fonctions.

Première new_student() la fonction est liée à la règle d'URL (‘/addnew’). Il rend un fichier HTML contenant un formulaire d'informations sur les étudiants.

@app.route('/enternew')
def new_student():
   return render_template('student.html')

Le script HTML pour ‘student.html’ est comme suit -

<html>
   <body>
      <form action = "{{ url_for('addrec') }}" method = "POST">
         <h3>Student Information</h3>
         Name<br>
         <input type = "text" name = "nm" /></br>
         
         Address<br>
         <textarea name = "add" ></textarea><br>
         
         City<br>
         <input type = "text" name = "city" /><br>
         
         PINCODE<br>
         <input type = "text" name = "pin" /><br>
         <input type = "submit" value = "submit" /><br>
      </form>
   </body>
</html>

Comme on peut le voir, les données du formulaire sont publiées dans le ‘/addrec’ URL qui lie le addrec() fonction.

Ce addrec() La fonction récupère les données du formulaire par POSTméthode et inserts dans la table des étudiants. Le message correspondant au succès ou à l'erreur lors de l'opération d'insertion est rendu à‘result.html’.

@app.route('/addrec',methods = ['POST', 'GET'])
def addrec():
   if request.method == 'POST':
      try:
         nm = request.form['nm']
         addr = request.form['add']
         city = request.form['city']
         pin = request.form['pin']
         
         with sql.connect("database.db") as con:
            cur = con.cursor()
            cur.execute("INSERT INTO students (name,addr,city,pin) 
               VALUES (?,?,?,?)",(nm,addr,city,pin) )
            
            con.commit()
            msg = "Record successfully added"
      except:
         con.rollback()
         msg = "error in insert operation"
      
      finally:
         return render_template("result.html",msg = msg)
         con.close()

Le script HTML de result.html contient une instruction d'échappement {{msg}} qui affiche le résultat de Insert opération.

<!doctype html>
<html>
   <body>
      result of addition : {{ msg }}
      <h2><a href = "\">go back to home page</a></h2>
   </body>
</html>

L'application contient un autre list() fonction représentée par ‘/list’URL. Il peuplera‘rows’ comme un MultiDictobjet contenant tous les enregistrements de la table des étudiants. Cet objet est passé aulist.html modèle.

@app.route('/list')
def list():
   con = sql.connect("database.db")
   con.row_factory = sql.Row
   
   cur = con.cursor()
   cur.execute("select * from students")
   
   rows = cur.fetchall(); 
   return render_template("list.html",rows = rows)

Ce list.html est un modèle qui itère sur l'ensemble de lignes et restitue les données dans un tableau HTML.

<!doctype html>
<html>
   <body>
      <table border = 1>
         <thead>
            <td>Name</td>
            <td>Address>/td<
            <td>city</td>
            <td>Pincode</td>
         </thead>
         
         {% for row in rows %}
            <tr>
               <td>{{row["name"]}}</td>
               <td>{{row["addr"]}}</td>
               <td> {{ row["city"]}}</td>
               <td>{{row['pin']}}</td>	
            </tr>
         {% endfor %}
      </table>
      
      <a href = "/">Go back to home page</a>
   </body>
</html>

Finalement, le ‘/’ La règle d'URL rend un ‘home.html’ qui agit comme le point d'entrée de l'application.

@app.route('/')
def home():
   return render_template('home.html')

Voici le code complet de Flask-SQLite application.

from flask import Flask, render_template, request
import sqlite3 as sql
app = Flask(__name__)

@app.route('/')
def home():
   return render_template('home.html')

@app.route('/enternew')
def new_student():
   return render_template('student.html')

@app.route('/addrec',methods = ['POST', 'GET'])
def addrec():
   if request.method == 'POST':
      try:
         nm = request.form['nm']
         addr = request.form['add']
         city = request.form['city']
         pin = request.form['pin']
         
         with sql.connect("database.db") as con:
            cur = con.cursor()
            
            cur.execute("INSERT INTO students (name,addr,city,pin) 
               VALUES (?,?,?,?)",(nm,addr,city,pin) )
            
            con.commit()
            msg = "Record successfully added"
      except:
         con.rollback()
         msg = "error in insert operation"
      
      finally:
         return render_template("result.html",msg = msg)
         con.close()

@app.route('/list')
def list():
   con = sql.connect("database.db")
   con.row_factory = sql.Row
   
   cur = con.cursor()
   cur.execute("select * from students")
   
   rows = cur.fetchall();
   return render_template("list.html",rows = rows)

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

Exécutez ce script à partir du shell Python et lorsque le serveur de développement démarre. Visitehttp://localhost:5000/ dans le navigateur qui affiche un menu simple comme celui-ci -

Cliquez sur ‘Add New Record’ lien pour ouvrir le Student Information Forme.

Remplissez les champs du formulaire et soumettez-le. La fonction sous-jacente insère l'enregistrement dans la table des étudiants.

Revenez à la page d'accueil et cliquez sur ‘Show List’lien. Le tableau montrant les données d'exemple s'affiche.

L'utilisation de SQL brut dans les applications Web Flask pour effectuer des opérations CRUD sur une base de données peut être fastidieuse. Au lieu,SQLAlchemy, une boîte à outils Python est un puissant OR Mapperqui donne aux développeurs d'applications toute la puissance et la flexibilité de SQL. Flask-SQLAlchemy est l'extension Flask qui ajoute la prise en charge de SQLAlchemy à votre application Flask.

What is ORM (Object Relation Mapping)?

La plupart des plates-formes de langage de programmation sont orientées objet. Les données des serveurs SGBDR sont quant à elles stockées sous forme de tables. Le mappage de relation d'objet est une technique de mappage des paramètres d'objet à la structure de table du SGBDR sous-jacente. Une API ORM fournit des méthodes pour effectuer des opérations CRUD sans avoir à écrire des instructions SQL brutes.

Dans cette section, nous allons étudier les techniques ORM de Flask-SQLAlchemy et créer une petite application Web.

Step 1 - Installez l'extension Flask-SQLAlchemy.

pip install flask-sqlalchemy

Step 2 - Vous devez importer la classe SQLAlchemy depuis ce module.

from flask_sqlalchemy import SQLAlchemy

Step 3 - Créez maintenant un objet d'application Flask et définissez l'URI de la base de données à utiliser.

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///students.sqlite3'

Step 4- Créez ensuite un objet de la classe SQLAlchemy avec l'objet d'application comme paramètre. Cet objet contient des fonctions d'assistance pour les opérations ORM. Il fournit également une classe Model parent à l'aide de laquelle les modèles définis par l'utilisateur sont déclarés. Dans l'extrait ci-dessous, unstudents le modèle est créé.

db = SQLAlchemy(app)
class students(db.Model):
   id = db.Column('student_id', db.Integer, primary_key = True)
   name = db.Column(db.String(100))
   city = db.Column(db.String(50))  
   addr = db.Column(db.String(200))
   pin = db.Column(db.String(10))

def __init__(self, name, city, addr,pin):
   self.name = name
   self.city = city
   self.addr = addr
   self.pin = pin

Step 5 - Pour créer / utiliser la base de données mentionnée dans l'URI, exécutez le create_all() méthode.

db.create_all()

le Session objet de SQLAlchemy gère toutes les opérations de persistance de ORM objet.

Les méthodes de session suivantes effectuent des opérations CRUD -

db.session.add(objet modèle) - insère un enregistrement dans la table mappée
db.session.delete(objet modèle) - supprime l'enregistrement de la table
model.query.all() - récupère tous les enregistrements de la table (correspondant à la requête SELECT).

Vous pouvez appliquer un filtre au jeu d'enregistrements récupéré à l'aide de l'attribut de filtre. Par exemple, pour récupérer des enregistrements aveccity = ’Hyderabad’ dans la table des étudiants, utilisez la déclaration suivante -

Students.query.filter_by(city = ’Hyderabad’).all()

Avec autant de contexte, nous allons maintenant fournir des fonctions d'affichage pour notre application pour ajouter des données d'élève.

Le point d'entrée de l'application est show_all() fonction liée à ‘/’URL. Le tableau du jeu d'enregistrements des étudiants est envoyé en tant que paramètre au modèle HTML. Le code côté serveur dans le modèle rend les enregistrements sous forme de tableau HTML.

@app.route('/')
def show_all():
   return render_template('show_all.html', students = students.query.all() )

Le script HTML du modèle (‘show_all.html’) est comme ça -

<!DOCTYPE html>
<html lang = "en">
   <head></head>
   <body>
      <h3>
         <a href = "{{ url_for('show_all') }}">Comments - Flask 
            SQLAlchemy example</a>
      </h3>
      
      <hr/>
      {%- for message in get_flashed_messages() %}
         {{ message }}
      {%- endfor %}
		
      <h3>Students (<a href = "{{ url_for('new') }}">Add Student
         </a>)</h3>
      
      <table>
         <thead>
            <tr>
               <th>Name</th>
               <th>City</th>
               <th>Address</th>
               <th>Pin</th>
            </tr>
         </thead>

         <tbody>
            {% for student in students %}
               <tr>
                  <td>{{ student.name }}</td>
                  <td>{{ student.city }}</td>
                  <td>{{ student.addr }}</td>
                  <td>{{ student.pin }}</td>
               </tr>
            {% endfor %}
         </tbody>
      </table>
   </body>
</html>

La page ci-dessus contient un hyperlien vers ‘/new’ Mappage d'URL new()fonction. Lorsque vous cliquez dessus, il ouvre un formulaire d'informations sur les étudiants. Les données sont publiées sur la même URL dansPOST méthode.

new.html

<!DOCTYPE html>
<html>
   <body>
      <h3>Students - Flask SQLAlchemy example</h3>
      <hr/>
      
      {%- for category, message in get_flashed_messages(with_categories = true) %}
         <div class = "alert alert-danger">
            {{ message }}
         </div>
      {%- endfor %}
      
      <form action = "{{ request.path }}" method = "post">
         <label for = "name">Name</label><br>
         <input type = "text" name = "name" placeholder = "Name" /><br>
         <label for = "email">City</label><br>
         <input type = "text" name = "city" placeholder = "city" /><br>
         <label for = "addr">addr</label><br>
         <textarea name = "addr" placeholder = "addr"></textarea><br>
         <label for = "PIN">City</label><br>
         <input type = "text" name = "pin" placeholder = "pin" /><br>
         <input type = "submit" value = "Submit" />
      </form>
   </body>
</html>

Lorsque la méthode http est détectée comme POST, les données du formulaire sont ajoutées dans la table des étudiants et l'application retourne à la page d'accueil affichant les données ajoutées.

@app.route('/new', methods = ['GET', 'POST'])
def new():
   if request.method == 'POST':
      if not request.form['name'] or not request.form['city'] or not request.form['addr']:
         flash('Please enter all the fields', 'error')
      else:
         student = students(request.form['name'], request.form['city'],
            request.form['addr'], request.form['pin'])
         
         db.session.add(student)
         db.session.commit()
         
         flash('Record was successfully added')
         return redirect(url_for('show_all'))
   return render_template('new.html')

Ci-dessous le code d'application complet (app.py).

from flask import Flask, request, flash, url_for, redirect, render_template
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///students.sqlite3'
app.config['SECRET_KEY'] = "random string"

db = SQLAlchemy(app)

class students(db.Model):
   id = db.Column('student_id', db.Integer, primary_key = True)
   name = db.Column(db.String(100))
   city = db.Column(db.String(50))
   addr = db.Column(db.String(200)) 
   pin = db.Column(db.String(10))

def __init__(self, name, city, addr,pin):
   self.name = name
   self.city = city
   self.addr = addr
   self.pin = pin

@app.route('/')
def show_all():
   return render_template('show_all.html', students = students.query.all() )

@app.route('/new', methods = ['GET', 'POST'])
def new():
   if request.method == 'POST':
      if not request.form['name'] or not request.form['city'] or not request.form['addr']:
         flash('Please enter all the fields', 'error')
      else:
         student = students(request.form['name'], request.form['city'],
            request.form['addr'], request.form['pin'])
         
         db.session.add(student)
         db.session.commit()
         flash('Record was successfully added')
         return redirect(url_for('show_all'))
   return render_template('new.html')

if __name__ == '__main__':
   db.create_all()
   app.run(debug = True)

Exécutez le script à partir du shell Python et entrez http://localhost:5000/ dans le navigateur.

Clique le ‘Add Student’ lien pour ouvrir Student information forme.

Remplissez le formulaire et envoyez-le. La page d'accueil réapparaît avec les données soumises.

Nous pouvons voir la sortie comme indiqué ci-dessous.

Sijax signifie ‘Simple Ajax’ et c'est un Python/jQuery bibliothèque conçue pour vous aider à apporter facilement Ajaxà votre application. Il utilisejQuery.ajax pour faire des requêtes AJAX.

Installation

L'installation de Flask-Sijax est facile.

pip install flask-sijax

Configuration

SIJAX_STATIC_PATH- le chemin statique vers lequel vous voulez que les fichiers javascript Sijax soient mis en miroir. L'emplacement par défaut eststatic/js/sijax. Dans ce dossier,sijax.js et json2.js les fichiers sont conservés.
SIJAX_JSON_URI - l'URI pour charger le fichier statique json2.js à partir de

Sijax utilise JSONpour transmettre les données entre le navigateur et le serveur. Cela signifie que les navigateurs doivent soit prendre en chargeJSON nativement ou obtenir JSON soutien de la json2.js fichier.

Les fonctions enregistrées de cette manière ne peuvent pas fournir Sijax fonctionnalité, car ils ne sont pas accessibles à l'aide d'un POST méthode par défaut (et Sijax utilise les requêtes POST).

Faire un View fonction capable de gérer Sijax demandes, rendez-le accessible via POST en utilisant @app.route('/url', methods = ['GET', 'POST']) ou utilisez le @flask_sijax.route assistant décorateur comme celui-ci -

@flask_sijax.route(app, '/hello')

Chaque fonction de gestionnaire Sijax (comme celle-ci) reçoit au moins un paramètre automatiquement, tout comme Python passe «self» aux méthodes objet. le‘obj_response’ Le paramètre est la manière dont la fonction répond au navigateur.

def say_hi(obj_response):
   obj_response.alert('Hi there!')

Lorsque la requête Sijax est détectée, Sijax la gère comme ceci -

g.sijax.register_callback('say_hi', say_hi)
   return g.sijax.process_request()

Application Sijax

Un code d'application Sijax minimal se présente comme suit -

import os
from flask import Flask, g
from flask_sijax import sijax

path = os.path.join('.', os.path.dirname(__file__), 'static/js/sijax/')
app = Flask(__name__)

app.config['SIJAX_STATIC_PATH'] = path
app.config['SIJAX_JSON_URI'] = '/static/js/sijax/json2.js'
flask_sijax.Sijax(app)

@app.route('/')
def index():
   return 'Index'
	
@flask_sijax.route(app, '/hello')
def hello():
   def say_hi(obj_response):
      obj_response.alert('Hi there!')
   if g.sijax.is_sijax_request:
      # Sijax request detected - let Sijax handle it
      g.sijax.register_callback('say_hi', say_hi)
      return g.sijax.process_request()
      return _render_template('sijaxexample.html')

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

Lorsqu'un Sijax demande (un jQuery.ajax() request) au serveur, cette requête est détectée sur le serveur par g.sijax.is_sijax_request(), auquel cas vous laissez Sijax gérer la demande.

Toutes les fonctions enregistrées avec g.sijax.register_callback() sont exposés pour les appels depuis le navigateur.

Appel g.sijax.process_request() indique à Sijax d'exécuter la fonction appropriée (précédemment enregistrée) et de renvoyer la réponse au navigateur.

Serveur visible de l'extérieur

Une application Flask sur le serveur de développement est accessible uniquement sur l'ordinateur sur lequel l'environnement de développement est configuré. Il s'agit d'un comportement par défaut, car en mode débogage, un utilisateur peut exécuter du code arbitraire sur l'ordinateur.

Si debug est désactivé, le serveur de développement sur l'ordinateur local peut être mis à la disposition des utilisateurs sur le réseau en définissant le nom d'hôte comme ‘0.0.0.0’.

app.run(host = ’0.0.0.0’)

Ainsi, votre système d'exploitation écoute toutes les adresses IP publiques.

Déploiement

Pour passer d'un environnement de développement à un environnement de production à part entière, une application doit être déployée sur un vrai serveur Web. En fonction de ce que vous avez, différentes options sont disponibles pour déployer une application Web Flask.

Pour les petites applications, vous pouvez envisager de les déployer sur l'une des plates-formes hébergées suivantes, qui offrent toutes un plan gratuit pour les petites applications.

Heroku
dotcloud
webfaction

L'application Flask peut être déployée sur ces plates-formes cloud. De plus, il est possible de déployer l'application Flask sur la plateforme cloud de Google. Le service Localtunnel vous permet de partager votre application sur localhost sans modifier les paramètres DNS et de pare-feu.

Si vous êtes enclin à utiliser un serveur Web dédié à la place des plates-formes partagées mentionnées ci-dessus, les options suivantes sont à explorer.

mod_wsgi

mod_wsgi est un module Apache qui fournit une interface compatible WSGI pour l'hébergement d'applications Web basées sur Python sur un serveur Apache.

Installation de mod_wsgi

Pour installer une version officielle directement depuis PyPi, vous pouvez exécuter -

pip install mod_wsgi

Pour vérifier que l'installation a réussi, exécutez le script mod_wsgi-express avec la commande start-server -

mod_wsgi-express start-server

Cela lancera Apache / mod_wsgi sur le port 8000. Vous pouvez ensuite vérifier que l'installation a fonctionné en pointant votre navigateur sur -

http://localhost:8000/

Création d'un fichier .wsgi

Il devrait y avoir un yourapplication.wsgifichier. Ce fichier contient le codemod_wsgi,qui s'exécute au démarrage pour obtenir l'objet d'application. Pour la plupart des applications, le fichier suivant devrait suffire -

from yourapplication import app as application

Sois sûr que yourapplication et toutes les bibliothèques en cours d'utilisation se trouvent sur le chemin de chargement python.

Configurer Apache

Vous devez dire mod_wsgi, l'emplacement de votre application.

<VirtualHost *>
   ServerName example.com
   WSGIScriptAlias / C:\yourdir\yourapp.wsgi

   <Directory C:\yourdir>
      Order deny,allow
      Allow from all
   </Directory>

</VirtualHost>

Conteneurs WSGI autonomes

Il existe de nombreux serveurs populaires écrits en Python qui contiennent des applications WSGI et servent HTTP.

Gunicorn
Tornado
Gevent
Web tordu

FastCGI est une autre option de déploiement pour l'application Flask sur des serveurs Web tels que nginix, lighttpd et Cherokee.

Configuration de FastCGI

Tout d'abord, vous devez créer le FastCGIfichier serveur. Appelons-leyourapplication.fcgi.

from flup.server.fcgi import WSGIServer
from yourapplication import app

if __name__ == '__main__':
   WSGIServer(app).run()

nginx et les anciennes versions de lighttpd besoin d'un socket à passer explicitement pour communiquer avec le FastCGIserveur. Pour que cela fonctionne, vous devez passer le chemin du socket auWSGIServer.

WSGIServer(application, bindAddress = '/path/to/fcgi.sock').run()

Configurer Apache

Pour un déploiement Apache de base, votre .fcgi Le fichier apparaîtra dans l'URL de votre application, par exemple example.com/yourapplication.fcgi/hello/. Il existe plusieurs façons de configurer votre application afin queyourapplication.fcgi n'apparaît pas dans l'URL.

<VirtualHost *>
   ServerName example.com
   ScriptAlias / /path/to/yourapplication.fcgi/
</VirtualHost>

Configurer lighttpd

Configuration de base de lighttpd ressemble à ceci -

fastcgi.server = ("/yourapplication.fcgi" => ((
   "socket" => "/tmp/yourapplication-fcgi.sock",
   "bin-path" => "/var/www/yourapplication/yourapplication.fcgi",
   "check-local" => "disable",
   "max-procs" => 1
)))

alias.url = (
   "/static/" => "/path/to/your/static"
)

url.rewrite-once = (
   "^(/static($|/.*))$" => "$1",
   "^(/.*)$" => "/yourapplication.fcgi$1"
)

N'oubliez pas d'activer le FastCGI, alias et modules de réécriture. Cette configuration lie l'application à/yourapplication.