CPGE MP Informatique

Casablanca
Exploitation d’une BDD via Python

1. Introduction
Les bases de données sont des outils de plus en plus fréquemment utilisés. Elles
permettent de stocker des données nombreuses dans un seul ensemble bien structuré,
d’éviter le plus souvent les doublons et d’assurer la cohérence des informations qu’elles
contiennent.
Python vous donne les outils nécessaires pour profiter des ressources de
nombreux systèmes (MySQL, PostgreSQL, …). Pour ce cours nous interagirons avec une
base de données SQLite. Autrement dit, vous pouvez en Python, créer une application
contenant son propre SGBDR intégré, sans qu'il soit nécessaire d'installer quoi que ce soit
d'autre.
2. Création d’une base de données SQLite en Python
Pour accéder aux fonctionnalités désirées, il suffit d'importer le module sqlite3
intégré à Python :
>>>import sqlite3
Puis, vous pouvez utiliser la fonction connect() qui prend en paramètre l’adresse de
votre base de données et qui crée un objet de connexion. Cet objet assurera l'interface entre
votre programme et la base de données.
>>>fichierDonnees ="E:/test/bd_test"
>>>conn =sqlite3.connect(fichierDonnees)
Une fois l'objet connexion créé, il faut créer un objet curseur destiné à mémoriser
temporairement les données en cours de traitement et les opérations que vous effectuez sur
elles, avant leur transfert définitif dans la base de données. Cette technique permet donc
d'annuler si nécessaire une ou plusieurs opérations qui se seraient révélées inadéquates, et
de revenir en arrière dans le traitement, sans que la base de données n'en soit affectée.
>>>cur =conn.cursor()
Grâce aux objets connexion et curseur créés, il est désormais possible de «
dialoguer » avec la base de données en effectuant des requêtes SQL.
La création d’une nouvelle table dans notre base de données se fait par exemple
par l’instruction ci-dessous :
>>>cur.execute("CREATE TABLE membres (age INTEGER PRIMARY KEY, nom TEXT,
taille REAL)")

Prof : S. EL KASM 1
CPGE MP Informatique
Casablanca
Ici nous avons créé une table nommée membres contenant trois champs : age de
type entier, nom de type chaîne de caractères et taille un réel.
La requête est exprimée dans une chaîne de caractères classique, que nous
transmettons au curseur par l'intermédiaire de sa méthode execute().
La saisie de nouveaux enregistrements se fait également via la méthode execute et
des requêtes SQL correspondantes. Par exemple :
>>>cur.execute("INSERTINTO membresVALUES(21,'Ali',1.83)")
>>>cur.execute("INSERT INTO membresVALUES(15,'Amine',1.57)")
>>>cur.execute("INSERT Into membresVALUES(18,'Zineb',1.69)")
Attention : à ce stade, les enregistrements sont dans le tampon du curseur, mais ils
n'ont pas encore été transférés véritablement dans la base de données. Le transfert dans la
base sera déclenché par la méthode commit() de l'objet connexion :
>>>conn.commit()
Une fois les échanges souhaités avec la base de données réalisés, le curseur et la
connexion doivent être refermés :
>>>cur.close()
>>>conn.close()
3. Interroger une base de données SQLite en Python
L'interrogation de la base s'effectue à l'aide de requêtes SQL, par l’intermédiaire
également de la méthode execute() du curseur, toujours sous la forme de chaînes de
caractères :
>>>cur.execute("SELECT * FROM membres")
Cette requête demande la sélection d'un ensemble particulier d'enregistrements, qui
devront être transférés de la base de données au curseur.
Les enregistrements sélectionnés sont donc à présent dans le curseur. Si nous
voulons les voir, nous devons les en extraire. Cela peut être réalisé de deux façons, qui
peuvent paraître différentes à première vue, mais qui en réalité tirent parti toutes les deux
du fait que l'objet-curseur produit par Python est un itérateur, c'est-à-dire un dispositif
générateur de séquences.
Vous pouvez parcourir directement la séquence qu'il produit, à l'aide d'une boucle
for classique. Vous obtenez une série de tuples :
>>>forl incur:
... print(l)

Prof : S. EL KASM 2
CPGE MP Informatique
Casablanca
...
(21, 'Ali', 1.83)
(15, 'Amine', 1.57)
(18, 'Zineb', 1.69)
...
ou bien la recueillir dans une liste ou un tuple en vue d'un traitement ultérieur (à l'aide des
fonctions intégrées list()et tuple()) :
>>>cur.execute("SELECT * FROM membres")
>>>list(cur)
[(21, 'Ali', 1.83), (15, 'Amine', 1.57), (18, 'Zineb', 1.69)]
Vous pouvez également, d'une manière plus classique, faire appel à la méthode
fetchall() du curseur, laquelle renvoie elle aussi une liste de tuples :
>>>cur.execute("SELECT * FROM membres")
>>>cur.fetchall()
[(21, 'Ali', 1.83), (15, 'Amine', 1.57), (18, 'Zineb', 1.69)]
4. Insertions, modifications et suppressions
Dans un programme concret, les données à enregistrer se présenteront la plupart
du temps dans des variables Python. Vous devrez donc construire la chaîne de caractères
contenant la requête SQL, en y incluant les valeurs tirées de ces variables. La bonne
technique est illustrée ci-après : la chaîne « patron » utilise le point d'interrogation comme
balise de conversion, et le formatage proprement dit est pris en charge par la méthode
execute() du curseur :
>>>data =[(17,"Imad",1.74),(22,"Wafae",1.71),(20,"Salma",1.65)]
>>>fortu in data:
... cur.execute("INSERT INTO membres(age,nom,taille) VALUES(?,?,?)", tu)
...
>>>conn.commit()
Dans cet exemple, la chaîne de requête comporte 3 points d'interrogation, qui sont
nos balises. Elles seront remplacées par les 3 éléments du tuple tu à chaque itération de la
boucle, le module d'interface avec SQLite se chargeant de traiter chaque variable
correctement en fonction de son type.
Pour modifier un ou plusieurs enregistrements, exécutez une requête du type :
>>>cur.execute("UPDATE membres SET nom ='Wafae' WHERE nom='Wafaa'")
Pour supprimer un ou plusieurs enregistrements, utilisez une requête telle que :

Prof : S. EL KASM 3
CPGE MP Informatique
Casablanca
>>>cur.execute("DELETE FROM membres WHERE nom='Salma'")
Attention : n'oubliez pas que toutes les modifications apportées au curseur se
passent en mémoire vive, et de ce fait rien n'est enregistré définitivement tant que vous
n'exécutez pas l'instruction conn.commit(). Vous pouvez donc annuler toutes les
modifications apportées depuis le commit() précédent, en refermant la connexion à l'aide
de l'instruction : conn.close().

Prof : S. EL KASM 4