IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)

Introduction à Python 3 et au framework web Flask par l'exemple


précédentsommairesuivant

1. Avant-propos

Ce document propose une liste de scripts Python dans différents domaines :

  • les fondamentaux du langage ;

  • la gestion de bases de données MySQL et PostgreSQL ;

  • la programmation réseau TCP/ IP (protocoles HTTP, POP3, IMAP, SMTP) ;

  • la programmation web MVC avec le Framework FLASK ;

  • les architectures trois couches et la programmation par interfaces ;

Ce n'est pas un cours Python exhaustif mais un recueil d'exemples destinés à des développeurs ayant déjà utilisé un langage de script tel que Perl, PHP, VBScript ou des développeurs habitués aux langages typés tels que Java ou C# et qui seraient intéressés par découvrir un langage de script orienté objet. Ce document est peu approprié pour des lecteurs n'ayant jamais ou peu programmé.

Ce document n'est pas non plus un recueil de "bonnes pratiques". Le développeur expérimenté pourra ainsi trouver que certains codes pourraient être mieux écrits. Ce document a pour seul objectif de donner des exemples à une personne désireuse de s'initier au langage Python 3 et au Framework Flask. Elle approfondira ensuite son apprentissage avec d'autres documents.

Les scripts sont commentés et les résultats de leur exécution reproduits. Parfois des explications supplémentaires sont fournies. Le document nécessite une lecture active : pour comprendre un script, il faut à la fois lire son code, ses commentaires et ses résultats d’exécution.

Les exemples du document sont disponibles à l'adresse https://tahe.developpez.com/tutoriels-cours/python-flask-2020/documents/python-flask-2020.rar :

Image non disponible

Le document est une mise à jour d'un ancien document paru en juin 2011 https://tahe.developpez.com/tutoriels-cours/python/. Le document de 2011 avait été construit avec l'interpréteur Python 2.7. Depuis, des versions Python 3.x sont apparues. En février 2020, on en est à la version 3.8. Les versions 3.x ont amené une discontinuité dans la portabilité entre versions : des codes s'exécutant sous Python 2.7 peuvent se révéler inutilisables sous Python 3.x. C'est notamment le cas pour l'écriture console. En 2.7 on peut écrire [print "toto"] alors qu'en 3.x il faut écrire [print("toto")] : il faut mettre des parenthèses. Cette simple évolution fait que les codes fournis avec le document de 2011 sont pour la plupart inutilisables directement avec Python 3.x. Il faut les modifier.

Ce nouveau document ne se contente pas de mettre à jour les codes de 2011 pour qu'ils soient exécutables avec Python 3.8 :

  • les sections sur la programmation TCP-IP et l’usage des bases de données ont subi d’importantes évolutions ;

  • la section sur la programmation web qui n’était qu’une introduction est désormais un cours complet utilisant le framework FLASK ;

Pour construire ce cours, j’ai suivi une démarche inhabituelle : j’ai fait un portage du cours PHP Introduction au langage PHP7 par l’exemple. Je n’ai donc pas suivi les structures traditionnelles des cours Python ou Flask. Je voulais avant tout savoir comment je pouvais faire avec Python 3 ce que j’avais fait en PHP 7. Le résultat est que j’ai pu refaire, en Python 3 / Flask, tous les exemples du cours PHP 7.

Ce document peut comporter des erreurs ou des insuffisances. Le lecteur peut utiliser le flux de discussion todo pour les signaler.

Le contenu du document est le suivant :

Chapitre

Dossier du code

Contenu

Chapitre 1

 

Présentation du cours

Chapitre 2

 

Installation d’un environnement de travail

Chapitre 3

[bases]

Les bases du langage Python – structures du langage – type de données – fonctions – affichage console – chaînes de formatage – changement de types – les listes – les dictionnaires – les expressions régulières

Chapitre 4

[strings]

Notation des chaînes de caractères – méthodes de la classe <str> - encodage / décodage des chaînes de caractères en UTF-8

Chapitre 5

[exceptions]

Gestion des exceptions

Chapitre 6

[fonctions]

Portée des variables – mode de passage des paramètres – utiliser des modules – le Python Path – paramètres nommés – fonctions récursives

Chapitre 7

[fichiers]

Lecture / écriture d’un fichier texte – gestion des fichiers encodés en UTF-8 – gestion des fichiers jSON

Chapitre 8

[impots/v01]

