Support Cours Python

École Centrale des Logiciels Libres et de Télécommunications
Institut Supérieur de Technologie de l'Université de Bangui

(IST/UB)
Support_Cours_Python
Présenté par : Sous la supervision :

Ahamadi Nasry Pr. Samuel Ouya
Benam Berenger
Sommaire
1 Chapitre 1 : rappel sur le protocole http (protocole de transfert hypertexte). .................... 1
1.1 Qu'est-ce que HTTP ? .................................................................................................. 1
1.2 Comment fonctionne HTTP ........................................................................................ 1
1.3 Requêtes et réponses HTTP ......................................................................................... 1
1.3.1 Requêtes HTTP. ................................................................................................... 1
1.3.1.1 Qu'est-ce qu'une méthode HTTP ? ................................................................ 2
1.3.1.2 Que sont les en-têtes de requête HTTP ? ...................................................... 4
1.3.1.3 Qu'y a-t-il dans le corps d'une requête HTTP ? ............................................ 4
1.3.2 Réponses HTTP.................................................................................................... 4
1.3.2.1 Codes d'état HTTP ........................................................................................ 4
1.3.2.2 Que sont les en-têtes de réponse HTTP ? ..................................................... 5
1.3.2.3 Que contient un corps de réponse HTTP ? ................................................... 5
1.3.3 Conclusion ............................................................................................................ 5
2 Chapitre 2 : python /MySQL .............................................................................................. 6
2.1 Introduction ................................................................................................................. 6
2.2 Python c'est quoi? ........................................................................................................ 6
2.3 Que fait Python? .......................................................................................................... 6
2.4 Les versions de python ................................................................................................ 6
2.5 Différences entres python 2 et python 3 ...................................................................... 6
2.6 PIP c'est quoi? .............................................................................................................. 7
2.7 Installation de pip ........................................................................................................ 7
2.7.1 Que fait PIP .......................................................................................................... 7
2.8 Base de données et Python .......................................................................................... 7
2.8.1 Une base de données c'est quoi? .......................................................................... 7
2.8.2 Quels sont les SGBDR les plus connus? .............................................................. 7
2.9 Mise en œuvre des programmes python et mysql ....................................................... 8
2.9.1 MySQL ................................................................................................................. 8
2.9.2 Python ................................................................................................................... 8
2.9.3 Installation de pip3 ............................................................................................... 9
2.9.4 Installation du connecteur pymysql ...................................................................... 9
2.9.5 Application CRUD avec Python et MySQL ........................................................ 9
2.9.5.1 Qu’est-ce que le CRUD ?.............................................................................. 9
2.9.5.2 Les étapes de base pour créer une application CRUD ................................ 10
2.9.5.3 Connexion sur notre serveur mysql ............................................................ 10
2.9.5.4 Création de la base de données banque ....................................................... 11
2.9.5.5 Création de la table client ........................................................................... 11
2.9.5.6 Création d’un utilisateur ............................................................................. 11
2.9.5.7 Attribution des droits. ................................................................................. 12
2.9.5.8 Création de notre projet. ............................................................................. 12
2.9.5.9 Programme d’affichage ............................................................................... 12
2.9.5.10 Programme d’insertion. ............................................................................... 13
2.9.5.11 Programme de modification. ....................................................................... 13
2.9.5.12 Programme de suppression. ........................................................................ 14
3 Chapitre 3 Python/ MySQL apache2/CGI ....................................................................... 17
3.1 CGI ............................................................................................................................ 17
3.2 Rôle du CGI : ............................................................................................................. 17
3.2.1 Fonctionnement général de la CGI : .................................................................. 17
3.2.2 Environnement CGI (variables d'environnement) : ........................................... 17
3.2.3 Entrée et sortie du script : ................................................................................... 17
3.2.4 Lecture des données d'entrée : ............................................................................ 17
3.2.5 Écriture de la réponse : ....................................................................................... 17
3.2.6 Permissions d'exécution : ................................................................................... 18
3.3 Mise en œuvre ........................................................................................................... 18
3.4 Curl : .......................................................................................................................... 37
3.5 Voici une explication détaillée de chaque verbe et de la manière dont ils sont mis en
œuvre avec Curl : ................................................................................................................. 37
3.5.1 GET : .................................................................................................................. 37
3.5.2 POST : ................................................................................................................ 37
3.5.3 PUT : .................................................................................................................. 37
3.5.4 DELETE : ........................................................................................................... 37
3.6 Mise en œuvre ........................................................................................................... 38
3.6.1 Utilisation de GET ............................................................................................. 38
3.6.2 Utilisation de POST ........................................................................................... 38
3.6.3 Utilisation de PUT .............................................................................................. 39
3.6.4 Utilisation de DELETE ...................................................................................... 40
4 Chapitre 4 : Python/ PostgreSQL / apache2/CGI ............................................................. 41
4.1 Présentation de PostgreSQL ...................................................................................... 41
4.2 Install de PostgreSQL ................................................................................................ 42
4.2.1 Vérifier l’installation de PostgreSQL ................................................................. 42
4.2.2 Accéder à PostgreSQL ....................................................................................... 43
4.2.3 Créer un nouveau rôle ........................................................................................ 43
4.2.4 Création d’une nouvelle base de données .......................................................... 44
4.2.5 Attribution des privilèges ................................................................................... 44
4.2.6 Installation du psycopg2 ..................................................................................... 45
4.3 Utilisation de la commande curl : .............................................................................. 62
4.3.1 Utilisation de POST ........................................................................................... 62
4.3.2 Utilisation de GET ............................................................................................. 63
4.3.3 Utilisation de PUT .............................................................................................. 63
4.3.4 Utilisation de DELETE ...................................................................................... 63
4.3.5 Installation de pgadmin4 .................................................................................... 64
1 Chapitre 1 : rappel sur le protocole http (protocole de
transfert hypertexte).
1.1 Qu'est-ce que HTTP ?
HTTP (HyperText Transfer Protocol) est l'ensemble de règles pour le transfert de fichiers - tels
que du texte, des images, du son, de la vidéo et d'autres fichiers multimédias - sur le Web. Dès
qu'un utilisateur ouvre son navigateur Web, il utilise indirectement HTTP. HTTP est un
protocole d'application qui s'exécute au-dessus de la suite de protocoles TCP/IP, qui constitue
la base d'Internet. La dernière version de HTTP est HTTP/2 , qui a été publiée en mai 2015.
C'est une alternative à son prédécesseur, HTTP 1.1 , mais ne la rend pas obsolète.
1.2 Comment fonctionne HTTP

Grâce au protocole HTTP, les ressources sont échangées entre les appareils clients et les
serveurs sur Internet. Les appareils clients envoient des demandes aux serveurs pour les
ressources nécessaires pour charger une page Web ; les serveurs renvoient des réponses au
client pour répondre aux demandes. Les requêtes et les réponses partagent des sous-documents
- tels que des données sur des images, du texte, des mises en page de texte, etc. - qui sont
assemblés par un navigateur Web client pour afficher le fichier de page Web complet.
1.3 Requêtes et réponses HTTP

Chaque interaction entre le client et le serveur est appelée un message. Les messages HTTP
sont des requêtes ou des réponses. Les appareils clients soumettent des requêtes HTTP aux
serveurs, qui répondent en renvoyant des réponses HTTP aux clients.
1.3.1 Requêtes HTTP.

C'est à ce moment qu'un appareil client, tel qu'un navigateur Internet, demande au serveur les
informations nécessaires pour charger le site Web. La demande fournit au serveur les
informations souhaitées dont il a besoin pour adapter sa réponse au dispositif client. Chaque
requête HTTP contient des données encodées, avec des informations telles que :
La version spécifique de HTTP a suivi. HTTP et HTTP/2 sont les deux versions.
Une URL. Cela pointe vers la ressource sur le Web.
Une méthode HTTP. Cela indique l'action spécifique que la demande s'attend à
recevoir du serveur dans sa réponse.
En-têtes de requête HTTP. Cela inclut des données telles que le type de navigateur
utilisé et les données que la demande recherche auprès du serveur. Il peut également
inclure des cookies, qui affichent des informations précédemment envoyées par le
serveur traitant la demande.
Un corps HTTP. Il s'agit d'informations facultatives dont le serveur a besoin à partir de
la demande, telles que les formulaires d'utilisateur - identifiants de connexion par nom
d'utilisateur/mot de passe, réponses courtes et téléchargements de fichiers - qui sont
soumis au site Web.
1
1.3.1.1 Qu'est-ce qu'une méthode HTTP ?
Une méthode HTTP, parfois appelée verbe HTTP, indique l'action que la requête HTTP attend
du serveur interrogé. Par exemple, deux des méthodes HTTP les plus courantes sont 'GET' et
'POST' ; une requête "GET" attend des informations en retour (généralement sous la forme
d'un site Web), tandis qu'une requête "POST" indique généralement que le client soumet des
informations au serveur Web (telles que des informations de formulaire, par exemple un nom
d'utilisateur et un mot de passe soumis).
 GET :
La méthode http GET demande une représentation de la ressource spécifiée. Les requêtes
utilisant GET ne doivent être utilisées que pour demander des données (elles ne doivent pas
inclure de données).
La demande a un corps Non
La réponse réussie a du corps Oui
Sûr Oui
Idempotent Oui
Cacheable Oui
Autorisé dans les formulaires HTML Oui
 POST
La méthode http POST envoie des données au serveur. Le type du corps de la requête est
indiqué par l’en- Content-Type tête.
La différence entre PUT et POST est que PUT est idempotent : l'appeler une ou plusieurs fois
successivement a le même effet (ce n'est pas un effet secondaire), où des identiques successifs
POST peuvent avoir des effets supplémentaires, comme passer une commande plusieurs fois.
Une POST requête est généralement envoyée via un formulaire HTML et entraîne une
modification sur le serveur. Dans ce cas, le type de contenu est sélectionné en mettant la chaîne
adéquate dans l' enctype attribut de l' <form>élément ou l' form enctype attribut des éléments
<input>ou <button>.
La demande a un corps Oui
La réponse réussie a du corps Oui
Sûr Non
Idempotent Non
2
Cacheable Uniquement si les informations de fraîcheur
sont incluses
Autorisé dans les formulaires HTML Oui
 PUT
La méthode de requête HTTPPUT crée une nouvelle ressource ou remplace une représentation
de la ressource cible par la charge utile de la requête.
La différence entre PUT et POST est que PUT est idempotent : l'appeler une ou plusieurs fois
successivement a le même effet (c'est-à-dire pas d'effet secondaire), alors que des requêtes
identiques successives POST peuvent avoir des effets supplémentaires, comme passer une
commande plusieurs fois.
La réponse réussie a du corps Peut
Sûr Non
Idempotent Oui
Cacheable Non
Autorisé dans les formulaires HTML Non
 DELETE
La méthode de requête http DELETE supprime la ressource spécifiée.
La demande a un corps Peut
La réponse réussie a du corps Peut
Sûr Non
Idempotent Oui
Cacheable Non
Autorisé dans les formulaires HTML Non
3
1.3.1.2 Que sont les en-têtes de requête HTTP ?
Les en-têtes HTTP contiennent des informations textuelles stockées dans des paires clé-valeur,
et elles sont incluses dans chaque requête HTTP (et réponse, nous en reparlerons plus tard).
Ces en-têtes communiquent des informations essentielles, telles que le navigateur utilisé par le
client et les données demandées.
Exemple d'en-têtes de requête HTTP de l'onglet réseau de Google Chrome :
1.3.1.3 Qu'y a-t-il dans le corps d'une requête HTTP ?

Le corps d'une demande est la partie qui contient le « corps » d'informations que la demande
transfère. Le corps d'une requête HTTP contient toutes les informations soumises au serveur
Web, telles qu'un nom d'utilisateur et un mot de passe, ou toute autre donnée saisie dans un
formulaire.
1.3.2 Réponses HTTP.

Le message de réponse HTTP correspond aux données reçues par un périphérique client à
partir du serveur Web. Comme son nom l'indique, la réponse est la réponse du serveur à une
requête HTTP. Les informations contenues dans une réponse HTTP sont adaptées au contexte
que le serveur a reçu de la requête. Les réponses HTTP incluent généralement les données
suivantes :
 Code d'état HTTP, qui indique l'état de la demande au périphérique client. Les
réponses peuvent indiquer un succès, une réponse informative, une redirection ou des
erreurs côté serveur ou côté client.
 Les en-têtes de réponse HTTP, qui envoient des informations sur le serveur et les
ressources demandées.
 Un corps HTTP (facultatif). Si une demande aboutit, celle-ci contient les données
demandées sous forme de code HTML, qui est traduit en une page Web par le
navigateur client.
1.3.2.1 Codes d'état HTTP

En réponse aux requêtes HTTP, les serveurs émettent souvent des codes de réponse, indiquant
que la requête est en cours de traitement, qu'il y a eu une erreur dans la requête ou que la
requête est redirigée. Les codes de réponse courants incluent :
4
 200 d'accord. Cela signifie que la requête, telle que GET ou POST, a fonctionné et est
en cours de traitement.
 300 déplacés de façon permanente. Ce code de réponse signifie que l'URL de la
ressource demandée a été modifiée de façon permanente.
 401 Non autorisé. Le client, ou l'utilisateur faisant la demande au serveur, n'a pas été
authentifié.
 403 Interdit. L'identité du client est connue mais n'a pas reçu d'autorisation d'accès.
 404 Non trouvé. C'est le code d'erreur le plus fréquent. Cela signifie que l'URL n'est
pas reconnue ou que la ressource à l'emplacement n'existe pas.
 500 Erreur de serveur interne. Le serveur a rencontré une situation qu'il ne sait pas
gérer.
Le « xx » fait référence à différents nombres entre 00 et 99.
1.3.2.2 Que sont les en-têtes de réponse HTTP ?

Tout comme une requête HTTP, une réponse HTTP est accompagnée d'en-têtes qui
transmettent des informations importantes telles que la langue et le format des données
envoyées dans le corps de la réponse.
Exemple d'en-têtes de réponse HTTP de l'onglet réseau de Google Chrome :
1.3.2.3 Que contient un corps de réponse HTTP ?

Les réponses HTTP réussies aux requêtes 'GET' ont généralement un corps qui contient les
informations demandées. Dans la plupart des requêtes Web, il s'agit de données HTML qu'un
navigateur Web traduira en une page Web.
1.3.3 Conclusion
HTTP est un protocole extensible facile à utiliser. La structure client-serveur, combinée à la
possibilité d'ajouter des en-têtes, permet à HTTP de progresser parallèlement aux capacités
étendues du Web.
Bien que HTTP/2 ajoute une certaine complexité en incorporant des messages HTTP dans des
trames pour améliorer les performances, la structure de base des messages est restée la même
depuis HTTP/1.0. Le flux de session reste simple, ce qui permet de l'étudier et de le déboguer
avec un simple moniteur de messages HTTP.
5
2 Chapitre 2 : python /MySQL
2.1 Introduction
Python est un langage de programmation. Il est l'un des langages de programmation les plus
intéressants du moment. Facile à apprendre, python est souvent utilisé en exemple lors de
l'apprentissage de la programmation. Vous trouverez sur ce site des cours / tuto informatiques
qui vous enseigneront les bases pour la compréhension de ce langage. Pour les développeurs
plus expérimentés le site vous indiquera quelques astuces pour vos projets.
2.2 Python c'est quoi?

Python est un langage de programmation inventé par Guido van Rossum. La première version
de python est sortie en 1991.
Python est un langage de programmation interprété, c'est-à-dire qu'il n'est pas nécessaire de le
compiler avant de l'exécuter. Si vous avez déjà touché un peu à la programmation, vous verrez
que ce langage possède une certaine poésie. Les programmeurs s'amusent souvent à trouver la
manière la plus élégante et efficace d'écrire une suite d'instructions.
2.3 Que fait Python?

Python est à la fois simple et puissant, il vous permet d'écrire des scripts très simples et grâce
à ses nombreuses bibliothèques, vous pouvez travailler sur des projets plus ambitieux.
* Web: Aujourd'hui python combiné avec le Framework Django est un très bon choix
technologique pour des gros projets de sites internet.
* Système: Python est également souvent utilisé par les admin système pour créer des
tâches dites répétitives ou simplement de maintenance. D'ailleurs si vous voulez créer des
applications java en codant en python, c'est possible grâce au projet Jython.
2.4 Les versions de python

Il existe 2 versions de Python : 2. x et 3. x.
2.5 Différences entres python 2 et python 3

Il y a eu beaucoup de changements pour la sortie de python 3. Le changement le plus radical
étant surement de transformer le print en fonction.
Passer de:
print "bonjour"
Print ("bonjour")
Ce changement fait begguer toutes vos applications python 2 exécutées en python 3, puisque
print est très souvent utilisé.
Il existe d'autres différences entre les versions python 2 et python 3:
6
2.6 PIP c'est quoi?
Pip est un système de gestion de paquets utilisé pour installer et gérer des librairies écrites en
Python. Vous pouvez trouver une grande partie de ces librairies dans le Python Package Index
(ou PyPI). Pip empêche les installations partielles en annonçant toutes les exigences avant
l'installation.
2.7 Installation de pip

Pour installer pip il vous faudra exécuter la commande suivante :
#sudo apt-get install python-pip
2.7.1 Que fait PIP

Pip vous permet d'installer une librairie aussi facilement.
2.8 Base de données et Python
2.8.1 Une base de données c'est quoi?

Une base de données (database en anglais) est un conteneur dans lequel il est possible de
stocker des données de façon structurée. Cette structure permet au programme informatique
connectée à celle-ci de faire des recherches complexes.
Un langage standardisé -SQL- est dédié à cette structure et permet aussi bien de faire des
recherches mais aussi des modifications ou des suppressions.
Les logiciels de gestion de bases de données les plus utilisées aujourd'hui sont des SGBDR -
Système de gestion de base de données relationnelles -, c'est à dire que les données sont liées
les unes aux autres, par exemple on peut définir que si on supprime une information, d'autres
informations dépendantes de cette dernière soient elles-aussi automatiquement supprimées.
Cela garantit une cohérence de données.
Il ne faut donc pas confondre une base de données qui est un conteneur et le SGBDR qui est
un logiciel de gestion de bases de données.
2.8.2 Quels sont les SGBDR les plus connus?

PostgreSQL : PostgreSQL est la base de données à utiliser pour les gros projets. Stable et très
puissant, il permet de gérer des Gigabytes de données sans problème.
Mysql : Mysql est l'un des SGBDR les plus utilisés au monde. Il est gratuit et très
puissant. Il possède la double licence GPL et propriétaire depuis son rachat par Sun
Microsystem eux-mêmes racheté par Oracle (concurrent direct de MySQL). Le logiciel
reste cependant entièrement gratuit et libre. Il répond à une logique client/serveur, c'est
à dire que plusieurs clients (ordinateurs distants) peuvent se connecter sur un seul
serveur qui héberge les données.
MariaDB : Le créateur de MySQL a créé MariaDB suite au rachat de MySQL pour

continuer le projet en open source.
7
Sqlite : SQLite est une bibliothèque écrite en C. SQLite est parfait pour les petits projets.
Sa particularité est d'être intégrée directement à un programme et ne répond donc pas
à la logique client-serveur. Il est le moteur de base de données le plus distribué au
monde puisqu’il est intégré à de nombreux logiciels grand public comme Firefox,
Skype, Adobe, etc. Le logiciel pèse moins de 300 ko et peut donc être intégré à des
projets tournant sur de petits supports comme les smartphones. Souvent aucune
installation n'est nécessaire pour l'utiliser.
Oracle : Oracle Database est sous licence propriétaire, c'est à dire payant. Il est souvent
utilisé pour les projets à gros budget nécessitant de réaliser des actions complexes.
Microsoft SQL Server : Produit Microsoft ne tourne que sur un OS Windows, payant
n'apporte rien de plus que les logiciels concurrents libre de droit. Si vous avez trop
d'argent à la limite...
2.9 Mise en œuvre des programmes python et mysql
2.9.1 MySQL
Installation de MySQL
Tout d'abord il vous faudra installer le paquet MySQL-server en tapant la commande suivante
: #apt install mysql-server
2.9.2 Python
Installation de python3 sous linux
Pour installer python3, on exécute la commande suivante : #apt
install python3
8
2.9.3 Installation de pip3
Pour installer pip3, on installe le paquet suivant :
#apt install python3-pip
2.9.4 Installation du connecteur pymysql

C’est quoi pymysql ?
Installation de pymysql
Pour installer pymysql, il faudra installer le paquet suivant :
#pip3 install pymysql
Maintenant qu’on a fini de préparer notre environnement de développement, Il vous faudra

créer une base de données pour pouvoir faire des requêtes (CRUD) en utilisant des programmes
python. Pour cela nous devons nous connecter sur le serveur MySQL:
2.9.5 Application CRUD avec Python et MySQL

2.9.5.1 Qu’est-ce que le CRUD ?
CRUD est un acronyme pour Create, Read, Update et Delete (Créer, Lire, Mettre à jour et
Supprimer). C’est un ensemble d’opérations de base qui peuvent être effectuées sur une base
de données.
CRUD est un acronyme des noms des quatre opérations de base de la gestion de la persistance
des données et applications :
• Create (créer)
• Read ou Retrieve (lire)
• Update (mettre à jour)
9
• Delete ou Destroy (supprimer)
2.9.5.2 Les étapes de base pour créer une application CRUD
1- Créer une base de données dans MySQL : Tout d’abord, nous devons créer
une base de données MySQL dans votre serveur. Nous pouvons utiliser l’interface graphique
de votre gestionnaire de base de données préféré ou utiliser la ligne de commande pour créer
la base de données.
2- Créer au minimum une table : nous devons créer au minimum une table dans
notre base de données pour pouvoir stocker les données de notre application. Définissez les
colonnes de la table pour stocker les informations dont nous avons besoin. Par exemple, si
nous créons une application pour gérer une banque, nous pouvons créer une table “client” avec
les colonnes “nom”, “prénom”, “email”, etc.
3- Écrire un programme python pour ajouter des données : le programme

doit être exécuté pour ajouter les données dans notre base de données. Le programme doit se
connecter à la base de données, récupérer les données soumises et les ajouter à la table.
5- Créer un programme de lecture : Créez un programme de lecture pour afficher

tous les enregistrements de notre table de base de données. Vous pouvez utiliser une boucle
pour parcourir tous les enregistrements et les afficher dans un tableau ou un autre format.
6- Écrire un programme python pour mettre à jour les données : le

programme python doit être exécuté pour mettre à jour les données dans notre base de données.
Le programme doit se connecter à la base de données, récupérer les données soumises et les
mettre à jour dans la table.
9- Écrire programme python pour supprimer les données : le programme doit

être exécuté pour supprimer l’enregistrement correspondant de notre base de données. Le
programme doit se connecter à la base de données et supprimer l’enregistrement.
Maintenant qu’on a fini de préparer notre environnement de développement, et comprendre

que c’est quoi un CRUD et les étapes pour faire un CRUD. Donc on va passer à la mise en
œuvre. Il vous faudra créer une base de données pour pouvoir faire des requêtes (CRUD) en
utilisant des programmes python. Pour cela nous devons nous connecter sur le serveur MySQL
en tapant la commande suivante :
2.9.5.3 Connexion sur notre serveur mysql

#mysql –u root -p
On vous demandera votre mot de passe mais root par défaut n’a pas de mot de passe.
Une fois la console MySQL ouverte, nous pouvons créer votre base de données.
Dans notre cas, nous la nommerons banque :
10
2.9.5.4 Création de la base de données banque
#create database banque ; : c’est la commande pour créer une base de données sous
MySQL.
#use banque ; : c’est la commande qui nous permet de sélectionner notre base de
données
2.9.5.5 Création de la table client

On va créer la table client sur le serveur MySQL avec les champs suivants comme on le voit
sur la capture suivante :
Insertion de données dans notre table client.
2.9.5.6 Création d’un utilisateur

On va créer un utilisateur nasry avec le mot de passe passer :
11
2.9.5.7 Attribution des droits.
On va donner les droits de privilèges de notre base de données à notre utilisateur nasry en
faisant la commande suivante :
#grant all privileges on banque.* to nasry ;
#flush privileges ; : pour appliquer les privilèges .
2.9.5.8 Création de notre projet.

On va créer un projet tpcrudpython.
2.9.5.9 Programme d’affichage

On va créer un programme qui se connecte dans notre base de données banque et récupérer les
informations des clients et les affiches.
#nano crudpython.py
Et quand on lance notre programme python avec python3 + le nom du fichier (crudpython.py)
on voit bien que notre programme se connecte bien sur notre base de données, récupère les
informations et les affiches.
#python3 crudpython.py
12
2.9.5.10 Programme d’insertion.
Création d’un programme python qui permet d’insérer de données dans notre base de données
plus précisément dans la table client.
On va lancer notre programme en utilisant python3 + le nom de notre fichier : #python3
crudpython.py
Et on remarque sur la capture ci-dessus mbaye est bien inséré.
Vérification au niveau de la base de données.
2.9.5.11 Programme de modification.

On va créer un programme qui nous permet de mettre à jour nos données.
13
On remarque bien que le client 4 qui avait avant 333 comme code, il a maintenant 4444 comme
code.
Avant modification.
Apres modification.
2.9.5.12 Programme de suppression.

On va mettre en place un programme qui nous permet de supprimer des données à travers le
numéro de compte.
14
On remarque bien que le client qui a comme id 4 est bien supprimé.
Avant suppression.
Apres suppression.
PARTIE II : Programme python CGI
Donc en résumer :
15
 Pymsql :
 Les fonctions :
• Database () : qui nous permet de se connecter dans la base de données.
• lecture () : qui nous permet de récupérer les informations et les affiches.
• Insertion () : qui nous permet d’insérer des données dans la base de données
(table client).
• Modifier () : qui nous permet de modifier des données dans la table client.
• Supprimer () : qui nous permet de supprimer des données dans la table client.
 Commit () : sur les trois derniers programmes (insert, modification,
suppression) : qui est important lorsqu’on fait des actions dans la base de
données (table).
16
3 Chapitre 3 Python/ MySQL apache2/CGI
3.1 CGI
La CGI (Common Gateway Interface) est un protocole qui permet aux serveurs Web de
communiquer avec des applications ou des scripts exécutés côté serveur. Ces scripts sont
généralement écrits dans des langages de programmation tels que Python.
3.2 Rôle du CGI :

Le CGI agit comme un intermédiaire entre le serveur web et les programmes/scripts exécutés
sur le serveur. Lorsqu'un client (navigateur web) envoie une requête au serveur pour accéder
à une page ou effectuer une action spécifique, le serveur détecte que la requête nécessite
l'exécution d'un programme CGI. Le serveur passe ensuite les paramètres de la requête au
programme CGI, qui génère une réponse dynamique. Le serveur renvoie ensuite cette réponse
au client pour affichage.
3.2.1 Fonctionnement général de la CGI :

Lorsqu'un client envoie une requête HTTP à un serveur Web pour accéder à une page Web
dynamique, le serveur traite cette requête en utilisant la CGI pour communiquer avec un script.
Le serveur fournit des informations sur la requête au script via des variables d'environnement
et des données d'entrée. Le script génère ensuite une réponse HTTP (HTML, JSON, etc.) qui
est renvoyée au client par le serveur.
3.2.2 Environnement CGI (variables d'environnement) :

Lorsqu'un serveur Web exécute un script CGI, il fournit diverses informations au script via
des variables d'environnement. Ces variables contiennent des informations sur la requête
HTTP, telles que les paramètres de requête, les en-têtes HTTP, l'adresse IP du client, etc. En
Python, vous pouvez accéder à ces variables via le module os ou cgi.
3.2.3 Entrée et sortie du script :

La communication entre le serveur et le script CGI se fait via les flux standard d'entrée et de
sortie. Les données de la requête du client sont transmises au script via le flux d'entrée standard
(stdin). Le script génère ensuite la réponse et la renvoie au serveur via le flux de sortie standard
(stdout). Dans Python, vous pouvez utiliser sys.stdin pour lire les données d'entrée et sys.stdout
pour écrire la réponse.
3.2.4 Lecture des données d'entrée :

Les données d'entrée du client sont généralement transmises sous forme de chaîne de texte
encodée (par exemple, URL-encodée pour les requêtes GET, ou au format x-www-form-
urlencoded pour les requêtes POST). Vous pouvez utiliser le module cgi en Python pour
analyser les données d'entrée et les récupérer sous forme de dictionnaire.
3.2.5 Écriture de la réponse :

Pour renvoyer une réponse HTTP au client, vous devez générer le contenu de la réponse (par
exemple, du code HTML ou JSON) et écrire ce contenu dans la sortie standard (stdout).
Assurez-vous d'inclure les en-têtes HTTP appropriés, tels que "Content-Type", pour indiquer
le type de contenu renvoyé.
17
3.2.6 Permissions d'exécution :
Pour que le serveur Web puisse exécuter votre script CGI, assurez-vous de lui accorder les
bonnes permissions d'exécution. Vous pouvez généralement définir ces permissions via les
commandes chmod dans un terminal.
3.3 Mise en œuvre

root@nasry-ahamadi:/usr/lib/cgi-bin# a2enmod cgi
root@nasry-ahamadi:/usr/lib/cgi-bin# systemctl restart apache2
root@nasry-ahamadi:/usr/lib/cgi-bin# vim programme.py
Voici notre premier programme cgi.
#!/usr/bin/python3
print("Content-Type: text/plain")
print("")
print("Bonjour les developpeurs, voici notre premier programme cgi")
root@nasry-ahamadi:/usr/lib/cgi-bin# chmod a+x programme.py
Test cote navigateur :
http://localhost/cgi-bin/programme.py
18
Pour pouvoir se connecter sur notre serveur de base de données MySQL :
root@nasry-ahamadi:/var/www/html/python-cgi# mysql -u root -p
Création de la base de données banque :
mysql> create database banque;
On se place dans la base de données banque :
mysql> use banque;
Création de la table client :
mysql> create table client(id int primary key auto_increment,prenom varchar(50),nom

varchar(60),code varchar(4),numcompte varchar(40),solde varchar(30));
Description de la table client :
mysql> desc client;
19
Affichage des utilisateur déjà créer :
mysql> select user from mysql.user;
Création de notre répertoire pour mettre nos code python :
root@nasry-ahamadi:/usr/lib/cgi-bin# mkdir crudpythoncgi
root@nasry-ahamadi:/usr/lib/cgi-bin# cd crudpythoncgi/
NB : tous ce qui est de code html on va le mettre dans /var/www/html.

Voici notre code html :
<html>
<head>
<title>insertion</title>
<link href="https://cdn.jsdelivr.net/npm/bootstrap@5.2.3/dist/css/bootstrap.min.css"
rel="stylesheet" integrity="sha384-
20
rbsA2VBKQhggwzxH7pPCaAqO46MgnOM80zW1RWuH61DGLwZJEdK2Kadq2F9CUG6
5" crossorigin="anonymous">
</head>
<body>
<div class="offset-5 my-4 col-3">
<h1 class="text-center">Formulaire</h1>
<form method="POST" action="/cgi-bin/crudpythoncgi/insert.py">
<div class="mb-3">
<label class="form-label" for="prenom">Prenom</label>
<input type="text" name="prenom" class="form-control">
</div>
<div class="mb-3">
<label class="form-label" for="nom">Nom</label>
<input type="text" name="nom" class="form-control">
</div>
<div class="mb-3">
<label class="form-label" for="code">Code</label>
<input type="text" name="code" class="form-control">
</div>
<div class="mb-3">
<label class="form-label" for="numcompte">Numcompte</label>
<input type="text" name="numcompte" class="form-control">
</div>
<div class="mb-3">
<label class="form-label" for="Solde">Solde</label>

21
<input type="text" name="solde" class="form-control">
</div>
<div class="offset-5">
<input type="submit" value="Valider" class="btn btn-success">
</div>
</form>
</body>
</html>
Voici notre code qui permet de faire l’insertion d’un client dans la base de données :
root@nasry-ahamadi:/usr/lib/cgi-bin/crudpythoncgi# vim insert.py
#!/usr/bin/python3
import pymysql,cgi,cgitb
def database():
global conn,curseur
conn=pymysql.connect(host="localhost",user="nasry",passwd="passer",database="banque")
curseur=conn.cursor()
22
def insertion(prenom,nom,code,numcompte,solde):
req="insert into client(prenom,nom,code,numcompte,solde) values (%s,%s,%s,%s,%s)"
database()
val=(prenom,nom,code,numcompte,solde)
curseur.execute(req,val)
conn.commit()
print("Content-Type:text/plain")
print("")
print("insertion reussi")
form=cgi.FieldStorage()
prenom=form.getvalue('prenom')
nom=form.getvalue('nom')
code=form.getvalue('code')
numcompte=form.getvalue('numcompte')
solde=form.getvalue('solde')
insertion(prenom,nom,code,numcompte,solde)
23
Attribution des droits d’exécution :
root@nasry-ahamadi:/usr/lib/cgi-bin/crudpythoncgi# chmod a+x insert.py
http://localhost/python-cgi/insert.html
24
mysql> select * from client;
root@nasry-ahamadi:/usr/lib/cgi-bin/crudpythoncgi# curl -X POST "http://localhost/cgi-

bin/crudpythoncgi/insert.py" -d
"prenom=Berenger&nom=Benam&code=2222&numcompte=1002&solde=200000"
Voici notre code python qui permet d’afficher les clients qui existent dans la base de données
sans l’utilisation du bootstrap :
root@nasry-ahamadi:/usr/lib/cgi-bin/crudpythoncgi# vim affiche.py
#!/usr/bin/python3
import pymysql
def database():
global conn,curseur
25
def affiche():
req="select * from client"
database()
curseur.execute(req)
print("Content-Type:text/html")
print("")
print("<body><table
border='1px'><tr><td>Prenom</td><td>Nom</td><td>Code</td><td>Numcompte</td><td
>Solde</td></tr>")
for row in curseur.fetchall():
print(f"<tr><td>{row[1]}</td><td>{row[2]}</td><td>{row[3]}</td><td>{row[4]}</td><td
>{row[5]}</td></tr>")
print("</table></body>")
affiche()
root@nasry-ahamadi:/usr/lib/cgi-bin/crudpythoncgi# chmod a+x affiche.py
26
http://localhost/cgi-bin/crudpythoncgi/affiche.py
Voici notre code python qui permet d’afficher les clients qui existent dans la base de données
en utilisant aussi du bootstrap :
root@nasry-ahamadi:/usr/lib/cgi-bin/crudpythoncgi# vim affiche1.py
#!/usr/bin/python3
import pymysql
def database():
global conn, curseur
conn = pymysql.connect(host="localhost", user="nasry", passwd="passer",

database="banque")
curseur = conn.cursor()
def affiche():
req = "SELECT * FROM client"
database()
# Print the HTML header with Bootstrap link
27
print("")
print("<!DOCTYPE html>")
print("<html>")
print("<head>")
print("<title>Client Data</title>")
print('<link rel="stylesheet"
href="https://cdnjs.cloudflare.com/ajax/libs/bootstrap/5.2.3/css/bootstrap.min.css">')
print("</head>")
print("<body>")
# Print the table with Bootstrap classes
print('<div class="container">')
print('<h1 class="text-center">Liste des Clients</h1>')
print('<table class="table table-bordered table-striped table-hover">')
print("<tr><td>Prenom</td><td>Nom</td><td>Code</td><td>Numcompte</td><td>Solde
</td></tr>")
>{row[5]}</td></tr>")
print("</table>")
print('</div>')
# Print the HTML footer
print("</body>")
print("</html>")
affiche()
28
root@nasry-ahamadi:/usr/lib/cgi-bin/crudpythoncgi# chmod a+x affiche1.py
http://localhost/cgi-bin/crudpythoncgi/affiche1.py
Voici notre formulaire :
root@nasry-ahamadi:/var/www/html/python-cgi# nano update.html
<html>
<head>
29
rbsA2VBKQhggwzxH7pPCaAqO46MgnOM80zW1RWuH61DGLwZJEdK2Kadq2F9CUG
</head>
<body>
<h1 class="text-center">Formulaire update</h1>
<form method="POST" action="/cgi-bin/crudpythoncgi/update.py">
<div class="mb-3">
</div>
<div class="mb-3">
</div>
<input type="submit" value="Valider" class="btn btn-warning">
</div>
</form>
</body>
</html>
30
Voici notre code python qui permet de faire la mise à jour du solde d’un client quand le client
saisit son code :
root@nasry-ahamadi:/usr/lib/cgi-bin/crudpythoncgi# vim update.py
#!/usr/bin/python3
def database():
global conn,curseur
def update(code,solde):
req="update client set solde=%s where code=%s"
database()
val=(solde,code)
conn.commit()
print("")
print("mis a jour reussie")
31
solde=form.getvalue('solde')
update(code,solde)
root@nasry-ahamadi:/usr/lib/cgi-bin/crudpythoncgi# chmod a+x update.py
http://localhost/python-cgi/update.html
32
root@nasry-ahamadi:/var/www/html/python-cgi# nano suppression.html
<html>
<head>
</head>
<body>
33
<h1 class="text-center">Formulaire suppression</h1>
<form method="POST" action="/cgi-bin/crudpythoncgi/suppression.py">
<div class="mb-3">
</div>
<input type="submit" value="Valider" class="btn btn-danger">
</div>
</form>
</body>
</html>
root@nasry-ahamadi:/usr/lib/cgi-bin/crudpythoncgi# vim suppression.py
#!/usr/bin/python3
def database():
global conn,curseur
34
def suppression(code):
req="delete from client where code=%s"
database()
val=(code,)
conn.commit()
print("")
print("suppression reussie")
suppression(code)
35
root@nasry-ahamadi:/usr/lib/cgi-bin/crudpythoncgi# chmod a+x suppression.py
http://localhost/python-cgi/suppression.html
Avant suppression :
Apres suppression :
36
3.4 Curl :
Le client cURL est un outil en ligne de commande couramment utilisé pour effectuer des
requêtes HTTP. Vous pouvez utiliser cURL pour envoyer des requêtes avec différents verbes
HTTP en utilisant l'option -X suivie du verbe approprié. L'option -d permet de spécifier les
données à inclure dans le corps de la requête.
3.5 Voici une explication détaillée de chaque verbe et de la manière dont ils
sont mis en œuvre avec Curl :
3.5.1 GET :
Le verbe GET est utilisé pour récupérer des données depuis un serveur. Il s'agit d'une opération
sans effet de côté, ce qui signifie qu'elle ne devrait pas modifier l'état du serveur. Lorsque vous
effectuez une requête GET, vous demandez au serveur de vous fournir des données
spécifiques.
Exemple d'utilisation avec Curl :
curl -X GET http://example.com/api/resource
Dans cette commande, Curl envoie une requête GET à l'URL
http://example.com/api/resource pour récupérer les données de la ressource spécifiée.
3.5.2 POST :
Le verbe POST est utilisé pour envoyer des données au serveur, souvent dans le but de créer
une nouvelle ressource. Les données sont incluses dans le corps de la requête. Cela peut être
utilisé pour soumettre des formulaires en ligne ou pour envoyer des données structurées.
curl -X POST "https://example.com/api/resource " -d "param1=value1&param2=value2"
Ici, Curl envoie une requête POST à l'URL donnée avec les paramètres spécifiés dans le corps
de la requête.
3.5.3 PUT :
Le verbe PUT est utilisé pour mettre à jour une ressource existante sur le serveur ou pour créer
une nouvelle ressource si elle n'existe pas. Comme avec POST, les données à mettre à jour
sont incluses dans le corps de la requête.
curl -X PUT "https://example.com/api/resource/123" -d "updatedData"
Cette commande envoie une requête PUT pour mettre à jour la ressource avec l'ID 123 en
utilisant les données fournies.
3.5.4 DELETE :
Le verbe DELETE est utilisé pour supprimer une ressource spécifiée sur le serveur.
37
curl -X DELETE https://example.com/api/resource/123
Dans cet exemple, Curl envoie une requête DELETE pour supprimer la ressource avec l'ID
123.
Pour chaque verbe, les données peuvent être passées dans le corps de la requête avec l'option
-d, comme illustré dans les exemples ci-dessus. Cependant, pour les requêtes GET et DELETE,
les données sont généralement passées sous forme de paramètres d'URL plutôt que dans le
corps de la requête.
3.6 Mise en œuvre

3.6.1 Utilisation de GET
root@nasry-ahamadi:/usr/lib/cgi-bin/crudpythoncgi# curl -X GET "http://localhost/cgi-

bin/crudpythoncgi/affiche.py"
3.6.2 Utilisation de POST

root@nasry-ahamadi:/usr/lib/cgi-bin/crudpythoncgi# curl -X POST "http://localhost/cgi-
bin/crudpythoncgi/insert.py" -d
"prenom=Ahamadi&nom=Nasry&code=2222&numcompte=1002&solde=800000"
Avant insertion :
38
Apres insertion :
3.6.3 Utilisation de PUT

root@nasry-ahamadi:/usr/lib/cgi-bin/crudpythoncgi# curl -X PUT "http://localhost/cgi-
bin/crudpythoncgi/update.py" -d "code=2222&solde=900000"
Avant mis à jour :
Apres mis à jour :
39
3.6.4 Utilisation de DELETE
root@nasry-ahamadi:/usr/lib/cgi-bin/crudpythoncgi# curl -X DELETE "http://localhost/cgi-
bin/crudpythoncgi/suppression.py" -d "code=2222"
Avant suppression :
Apres suppression :
40
4 Chapitre 4 : Python/ PostgreSQL / apache2/CGI
4.1 Présentation de PostgreSQL
PostgreSQL est un système de gestion de bases de données relationnelles puissant et open-
source. Il est largement utilisé pour le stockage et la récupération des données dans les
applications modernes.
 Base de données relationnelle : PostgreSQL est un système de gestion de base de

données relationnelle (SGBDR), ce qui signifie qu'il stocke et gère les données sous
forme de tables composées de lignes et de colonnes. Chaque table représente un type
d'entité, et les relations entre les tables sont établies à l'aide de clés étrangères.
 Tables : Les tables sont des structures de données fondamentales dans PostgreSQL.
Chaque table a un nom unique et est composée de colonnes qui définissent les attributs
des données que la table va contenir.
 Colonnes : Chaque colonne d'une table définit un attribut spécifique des données.
Chaque entrée (ligne) dans la table aura une valeur pour chaque colonne, représentant
les données réelles.
 Lignes : Les lignes d'une table contiennent les données proprement dites. Chaque ligne
représente une instance d'une entité particulière.
 Clé primaire : Une clé primaire est une ou plusieurs colonnes qui garantissent l'unicité
des lignes dans une table. Elle est utilisée pour identifier de manière unique chaque
enregistrement dans la table.
 Clé étrangère : Une clé étrangère est une colonne (ou un ensemble de colonnes) qui
établit une relation entre deux tables. Elle pointe vers la clé primaire d'une autre table
et permet d'établir des relations entre les données dans les différentes tables.
 Index : Un index est une structure de données utilisée pour accélérer la recherche dans
une table. Il améliore les performances en permettant un accès plus rapide aux données,
similaire à la façon dont un index dans un livre facilite la recherche de contenu
spécifique.
41
 Requêtes SQL : PostgreSQL utilise le langage de requête structuré (SQL) pour
manipuler et interroger les données. Les requêtes SQL permettent de récupérer, insérer,
mettre à jour ou supprimer des données dans les tables.
 Transactions : PostgreSQL prend en charge les transactions pour garantir l'intégrité

des données. Une transaction est un ensemble d'opérations SQL exécutées comme une
seule unité cohérente. Si une partie d'une transaction échoue, les modifications sont
annulées pour maintenir la cohérence des données.
4.2 Install de PostgreSQL

root@nasry-ahamadi:~# apt update
Pour installer PostgreSQL sur Ubuntu, exécutez la commande suivante :
root@nasry-ahamadi:~# apt install postgresql postgresql-contrib
4.2.1 Vérifier l’installation de PostgreSQL

Pour vérifier que PostgreSQL est installé et fonctionne, vous pouvez exécuter la commande
suivante :
root@nasry-ahamadi:~# systemctl status postgresql
42
4.2.2 Accéder à PostgreSQL
Pour se connecter sur notre serveur PostgreSQL on tape la commande suivante :
Pour accéder à PostgreSQL, vous pouvez utiliser l’interface de ligne de commande psql. Pour
lancer l’interpréteur de commandes psql, exécutez la commande suivante :
root@nasry-ahamadi:~# sudo -u postgres psql
Ceci vous connectera en tant que superutilisateur de PostgreSQL (postgres) et vous donnera
accès à l’interface de ligne de commande de PostgreSQL.
4.2.3 Créer un nouveau rôle

Un rôle est un compte utilisateur qui peut se connecter à un cluster de base de données
PostgreSQL. Pour créer un nouveau rôle, suivez les étapes suivantes :
Dans l’interface de ligne de commande de PostgreSQL, tapez la commande suivante pour créer
un nouveau rôle :
postgres=# CREATE ROLE nasry WITH LOGIN PASSWORD 'passer';
Pour accorder au nouveau rôle l’autorisation de créer des bases de données, tapez la commande
suivante :
postgres=# ALTER ROLE nasry CREATEDB;
Cela permettra au nouvel utilisateur de créer des bases de données.
43
4.2.4 Création d’une nouvelle base de données
Pour créer une nouvelle base de données dans PostgreSQL, tapez la commande suivante :
postgres=# CREATE DATABASE banque;
4.2.5 Attribution des privilèges

Pour autoriser le nouvel utilisateur (nasry) à accéder à la nouvelle base de données (banque),
saisissez la commande suivante :
postgres=# GRANT ALL PRIVILEGES ON DATABASE banque TO nasry;
Pour se connecter sur la base donnée banque :
postgres=# \c banque;
Pour créer la base de données client avec les champs suivants:
banque=# create table client(id serial primary key,prenom varchar(50),nom varchar(40),code

varchar(30),numcompte varchar(20),solde varchar(30));
La commande GRANT en SQL est utilisée pour accorder des privilèges (permissions) à des
utilisateurs ou des rôles sur des objets tels que des tables, des vues, des schémas, etc.
banque=# GRANT SELECT, INSERT, UPDATE, DELETE ON TABLE client TO nasry;
Cette commande accorde certains privilèges à l'utilisateur ou au rôle "nasry" sur la table
"client". Plus précisément, les privilèges accordés sont les suivants :
 SELECT : Permet à l'utilisateur "nasry" de lire (sélectionner) les données de la table

"client".
 INSERT : Permet à l'utilisateur "nasry" d'insérer de nouvelles lignes dans la table
"client".
44
 UPDATE : Permet à l'utilisateur "nasry" de mettre à jour les données existantes dans
la table "client".
 DELETE : Permet à l'utilisateur "nasry" de supprimer des lignes de la table "client".
banque=# GRANT USAGE, SELECT ON SEQUENCE client_id_seq TO nasry;
Cette commande accorde certains privilèges à l'utilisateur ou au rôle "nasry" sur une séquence
nommée "client_id_seq" :
 GRANT : C'est le mot-clé qui indique que vous allez accorder des privilèges à un
utilisateur ou à un rôle.
 USAGE : Ce privilège permet à l'utilisateur ou au rôle d'utiliser la séquence. En
accordant le privilège USAGE, vous autorisez "nasry" à utiliser cette séquence dans le
contexte de l'incrémentation des valeurs de séquence.
 SELECT : Ce privilège permet à l'utilisateur ou au rôle d'exécuter une instruction
SELECT sur la séquence. Bien que les séquences soient principalement utilisées pour
générer des valeurs uniques, accorder le privilège SELECT permet à "nasry"
d'interroger la séquence pour obtenir sa valeur actuelle ou d'autres propriétés.
 ON SEQUENCE client_id_seq : Cela spécifie la séquence sur laquelle les privilèges
sont accordés. Dans ce cas, il s'agit de la séquence nommée "client_id_seq".
 TO nasry : C'est le destinataire des privilèges. Vous accordez les privilèges à
l'utilisateur ou au rôle "nasry".
Pour quitter l’interface de ligne de commande PostgreSQL, tapez \q et appuyez sur Entrée.
4.2.6 Installation du psycopg2

psycopg2 est une bibliothèque Python populaire qui permet aux développeurs de se connecter
à des bases de données PostgreSQL depuis des applications Python. Elle offre une interface
simple et efficace pour interagir avec des bases de données PostgreSQL, exécuter des requêtes,
gérer les transactions et récupérer les résultats.
root@nasry-ahamadi:~# pip3 install psycopg2
45
Création de notre répertoire pour mettre nos codes python :
root@nasry-ahamadi:/usr/lib/cgi-bin# mkdir cgipostegres
root@nasry-ahamadi:/usr/lib/cgi-bin# cd cgipostegres/
Voici notre formulaire html :
root@nasry-ahamadi:/var/www/html/python-cgi# nano insertion.html
<html>
<head>
</head>
<body>
<form method="POST" action="/cgi-bin/cgipostegres/insert.py">
<div class="mb-3">
<label class="form-label" for="prenom">Prenom</label>
<input type="text" name="prenom" class="form-control">
</div>
<div class="mb-3">
<label class="form-label" for="nom">Nom</label>
<input type="text" name="nom" class="form-control">
46
</div>
<div class="mb-3">
</div>
<div class="mb-3">
<label class="form-label" for="numcompte">Numcompte</label>
<input type="text" name="numcompte" class="form-control">
</div>
<div class="mb-3">
</div>
<input type="submit" value="Valider" class="btn btn-success">
</div>
</form>
</body>
</html>
47
Voici notre code python qui permet d’ajouter un client :
root@nasry-ahamadi:/usr/lib/cgi-bin/cgipostegres# vim insert.py
#!/usr/bin/python3
import psycopg2
import cgi
import cgitb
def database():
conn = psycopg2.connect(host="localhost", user="nasry", password="passer",

dbname="banque")
48
def insertion(prenom, nom, code, numcompte, solde):
req = "INSERT INTO client(prenom,nom,code,numcompte,solde) VALUES

(%s,%s,%s,%s,%s)"
database()
val = (prenom,nom,code,numcompte,solde)
conn.commit()
print("")
print("Insertion réussie")
form = cgi.FieldStorage()
prenom = form.getvalue('prenom')
nom = form.getvalue('nom')
code = form.getvalue('code')
numcompte = form.getvalue('numcompte')
solde = form.getvalue('solde')
insertion(prenom,nom,code,numcompte,solde)
root@nasry-ahamadi:/usr/lib/cgi-bin/cgipostegres# chmod a+x insert.py
49
banque=# select * from client;
50
Voici notre formulaire html :
root@nasry-ahamadi:/var/www/html/python-cgi# nano update.html
<html>
<head>
</head>
<body>
<form method="POST" action="/cgi-bin/cgipostegres/update.py">
<div class="mb-3">
</div>
<div class="mb-3">
51
</div>
<input type="submit" value="Valider" class="btn btn-warning">
</div>
</form>
</body>
</html>
Voici notre programme python qui permet de mettre à jour le solde d’un client :
root@nasry-ahamadi:/usr/lib/cgi-bin/cgipostegres# vim update.py
#!/usr/bin/python3
import psycopg2
import cgi
52
import cgitb
def database():

dbname="banque")
def update(code,solde):
req = "UPDATE client SET solde=%s WHERE code=%s"
database()
val = (solde,code)
conn.commit()
print("")
print("Insertion réussie")
solde = form.getvalue('solde')
update(code,solde)
53
root@nasry-ahamadi:/usr/lib/cgi-bin/cgipostegres# chmod a+x update.py
Avant modification :
Apres modification :
54
Voici notre code python qui permet d’afficher les clients qui se trouvent dans la base de
données sans l’utilisation du bootstrap:
#!/usr/bin/python3
import psycopg2
def database():
global conn,curseur
conn=psycopg2.connect(host="localhost",user="nasry",password="passer",dbname="banque
")
def affiche():
req="select * from client"
database()
print("")
print("<body><table
border='1px'><tr><td>Prenom</td><td>Nom</td><td>Code</td><td>Numcompte</td><td
>Solde</td></tr>")
55
>{row[5]}</td></tr>")
print("</table></body>")
affiche()
root@nasry-ahamadi:/usr/lib/cgi-bin/cgipostegres# chmod a+x affiche.py
http://localhost/cgi-bin/cgipostegres/affiche.py
Voici notre code python qui permet d’afficher les clients qui se trouvent dans la base de
données avec l’utilisation de bootstrap :
root@nasry-ahamadi:/usr/lib/cgi-bin/cgipostegres# vim affiche1.py
#!/usr/bin/python3
import psycopg2
def database():

dbname="banque")
56
def affiche():
req = "SELECT * FROM client"
database()
# Print the HTML header with Bootstrap link
print("")
print("<!DOCTYPE html>")
print("<html>")
print("<head>")
print("<title>Client Data</title>")
print('<link rel="stylesheet"
href="https://cdnjs.cloudflare.com/ajax/libs/bootstrap/5.2.3/css/bootstrap.min.css">')
print("</head>")
print("<body>")
# Print the table with Bootstrap classes
print('<div class="container">')
print('<h1 class="text-center">Liste des Clients</h1>')
print('<table class="table table-bordered table-striped table-hover">')
print("<tr><td>Prenom</td><td>Nom</td><td>Code</td><td>Numcompte</td><td>Solde
</td></tr>")
>{row[5]}</td></tr>")
print("</table>")
print('</div>')
57
# Print the HTML footer
print("</body>")
print("</html>")
affiche()
root@nasry-ahamadi:/usr/lib/cgi-bin/cgipostegres# chmod a+x affiche1.py
http://localhost/cgi-bin/cgipostegres/affiche1.py
58
root@nasry-ahamadi:/var/www/html/python-cgi# nano suppression.html
<html>
<head>
<title>suppression</title>
</head>
<body>
<h1 class="text-center">Formulaire suppression</h1>
<form method="POST" action="/cgi-bin/cgipostegres/suppression.py">
<div class="mb-3">
</div>
<input type="submit" value="Valider" class="btn btn-danger">
</div>
</form>
</body>
</html>
59
root@nasry-ahamadi:/usr/lib/cgi-bin/cgipostegres# vim suppression.py
#!/usr/bin/python3
import psycopg2
import cgi
import cgitb
def database():

dbname="banque")
def suppression(code):
req = "DELETE FROM client WHERE code=%s"
database()
60
val = (code)
conn.commit()
print("")
print("Suppression réussie")
suppression(code)
root@nasry-ahamadi:/usr/lib/cgi-bin/cgipostegres# chmod a+x suppression.py
http://localhost/python-cgi/suppression.html
61
Avant suppression :
Apres suppression :
4.3 Utilisation de la commande curl :

4.3.1 Utilisation de POST
root@nasry-ahamadi:/usr/lib/cgi-bin/cgipostegres# curl -X POST "http://localhost/cgi-
bin/cgipostegres/insert.py" -d
"prenom=Berenger&nom=Benam&code=2222&numcompte=1002&solde=200000"
62
4.3.2 Utilisation de GET
root@nasry-ahamadi:/usr/lib/cgi-bin/cgipostegres# curl -X GET "http://localhost/cgi-
bin/cgipostegres/affiche.py"
4.3.3 Utilisation de PUT

root@nasry-ahamadi:/usr/lib/cgi-bin/cgipostegres# curl -X PUT "http://localhost/cgi-
bin/cgipostegres/update.py" -d "code=2222&solde=500000"
4.3.4 Utilisation de DELETE

root@nasry-ahamadi:/usr/lib/cgi-bin/cgipostegres# curl -X DELETE "http://localhost/cgi-
bin/cgipostegres/suppression.py" -d "code=2222"
63
Avant suppression :
Apres suppression :
4.3.5 Installation de pgadmin4

pgAdmin est une plate-forme d'administration et de développement PostgreSQL riche en
fonctionnalités et open source qui s'exécute sous Linux, Unix, Mac OS X et Windows.
Avec pgAdmin, vous pouvez gérer les serveurs de bases de données PostgreSQL.
Pour installer PgAdmin4, vous devez ajouter le dépôt de la dernière version de PgAdmin4 à
votre système. Pour ce faire, entrez les commandes suivantes dans votre terminal :
root@nasry-ahamadi:~# curl https://www.pgadmin.org/static/packages_pgadmin_org.pub |

sudo apt-key add
Ensuite, ajoutez le dépôt au fichier sources.list de votre système en exécutant la commande

suivante :
root@nasry-ahamadi:~# echo "deb

https://ftp.postgresql.org/pub/pgadmin/pgadmin4/apt/$(lsb_release -cs) pgadmin4 main" |
sudo tee /etc/apt/sources.list.d/pgadmin4.list
64
Enfin, mettez à jour les listes de packages.
root@nasry-ahamadi:~# apt update
Enfin, installez PgAdmin4 en exécutant la commande suivante :
root@nasry-ahamadi:~# apt install pgadmin4
Lancez la configuration du serveur Web Apache.
root@nasry-ahamadi:~# /usr/pgadmin4/bin/setup-web.sh
Cela vous demandera de saisir l'adresse e-mail de l'utilisateur pgadmin4 et de définir le mot de
passe, Acceptez aussi la configuration du serveur Web Apache en mettant y et y comme vous
le voyais sur l’image en haut:
65
Après l’installation, vous pouvez accéder à PgAdmin4 en ouvrant votre navigateur web et en
entrant l’URL suivante :
http://localhost/pgadmin4/
Connectez-vous en utilisant l'adresse e-mail et le mot de passe définis.
Sur la première page de pgAdmin, ajoutez un serveur PostgreSQL à administrer avec pgAdmin
en cliquant sur "Ajouter un nouveau serveur". Cela peut être un serveur PostgreSQL local ou
distant.
66
Dans la section "Général", donnez un nom et une description au serveur.
Sous l'onglet "Connexion", fournissez les détails d'accès - hôte de base de données,
utilisateur de base de données et mot de passe.
67
Une fois terminé, cliquez sur le bouton Enregistrer pour enregistrer les configurations. Si
vous avez réussi à ajouter le serveur, le nom apparaîtra dans la barre latérale gauche.
68
69
70
71
72
73

Support Cours Python

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Support Cours Python

Transféré par

Droits d'auteur :

Formats disponibles

École Centrale des Logiciels Libres et de Télécommunications

Institut Supérieur de Technologie de l'Université de Bangui

Présenté par : Sous la supervision :

1.2 Comment fonctionne HTTP

1.3 Requêtes et réponses HTTP

1.3.1 Requêtes HTTP.

La réponse réussie a du corps Oui

Autorisé dans les formulaires HTML Oui

La réponse réussie a du corps Oui

Autorisé dans les formulaires HTML Oui

La réponse réussie a du corps Peut

Autorisé dans les formulaires HTML Non

La demande a un corps Oui

La réponse réussie a du corps Peut

Autorisé dans les formulaires HTML Non

Exemple d'en-têtes de requête HTTP de l'onglet réseau de Google Chrome :

1.3.1.3 Qu'y a-t-il dans le corps d'une requête HTTP ?

1.3.2 Réponses HTTP.

1.3.2.1 Codes d'état HTTP

Le « xx » fait référence à différents nombres entre 00 et 99.

1.3.2.2 Que sont les en-têtes de réponse HTTP ?

Exemple d'en-têtes de réponse HTTP de l'onglet réseau de Google Chrome :

1.3.2.3 Que contient un corps de réponse HTTP ?

2.2 Python c'est quoi?

2.3 Que fait Python?

2.4 Les versions de python

2.5 Différences entres python 2 et python 3

Il existe d'autres différences entre les versions python 2 et python 3:

2.7 Installation de pip

#sudo apt-get install python-pip

2.7.1 Que fait PIP

2.8 Base de données et Python

2.8.1 Une base de données c'est quoi?

2.8.2 Quels sont les SGBDR les plus connus?

MariaDB : Le créateur de MySQL a créé MariaDB suite au rachat de MySQL pour

2.9 Mise en œuvre des programmes python et mysql

: #apt install mysql-server

#apt install python3-pip

2.9.4 Installation du connecteur pymysql

Pour installer pymysql, il faudra installer le paquet suivant :

#pip3 install pymysql

Maintenant qu’on a fini de préparer notre environnement de développement, Il vous faudra

2.9.5 Application CRUD avec Python et MySQL

3- Écrire un programme python pour ajouter des données : le programme

5- Créer un programme de lecture : Créez un programme de lecture pour afficher

6- Écrire un programme python pour mettre à jour les données : le

9- Écrire programme python pour supprimer les données : le programme doit

Maintenant qu’on a fini de préparer notre environnement de développement, et comprendre

2.9.5.3 Connexion sur notre serveur mysql

Dans notre cas, nous la nommerons banque :

2.9.5.5 Création de la table client

Insertion de données dans notre table client.

2.9.5.6 Création d’un utilisateur

#grant all privileges on banque.* to nasry ;

#flush privileges ; : pour appliquer les privilèges .

2.9.5.8 Création de notre projet.

2.9.5.9 Programme d’affichage

On va lancer notre programme en utilisant python3 + le nom de notre fichier : #python3

Et on remarque sur la capture ci-dessus mbaye est bien inséré.

Vérification au niveau de la base de données.

2.9.5.11 Programme de modification.

2.9.5.12 Programme de suppression.

On remarque bien que le client qui a comme id 4 est bien supprimé.