« Programmation Python/Gestion d'une base de données » : différence entre les versions
Contenu supprimé Contenu ajouté
Aucun résumé des modifications |
|||
Ligne 56 :
Vous devez ensuite créer une instance (un objet) de la classe gadfly :
<source lang=python>
import gadfly
baseDonn = gadfly.gadfly()
</
L'objet <code>baseDonn</code> ainsi créé est votre moteur de base de données local, lequel effectuera la plupart de ses opérations en mémoire vive. Ceci permet une exécution très rapide des requêtes.
Ligne 65 :
Pour créer la base de données proprement dite, il faut employer la méthode startup de cet objet :
<source lang=python>
baseDonn.startup("mydata","E:/Python/essais/gadfly")
</
Le premier paramètre transmis, <code>mydata</code>, est le nom choisi pour la base de données (vous pouvez évidemment choisir un autre nom !). Le second paramètre est le répertoire où l'on souhaite installer cette base de données. (Ce répertoire doit avoir été créé au préalable, et toute base de données de même nom qui préexisterait dans ce répertoire est écrasée sans avertissement).
Ligne 77 :
Afin de pouvoir transmettre vos requêtes SQL à l'objet <code>baseDonn</code> , vous devez cependant mettre en œuvre un ''curseur''. Il s'agit d'une sorte de tampon mémoire intermédiaire, destiné à mémoriser temporairement les données en cours de traitement, ainsi que les opérations que vous effectuez sur elles, avant leur transfert définitif dans de vrais fichiers. Cette technique permet donc d'annuler si nécessaire une ou plusieurs opérations qui se seraient révélées inadéquates (Vous pouvez en apprendre davantage sur ce concept en consultant l'un des nombreux manuels qui traitent du langage SQL). Veuillez à présent examiner le petit script ci-dessous, et noter que les requêtes SQL sont des chaînes de caractères, prises en charge par la méthode execute de l'objet ''curseur'' :
<source lang=python>
cur = baseDonn.cursor()
cur.execute("create table membres (age integer, nom varchar, taille float)")
Ligne 84 :
cur.execute("Insert Into Membres(Age, Nom, Taille) Values (18,'Forcas',1.69)")
baseDonn.commit()
</
La première des lignes ci-dessus crée l'objet curseur <code>cur</code>. Les chaînes de caractères comprises entre guillemets dans les 4 lignes suivantes contiennent des requêtes SQL très classiques. ''Notez bien que le langage SQL ne tient aucun compte de la casse des caractères'' : vous pouvez encoder vos requêtes SQL indifféremment en majuscules ou en minuscules (ce qui n'est pas le cas pour les instructions Python environnantes, bien entendu !)
Ligne 100 :
L'accès à une base de données existante ne nécessite que deux lignes de code :
<source lang=python>
import gadfly
baseDonn = gadfly.gadfly("mydata","E:/Python/essais/gadfly")
</
Ces deux lignes suffisent en effet pour transférer en mémoire vive les tables contenues dans les fichiers enregistrés sur disque. La base de données peut désormais être interrogée et modifiée :
<source lang=python>
cur = baseDonn.cursor()
cur.execute("select * from membres")
print cur.pp()
</
La première de ces trois lignes ouvre un curseur. La requête émise dans la seconde ligne demande la sélection d'un ensemble d'enregistrements, qui seront transférés de la base de données au curseur. Dans le cas présent, la sélection n'en n'est pas vraiment une : on y demande en effet d'extraire tous les enregistrements de la table membres (le symbole * est fréquemment utilisé en informatique avec la signification « tout » ou « tous »).
Ligne 119 :
Si vous préférez contrôler vous-même la mise en page des informations, il vous suffit d'utiliser à sa place la méthode <code>fetchall()</code>, laquelle renvoie une liste de tuples. Essayez par exemple :
<source lang=python>
for x in cur.fetchall():
print x, x[0], x[1], x[2]
</
Vous pouvez bien entendu ajouter des enregistrements supplémentaires :
<source lang=python>
cur.execute("Insert Into Membres(Age, Nom, Taille) Values (19,'Ricard',1.75)")
</
Pour modifier un ou plusieurs enregistrements, exécutez une requête du type :
<source lang=python>
cur.execute("update membres set nom ='Gerart' where nom='Ricard'")
</
Pour supprimer un ou plusieurs enregistrements, utilisez une requête telle que :
<source lang=python>
cur.execute("delete from membres where nom='Gerart'")
</
Si vous effectuez toutes ces opérations à la ligne de commande de Python, vous pouvez en observer le résultat à tout moment en effectuant un ''pretty print'' comme expliqué plus haut. Étant donné que toutes les modifications apportées au curseur se passent en mémoire vive, rien n'est enregistré définitivement tant que vous n'exécutez pas l'instruction <code>baseDonn.commit()</code>.
Ligne 146 :
Vous pouvez donc annuler toutes les modifications apportées depuis le commit() précédent, en refermant la connexion à l'aide de l'instruction :
<source lang=python>
baseDonn.close()
</
=== Recherches dans une base de données ===
Ligne 191 :
<li>
(Création de la base de données "musique") :
<source lang=python>
import gadfly
Ligne 234 :
connex.commit()
</
</li>
</ol>
Ligne 241 :
Commencez à remplir la table <code>compositeurs</code> avec les données qui suivent (... et profitez de cette occasion pour faire la preuve des compétences que vous maîtrisez déjà, en écrivant un petit script pour vous faciliter l'entrée des informations : une boucle s'impose !)
<source lang=python>
comp a_naiss a_mort
Ligne 252 :
Chopin 1810 1849
Bach 1685 1750
</
Dans la table
<source lang=python>
comp titre duree interpr
Ligne 272 :
Mozart Concerto piano N°22 35 S. Richter
Beethoven Concerto piano N°3 37 S. Richter
</
Ligne 345 :
Pour terminer ce chapitre, nous allons vous proposer dans les pages qui suivent un exemple de réalisation concrète. Il ne s'agira pas d'un véritable logiciel (le sujet exigerait qu'on lui consacre un ouvrage spécifique), mais plutôt d'une ébauche d'analyse, destinée à vous montrer comment vous pouvez « penser comme un programmeur » lorsque vous abordez un problème complexe.
Les techniques que nous allons mettre en
Notre objectif concret est d'arriver à réaliser rapidement un client rudimentaire, capable de dialoguer avec un « vrai » serveur de bases de données tel que MySQL. Nous voudrions que notre client reste un petit utilitaire très généraliste : qu'il soit capable de mettre en place une petite base de données comportant plusieurs tables, qu'il puisse servir à produire des enregistrements pour chacune d'elles, qu'il permette de tester le résultat de requêtes SQL basiques.
Ligne 409 :
<source lang=python>
class Glob:
"""Espace de noms pour les variables et fonctions <pseudo-globales>"""
Ligne 429 :
('duree', "i", "durée (en minutes)"),
('interpr', 30, "interprète principal")]}
</
Le dictionnaire d'application décrivant la structure de la base de données est contenu dans la variable <code>Glob.dicoT</code>.
Ligne 447 :
Les objets-interfaces que nous voulons construire seront similaires aux objets-fichiers que nous avons abondamment utilisés pour la gestion des fichiers au chapitre 9. Vous vous rappelez par exemple que nous ouvrons un fichier en créant un objet-fichier, à l'aide de la fonction-fabrique <code>open()</code>. D'une manière similaire, nous ouvrirons la communication avec la base de données en commençant par créer un objet-interface à l'aide de la classe <code>GestionBD()</code>, ce qui établira la connexion. Pour lire ou écrire dans un fichier ouvert, nous utilisons diverses méthodes de l'objet-fichier. D'une manière analogue, nous effectuerons nos opérations sur la base de données par l'intermédiaire des diverses méthodes de l'objet-interface.
<source lang="python" line>
</source>
Ligne 548 :
Dans une application véritable, ce formulaire trop simpliste devrait certainement être fortement remanié, et il prendrait vraisemblablement la forme d'une fenêtre spécialisée, dans laquelle les champs d'entrée et leurs libellés pourraient encore une fois être générés de manière automatique. Nous ne prétendons donc pas qu'il constitue un bon exemple, mais nous voulons simplement vous montrer comment vous pouvez automatiser sa construction dans une large mesure. Tâchez de réaliser vos propres formulaires en vous servant de principes semblables.
<source lang="python" line>
class Enregistreur:
"""classe pour gérer l'entrée d'enregistrements divers"""
def __init__(self, bd, table):
self.bd =bd
self.table =table
self.descriptif =Glob.dicoT[table] # descriptif des champs
def entrer(self):
"procédure d'entrée d'un enregistrement entier"
champs ="(" # ébauche de chaîne pour les noms de champs
valeurs ="(" # ébauche de chaîne pour les valeurs
# Demander successivement une valeur pour chaque champ :
for cha, type, nom in self.descriptif:
if type =="k": # on ne demandera pas le n° d'enregistrement
continue # à l'utilisateur (numérotation auto.)
champs = champs + cha + ","
val = raw_input("Entrez le champ %s :" % nom)
if type else:
champs = champs[:-1] + ")" # supprimer la dernière virgule,
▲ req ="INSERT INTO %s %s VALUES %s" % (self.table, champs, valeurs) #25
▲ self.bd.executerReq(req) #26
if ch.upper() == "O":
▲ ch =raw_input("Continuer (O/N) ? ") #28
return 0
else:
return 1
</source>
;Commentaires
Ligne 605 :
Le script qui suit est celui d'une petite application destinée à tester les classes décrites dans les pages qui précèdent. Libre à vous de la perfectionner, ou alors d'en écrire une autre tout à fait différente !
<source lang="python" line>
</
;Commentaires
|