Version 1 de l’exercice d’application, un calcul d’impôt sur les revenus. L’application est déclinée en 18 versions – La version 1 implémente une solution procédurale

Chapitre 9

[imports]

Gestion des dépendances d’une application par importation de modules – une méthode de gestion des dépendances est présentée – elle est utilisée dans tout le document – gestion du Python Path

Chapitre 10

[impots/v02]

La version 2 de l’application reprend la version 1 en rassemblant toutes les constantes de la configuration dans un fichier de configuration qui gère également le Python Path

Chapitre 11

[impots/v03]

La version 3 de l’application reprend la version 2 en utilisant des fonctions encapsulées dans un module – la gestion des dépendances est faite par configuration – introduction de fichier jSON pour lire les données nécessaires au calcul de l’impôt et écrire les résultats des calculs

Chapitre 12

[classes/01]

Classes – héritage – méthodes et propriétés – getters / setters – constructeur – propriété [__dict__]

Chapitre 13

[classes/02]

Présentation des classes [BaseEntity] et [MyException] utilisées dans le reste du document – [BaseEntity] facilite les conversions objet / dictionnaire

Chapitre 14

[troiscouches]

Architecture en couches et programmation par interfaces. Ce chapitre présente les méthodes de programmation utilisées dans le reste du document

Chapitre 15

[impots/v04]

Version 4 de l’application – cette version implémente une solution avec une architecture en couches, la programmation par interfaces, l’utilisation de classes dérivées de [BaseEntity] et [MyException]

Chapitre 16

[databases/mysql]

Installation du SGBD MySQL – connexion à une base de données – création d’une table – exécution d’ordres SQL SELECT, UPDATE, DELETE, INSERT – transaction – requêtes SQL paramétrées

Chapitre 17

[databases/postgresql]

Installation du SGBD PostgreSQL – connexion à une base de données – création d’une table – exécution d’ordres SQL SELECT, UPDATE, DELETE, INSERT – transaction – requêtes SQL paramétrées

Chapitre 18

[databases/anysgbd]

Ecriture de code indépendant du SGBD

Chapitre 19

[databases/sqlalchemy]

L’ORM (Object Relational Mapper) SqlAlchemy – un ORM permet de travailler de façon unifiée avec différents SGBD - mapping classes / tables SQL – opérations sur les classes images des tables SQL

Chapitre 20

[impots/v05]

Version 5 de l’application de calcul de l’impôt – Utilisation de l’architecture en couches de la version 04 et de l’ORM SqlAlchemy pour travailler avec les SGBD MySQL et PostgreSQL

Chapitre 21

[inet]

Programmation internet – protocole TCP / IP (Transfer Control Protocol / Internet Protocol) - protocoles HTTP (HyperText Transfer Protocol) – SMTP (Simple Mail Transfer Protocol) – POP (Post Office Protocol) – IMAP (Internet Message Access Protocol)

Chapitre 22

[flask]

Services web avec le framework web Flask – affichage d’une page HTML – service web jSON – requêtes GET et POST – gestion d’une session web

Chapitre 23

[impots/http-servers/01]

[impots/http-clients/01]

Version 6 de l’exercice d’application - Création d’un service web jSON de calcul de l’impôt avec une architecture multicouche - Ecriture d’un client web pour ce serveur avec une architecture multicouche – programmation client / serveur – utilisation du module [requests]

Chapitre 24

[impots/http-servers/02]

[impots/http-clients/02]

Version 7 de l’exercice de l’application – la version 6 est améliorée : le client et le serveur sont multithtreadés – utilitaires [Logger] pour loguer les échanges client / serveur – [SendMail] pour envoyer un mail à l’administrateur de l’application

Chapitre 25

[impots/http-servers/03]

[impots/http-clients/03]

Version 8 de l’exercice d’application – la version 7 est améliorée par l’usage d’une session web

Chapitre 26

[xml]

Gestion du XML (eXtended Markup Language) avec le module [xmltodict]

Chapitre 27

[impots/http-servers/04]

[impots/http-clients/04]

Version 9 de l’exercice d’application – la version 8 est modifiée pour avoir des échanges client / serveur en XML ;

Chapitre 28

[impots/http-servers/05]

[impots/http-clients/05]

Version 10 de l’exercice d’application – au lieu de traiter N contribuables par N requêtes GET, on utilise une unique requête POST avec les N contribuables dans le corps du POST

Chapitre 29

[impots/http-servers/06]

[impots/http-clients/06]

Version 11 de l’exercice d’application – l’architecture client / serveur de l’application est modifiée : la couche [métier] passe du serveur au client

Chapitre 30

[impots/http-servers/07]

Version 12 de l’exercice d’application – cette version implémente un serveur MVC (Model – View – Controller) délivrant indifféremment, à la demande du client, du jSON, du XML et du HTML. Ce chapitre implémente les versions jSON et XML du serveur

Chapitre 31

[impots/http-clients/07]

Implémentation des clients jSON et XML du serveur MVC de la version 12

Chapitre 32

[impots/http-servers/07]

Implémentation du serveur HTML de la version 12 – utilisation du framework CSS Bootstrap –

Chapitre 33

[impots/http-servers/08]

Version 13 de l’exercice d’application - Refactorisation du code de la version 12 – gestion de la session avec le module [flask_session] et un serveur Redis – utilisation de mots de passe cryptés

Chapitre 34

[impots/http-servers/09]

[impots/http-clients/09]

Version 14 de l’exercice d’application – implémentation d’URL avec un jeton CSRF (Cross Site Request Forgery)

Chapitre 35

[impots/http-servers/10]

Version 15 de l’exercice d’application – refactorisation du code de la version 14 pour gérer deux types d’actions : ASV (Action Show View) qui ne servent qu’à afficher une vue sans modifier l’état du serveur, ADS (Action Do Something) qui font une action qui modifie l’état du serveur – ces actions se terminent toutes par une redirection vers une action ASV – cela permet de gérer correctement les rafraîchissements de page du navigateur client

Chapitre 36

[impots/http-servers/11]

Version 16 de l’application – gestion des URL avec préfixe

Chapitre 37

[impots/http-servers/12]

Version 17 de l’application – portage de la version 16 sur un serveur Apache / Windows

Chapitre 38

[impots/http-servers/13]

Version 18 de l’application – corrige une anomalie de la version 17

La version finale de l’exercice d’application est une application Client / serveur de calcul de l’impôt avec l’architecture suivante :

Image non disponible

La couche [web] ci-dessus est implémentée avec une architecture MVC :

Image non disponible

Le contenu du document est dense. Le lecteur qui ira jusqu’au bout aura une bonne vision de la programmation web MVC en Python / Flask et au-delà une bonne vision de la programmation web MVC dans d’autres langages.

Le lecteur qui préfère voir du code, le tester et le modifier plutôt que de lire un cours pourra procéder ainsi :

Le fichier [README.md] ressemble à ceci :

Image non disponible

Il est peu probable que le lecteur lise la totalité du cours :

  • le lecteur débutant pourra lire les chapitres 1 à 15 et s’arrêter là. Il pourra ensuite passer du temps à coder ses propres scripts Python avant de revenir à ce cours ;

  • le lecteur ayant les bases de Python et voulant s’initier aux bases de données et à l’ORM (Object Relational Mapper) [sqlalchemy] pourra se contenter des chapitres 16 à 20 ;

  • le lecteur voulant s’initier à la programmation internet (HTTP, SMTP, POP3, IMAP) pourra lire le chapitre 21. Ce chapitre est assez complexe et montre des scripts avancés. On peut le lire à deux niveaux :

    • pour découvrir les protocoles de l’internet ;

    • pour obtenir des scripts exploitant ces protocoles ;

  • le lecteur ayant les bases de Python et voulant s’initier à la programmation web avec le framework Flask lira le chapitre 22 ;

  • le lecteur désirant approfondir la programmation web avec le framework Flask pourra étudier les chapitres 23 à 38. On y construit des applications client / serveur de plus en plus complexes ainsi qu’une application HTML / Python suivant le modèle de développement MVC (Modèle – Vue – Contrôleur). Cette application est développée au chapitre 32. On pourra s’arrêter là. Les chapitres suivants amènent des modifications non fondamentales ;

Serge Tahé, septembre 2020


précédentsommairesuivant

Licence Creative Commons
Le contenu de cet article est rédigé par Serge Tahé et est mis à disposition selon les termes de la Licence Creative Commons Attribution - Pas d'Utilisation Commerciale - Partage dans les Mêmes Conditions 3.0 non transposé.
Les logos Developpez.com, en-tête, pied de page, css, et look & feel de l'article sont Copyright © 2020 Developpez.com.