Apprendre à programmer avec Python/Gestion d'une base de données

Un livre de Wikilivres.
Aller à : navigation, rechercher
Apprendre à programmer avec Python
  1. Avant-propos Une version complète existe 30 mars 2007 à 18:23 (CEST)
  2. Penser comme un programmeur Une version complète existe 30 mars 2007 à 18:23 (CEST)
  3. Premiers pas En cours de finition 3Tavernier 25 novembre 2007 à 04:49 (CET) (relire)
  4. Contrôle du flux d'instructions En cours de finition Tavernier 25 novembre 2007 à 04:49 (CET) (relire)
  5. Instructions répétitives En cours de finition Tavernier 25 novembre 2007 à 04:49 (CET) (relire)
  6. Principaux types de données En cours de finition Tavernier 25 novembre 2007 à 04:49 (CET) (relire)
  7. Fonctions prédéfinies En cours de finition Tavernier 25 novembre 2007 à 04:49 (CET) (relire)
  8. Fonctions originales En cours de finition 4 avril 2007 à 22:17 (CEST) (manque liens index et exercices)
  9. Utilisation de fenêtres et de graphismes En cours de finition 9 avril 2007 à 17:59 (CEST) (manque liens index et exercices)
  10. Les fichiers Une version complète existe 9 avril 2007 à 18:21 (CEST)
  11. Approfondir les structures de données En cours de finition 9 avril 2007 à 18:54 (CEST) (manque liens index et exercices)
  12. Classes, objets, attributs En cours de finition 27 mai 2007 à 00:00 (CEST) (manque liens index et exercices)
  13. Classes, méthodes, héritage En cours de finition 27 mai 2007 à 00:09 (CEST) (manque liens index et exercices)
  14. Classes et Interfaces graphiques En cours de finition 9 juin 2007 à 12:22 (CEST) (manque liens index et exercices)
  15. Et pour quelques widgets de plus ... En cours de finition Tavernier 23 novembre 2007 à 21:56 (CET) (manque liens index et exercices)
  16. Analyse de programmes concrets Fait à environ 50 % 16 mars 2007 à 20:37 (CET) (manque images)
  17. Gestion d'une base de données En cours de finition Tavernier 24 novembre 2007 à 18:11 (CET) (manque liens index et exercices)
  18. Applications web En cours de finition Tavernier 24 novembre 2007 à 18:11 (CET) (manque liens index et exercices)
  19. Communications à travers un réseau Fait à environ 50 % 24 mars 2007 à 00:47 (CET) (ajouter images)
  20. Annexes En cours de finition 24 mars 2007 à 01:25 (CET) (finaliser)
  21. Bibliographie
  22. Licence

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é. Lorsqu'il s'agit de bases de données relationnelles, il devient en outre tout à fait possible d'éviter l'« enfer des doublons ». Vous avez sûrement été déjà confrontés à ce problème :

Des données identiques ont été enregistrées dans plusieurs fichiers différents. Lorsque vous souhaitez modifier ou supprimer l'une de ces données, vous devez ouvrir et modifier tous les fichiers qui la contiennent ! Le risque d'erreur est très réel, qui conduit inévitablement à des incohérences, sans compter la perte de temps que cela représente.

Les bases de données constituent la solution à ce type de problème. Python vous permet d'en utiliser de nombreux systèmes, mais nous n'en examinerons que deux dans nos exemples : Gadfly et MySQL.

Les bases de données[modifier | modifier le wikicode]

Il existe de nombreux types de bases de données. On peut par exemple déjà considérer comme une base de données élémentaire, un fichier qui contient une liste de noms et d'adresses.

Si la liste n'est pas trop longue, et si l'on ne souhaite pas pouvoir y effectuer des recherches en fonction de critères complexes, il va de soi que l'on peut accéder à ce type de données en utilisant des instructions simples, telles celles que nous avons abordées dans Programmation Python/Bases de données.

La situation se complique cependant très vite si l'on souhaite pouvoir effectuer des sélections et des tris parmi les données, surtout si celles-ci deviennent très nombreuses. La difficulté augmente encore si les données sont répertoriées dans différents ensembles reliés par un certain nombre de relations hiérarchiques, et si plusieurs utilisateurs doivent pouvoir y accéder en parallèle.

Imaginez par exemple que la direction de votre école vous confie la charge de mettre au point un système de bulletins informatisé. En y réfléchissant quelque peu, vous vous rendrez compte rapidement que cela suppose la mise en œuvre de toute une série de tables différentes : une table des noms d'élèves (laquelle pourra bien entendu contenir aussi d'autres informations spécifiques à ces élèves : adresse, date de naissance, etc.) ; une table contenant la liste des cours (avec le nom du professeur titulaire, le nombre d'heures enseignées par semaine, etc.) ; une table mémorisant les travaux pris en compte pour l'évaluation (avec leur importance, leur date, leur contenu, etc.) ; une table décrivant la manière dont les élèves sont groupés par classes ou par options, les cours suivis par chacun, etc., etc.

Vous comprenez bien que ces différentes tables ne sont pas indépendantes. Les travaux effectués par un même élève sont liés à des cours différents. Pour établir le bulletin de cet élève, il faut donc extraire des données de la table des travaux, bien sûr, mais en relation avec des informations trouvées dans d'autres tables (celles des cours, des classes, des options, etc.)

Nous verrons plus loin comment représenter des tables de données et les relations qui les lient.

SGBDR - Le modèle client/serveur[modifier | modifier le wikicode]

Les programmes informatiques capables de gérer efficacement de tels ensembles de données complexes sont forcément complexes, eux aussi. On appelle ces programmes des SGBDR (Systèmes de Gestion de Bases de Données Relationnelles). Il s'agit d'applications informatiques de première importance pour les entreprises. Certaines sont les fleurons de sociétés spécialisées (IBM, Oracle, Microsoft, Informix, Sybase...) et sont en général vendues à des prix fort élevés. D'autres ont été développées dans des centres de recherche et d'enseignement universitaires (PostgreSQL, MySQL…); elles sont alors en général tout à fait gratuites.

Ces systèmes ont chacun leurs spécificités et leurs performances, mais la plupart fonctionnant sur le modèle client/serveur : cela signifie que la plus grosse partie de l'application (ainsi que la base de données prise en charge) est installée en un seul endroit, en principe sur une machine puissante (cet ensemble constituant donc le serveur), alors que l'autre partie, beaucoup plus simple, est installée sur un nombre indéterminé de postes de travail, et on appelle celles-ci des clients.

Les clients sont reliés au serveur, en permanence ou non, par divers procédés et protocoles (éventuellement par l'intermédiaire de l'internet). Chacun d'entre eux peut accéder à une partie plus ou moins importante des données, avec autorisation ou non de modifier certaines d'entre elles, d'en ajouter ou d'en supprimer, en fonction de règles d'accès bien déterminées. (Ces règles sont définies par un administrateur de la base de données).

Le serveur et ses clients sont en fait des applications distinctes qui s'échangent des informations. Imaginez par exemple que vous êtes l'un des utilisateurs du système. Pour accéder aux données, vous devez lancer l'exécution d'une application cliente sur un poste de travail quelconque. Dans son processus de démarrage, l'application cliente commence par établir la connexion avec le serveur et la base de données[1]. Lorsque la connexion est établie, l'application cliente peut interroger le serveur en lui envoyant une requête sous une forme convenue. Il s'agit par exemple de retrouver une information précise. Le serveur exécute alors la requête en recherchant les données correspondantes dans la base, puis il expédie en retour une certaine réponse au client.

Cette réponse peut être l'information demandée, ou encore un message d'erreur en cas d'insuccès.

La communication entre le client et le serveur est donc faite de requêtes et de réponses. Les requêtes sont de véritables instructions expédiées du client au serveur, non seulement pour extraire des données de la base, mais aussi pour en ajouter, en supprimer, en modifier, etc.

Le langage SQL - Gadfly[modifier | modifier le wikicode]

Étant donnée la diversité des SGBDR existants, on pourrait craindre que chacun d'eux nécessite l'utilisation d'un langage particulier pour les requêtes qu'on lui adresse. En fait, de grands efforts ont été accomplis un peu partout pour la mise au point d'un langage commun, et il existe à présent un standard bien établi : SQL (Structured Query Language, ou langage de requêtes structuré)[2].

Vous aurez probablement l'occasion de rencontrer SQL dans d'autres domaines (bureautique, par exemple). Dans le cadre de cette introduction à l'apprentissage de la programmation avec Python, nous allons nous limiter à la présentation de deux exemples : la mise en oeuvre d'un petit SGBDR réalisé exclusivement à l'aide de Python, et l'ébauche d'un logiciel client plus ambitieux destiné à communiquer avec un serveur de bases de données MySQL.

Notre première réalisation utilisera un module nommé Gadfly. Entièrement écrit en Python, ce module ne fait pas partie de la distribution standard et doit donc être installé séparément. Il intègre un large sous-ensemble de commandes SQL. Ses performances ne sont évidemment pas comparables à celles d'un gros SGBDR spécialisé[3], mais elles sont tout à fait excellentes pour la gestion de bases de données modestes. Absolument portable comme Python lui-même, Gadfly fonctionnera indifféremment sous Windows , Linux ou MacOS. De même, les répertoires contenant des bases de données produites sous Gadfly pourront être utilisées sans modification depuis l'un ou l'autre de ces systèmes.

Si vous souhaitez développer une application qui doit gérer des relations relativement complexes dans une petite base de données, le module Gadfly peut vous faciliter grandement la tâche.

Mise en œuvre d'une base de données simple avec Gadfly[modifier | modifier le wikicode]

Nous allons ci-après examiner comment mettre en place une application simple, qui fasse office à la fois de serveur et de client sur la même machine.

Création de la base de données[modifier | modifier le wikicode]

Comme vous vous y attendez certainement, il suffit d'importer le module gadfly pour accéder aux fonctionnalités correspondantes.[4]

Vous devez ensuite créer une instance (un objet) de la classe gadfly :

import gadfly
baseDonn = gadfly.gadfly()

L'objet baseDonn 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.

Pour créer la base de données proprement dite, il faut employer la méthode startup de cet objet :

baseDonn.startup("mydata","E:/Python/essais/gadfly")

Le premier paramètre transmis, mydata, 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).

Les trois lignes de code que vous venez d'entrer sont suffisantes : vous disposez dès à présent d'une base de données fonctionnelle, dans laquelle vous pouvez créer différentes tables, puis ajouter, supprimer ou modifier des données dans ces tables.

Pour toutes ces opérations, vous allez utiliser le langage SQL.

Afin de pouvoir transmettre vos requêtes SQL à l'objet baseDonn , 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 :

cur = baseDonn.cursor()
cur.execute("create table membres (age integer, nom varchar, taille float)")
cur.execute("insert into membres(age, nom, taille) values (21,'Dupont',1.83)")
cur.execute("INSERT INTO MEMBRES(AGE, NOM, TAILLE) VALUES (15,'Suleau',1.57)")
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 cur. 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 !)

La seconde ligne crée une table nommée membres, laquelle contiendra des enregistrements de 3 champs : le champ age de type « nombre entier », le champ nom de type « chaîne de caractères » (de longueur variable[5]) et le champ taille, de type « nombre réel » (à virgule flottante). Le langage SQL autorise en principe d'autres types, mais ils ne sont pas implémentés dans Gadfly.

Les trois lignes qui suivent sont similaires. Nous y avons mélangé majuscules et minuscules pour bien montrer que la casse n'est pas significative en SQL. Ces lignes servent à insérer trois enregistrements dans la table membres.

À ce stade des opérations, les enregistrement n'ont pas encore été transférés dans de véritables fichiers sur disque. Il est donc possible de revenir en arrière, comme nous le verrons un peu plus loin. Le transfert sur disque est activé par la méthode commit() de la dernière ligne d'instructions.

Connexion à une base de données existante[modifier | modifier le wikicode]

Supposons qu'à la suite des opérations ci-dessus, nous décidions de terminer le script, ou même d'éteindre l'ordinateur. Comment devrons-nous procéder par la suite pour accéder à nouveau à notre base de données ?

L'accès à une base de données existante ne nécessite que deux lignes de code :

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 :

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 »).

La méthode pp() utilisée sur le curseur, dans la troisième ligne, provoque un affichage de tout ce qui est contenu dans le curseur sous une forme pré-formatée (les données présentes sont automatiquement disposées en colonnes). « pp » doit en effet être compris comme « pretty print ».

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 fetchall(), laquelle renvoie une liste de tuples. Essayez par exemple :

for x in cur.fetchall():
    print x, x[0], x[1], x[2]

Vous pouvez bien entendu ajouter des enregistrements supplémentaires :

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 :

cur.execute("update membres set nom ='Gerart' where nom='Ricard'")

Pour supprimer un ou plusieurs enregistrements, utilisez une requête telle que :

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 baseDonn.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 :

baseDonn.close()

Recherches dans une base de données[modifier | modifier le wikicode]

Exercices

  1. Avant d'aller plus loin, et à titre d'exercice de synthèse, nous allons vous demander de créer entièrement vous-même une base de données Musique qui contiendra les deux tables suivantes (Cela représente un certain travail, mais il faut que vous puissiez disposer d'un certain nombre de données pour pouvoir expérimenter les fonctions de recherche et de tri) :
    oeuvres
    comp (chaîne)
    titre (chaîne)
    duree (entier)
    interpr (chaîne)
    compositeurs
    comp (chaîne)
    a_naiss (entier)
    a_mort (entier)

Solution

  1. (Création de la base de données "musique") :
    import gadfly
    
    connex = gadfly.gadfly()
    connex.startup("musique","E:/Python/essais/gadfly")
    cur = connex.cursor()
    requete = "create table compositeurs (comp varchar, a_naiss integer,\
               a_mort integer)" 
    cur.execute(requete)
    requete = "create table oeuvres (comp varchar, titre varchar,\
               duree integer, interpr varchar)" 
    cur.execute(requete)
    
    print "Entrée des enregistrements, table des compositeurs :"
    while 1:
        nm = raw_input("Nom du compositeur (<Enter> pour terminer) : ")
        if nm =='':
            break
        an = raw_input("Année de naissance : ")
        am = raw_input("Année de mort : ")
        requete ="insert into compositeurs(comp, a_naiss, a_mort) values \
                     ('%s', %s, %s)" % (nm, an, am)
        cur.execute(requete)
    # Affichage des données entrées, pour vérification :
    cur.execute("select * from compositeurs")
    print cur.pp()
    
    print "Entrée des enregistrements, table des oeuvres musicales :"
    while 1:
        nom = raw_input("Nom du compositeur (<Enter> pour terminer) : ")
        if nom =='':
            break
        tit = raw_input("Titre de l'oeuvre : ")
        dur = raw_input("durée (minutes) : ")
        int = raw_input("interprète principal : ")
        requete ="insert into oeuvres(comp, titre, duree, interpr) values \
                     ('%s', '%s', %s, '%s')" % (nom, tit, dur, int)
        cur.execute(requete)
    # Affichage des données entrées, pour vérification :
    cur.execute("select * from oeuvres")
    print cur.pp()
    
    connex.commit()
    

Commencez à remplir la table compositeurs 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 !)

comp            a_naiss  a_mort

Mozart          1756     1791
Beethoven       1770     1827
Handel          1685     1759
Schubert        1797     1828
Vivaldi         1678     1741
Monteverdi      1567     1643
Chopin          1810     1849           
Bach            1685     1750

Dans la table oeuvres, entrez les données suivantes :

comp            titre                           duree       interpr

Vivaldi         Les quatre saisons              20          T. Pinnock
Mozart          Concerto piano N°12             25          M. Perahia
Brahms          Concerto violon N°2             40          A. Grumiaux 
Beethoven       Sonate "au clair de lune"       14          W. Kempf
Beethoven       Sonate "pathétique"             17          W. Kempf
Schubert        Quintette "la truite"           39          SE of London
Haydn           La création                     109         H. Von Karajan
Chopin          Concerto piano N°1              42          M.J. Pires
Bach            Toccata & fugue                 9           P. Burmester
Beethoven       Concerto piano N°4              33          M. Pollini
Mozart          Symphonie N°40                  29          F. Bruggen
Mozart          Concerto piano N°22             35          S. Richter
Beethoven       Concerto piano N°3              37          S. Richter


Les champs a_naiss et a_mort contiennent respectivement l'année de naissance et l'année de la mort des compositeurs. La durée des œuvres est fournie en minutes. Vous pouvez évidemment ajouter autant d'enregistrements d'œuvres et de compositeurs que vous le voulez, mais ceux qui précèdent devraient suffire pour la suite de la démonstration.

Pour ce qui va suivre, nous supposerons donc que vous avez effectivement encodé les données des deux tables décrites ci-dessus. (Si vous éprouvez des difficultés à écrire le script nécessaire, nous en donnons un exemplevoir la solution de l'exercice précédent).

Le petit script ci-dessous est fourni à titre purement indicatif. Il s'agit d'un client SQL rudimentaire, qui vous permet de vous connecter à la base de données « musique » qui devrait à présent exister dans l'un de vos répertoires, d'y ouvrir un curseur et d'utiliser celui-ci pour effectuer des requêtes. Notez encore une fois que rien n'est transcrit sur le disque tant que la méthode commit() n'a pas été invoquée.

# Utilisation d'une petite base de données acceptant les requêtes SQL

import gadfly

baseDonn = gadfly.gadfly("musique","E:/Python/essais/gadfly")
cur = baseDonn.cursor()
while 1:
    print "Veuillez entrer votre requête SQL (ou <Enter> pour terminer) :"
    requete = raw_input()
    if requete =="":
        break
    try:
        cur.execute(requete)        # tentative d'exécution de la requête SQL
    except:
        print '*** Requête incorrecte ***'
    else:    
        print cur.pp()              # affichage du résultat de la requête
    print

choix = raw_input("Confirmez-vous l'enregistrement (o/n) ? ")
if choix[0] == "o" or choix[0] == "O":
    baseDonn.commit()
else:
    baseDonn.close()

Cette application très simple n'est évidemment qu'un exemple. Il faudrait y ajouter la possibilité de choisir la base de données ainsi que le répertoire de travail. Pour éviter que le script ne se « plante » lorsque l'utilisateur encode une requête incorrecte, nous avons utilisé ici le traitement des exceptions déjà décrit à la page

Nuvola apps korganizer.svg
À faire...


.

La requête select[modifier | modifier le wikicode]

L'une des instructions les plus puissantes du langage SQL est l'instruction select, dont nous allons à présent explorer quelques fonctionnalités. Rappelons encore une fois que nous n'abordons ici qu'une très petite partie du sujet : la description détaillée de SQL peut occuper plusieurs livres.

Lancez donc le script ci-dessus, et analysez attentivement ce qui se passe lorsque vous proposez les requêtes suivantes :

SELECT *  FROM oeuvres
SELECT *  FROM oeuvres WHERE comp = 'Mozart'
SELECT comp, titre, duree  FROM oeuvres ORDER BY comp
SELECT titre, comp FROM oeuvres WHERE comp='Beethoven' OR comp='Mozart' ORDER BY comp
SELECT COUNT(*) FROM oeuvres 
SELECT SUM(duree) FROM oeuvres
SELECT avg(duree) FROM oeuvres
SELECT SUM(duree) FROM oeuvres WHERE comp='Beethoven'
SELECT * FROM oeuvres WHERE duree >35 ORDER BY duree DESC

Pour chacune de ces requêtes, tâchez d'exprimer le mieux possible ce qui se passe. Fondamentalement, vous activez sur la base de données des filtres de sélection et des tris. Les requêtes suivantes sont plus élaborées, car elles concernent les deux tables à la fois.

SELECT o.titre, c.nom, c.a_naiss FROM oeuvres o, compositeurs c WHERE o.comp = c.comp
SELECT comp FROM oeuvres INTERSECT SELECT comp FROM compositeurs
SELECT comp FROM oeuvres EXCEPT SELECT comp FROM compositeurs
SELECT comp FROM compositeurs EXCEPT SELECT comp FROM oeuvres
SELECT DISTINCT comp FROM oeuvres UNION SELECT comp FROM compositeurs

Il ne nous est pas possible de développer davantage le langage de requêtes dans le cadre restreint de ces notes. Nous allons cependant examiner encore un exemple de réalisation Python faisant appel à un système de bases de données, mais en supposant cette fois qu'il s'agisse de dialoguer avec un système serveur indépendant (lequel pourrait être par exemple un gros serveur de bases de données d'entreprise, un serveur de documentation dans une école, etc.).

Ébauche d'un logiciel client pour MySQL[modifier | modifier le wikicode]

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 oeuvre ici sont de simples suggestions, dans lesquelles nous essayerons d'utiliser au mieux les outils que vous avez découverts au cours de votre apprentissage dans les chapitres précédents, à savoir : les structures de données de haut niveau (listes et dictionnaires), et la programmation par objets. Il va de soi que les options retenues dans cet exercice restent largement critiquables : vous pouvez bien évidemment traiter les mêmes problèmes en utilisant des approches différentes.

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.

Dans les lignes qui suivent, nous supposerons que vous avez déjà accès à un serveur MySQL, sur lequel une base de données « discotheque » aura été créée pour l'utilisateur « jules », lequel s'identifie à l'aide du mot de passe « abcde ». Ce serveur peut être situé sur une machine distante accessible via un réseau, ou localement sur votre ordinateur personnel.

L'installation et la configuration d'un serveur MySQL sortent du cadre de cet ouvrage, mais ce n'est pas une tâche bien compliquée. C'est même fort simple si vous travaillez sous Linux, installé depuis une distribution « classique » telle que Debian, RedHat, SuSE ou Mandrake. Il vous suffit d'installer les paquetages MySQL-server et Python-MySQL, de démarrer le service MySQL, puis d'entrer les commandes :

mysqladmin  -u  root  password  xxxx

Cette première commande définit le mot de passe de l'administrateur principal de MySQL. Elle doit être exécutée par l'administrateur du système Linux (root), avec un mot de passe de votre choix. On se connecte ensuite au serveur sous le compte administrateur ainsi défini (le mot de passe sera demandé) :

mysql  -u  root  mysql  -p
grant  all  privileges  on  *.*  to jules@localhost  identified  by  'abcde';
grant  all  privileges  on  *.*  to jules@"%"  identified  by  'abcde';
\q

Ces commandes définissent un nouvel utilisateur « jules » pour le système MySQL, et cet utilisateur devra se connecter le mot de passe « abcde » (Les deux lignes autorisent respectivement l'accès local et l'accès via réseau).

Le nom d'utilisateur est quelconque : il ne doit pas nécessairement correspondre à un utilisateur système.

L'utilisateur « jules » peut à présent se connecter et créer des bases de données :

mysql  -u  jules  -p
create database discotheque;
\q

... etc.

À ce stade, le serveur MySQL est prêt à dialoguer avec le client Python décrit dans ces pages.

Décrire la base de données dans un dictionnaire d'application[modifier | modifier le wikicode]

Une application dialoguant avec une base de données est presque toujours une application complexe. Elle comporte donc de nombreuses lignes de code, qu'il s'agit de structurer le mieux possible en les regroupant dans des classes (ou au moins des fonctions) bien encapsulées.

En de nombreux endroits du code, souvent fort éloignés les uns des autres, des blocs d'instructions doivent prendre en compte la structure de la base de données, c'est-à-dire son découpage en un certain nombre de tables et de champs, ainsi que les relations qui établissent une hiérarchie dans les enregistrements.

Or, l'expérience montre que la structure d'une base de données est rarement définitive. Au cours d'un développement, on réalise souvent qu'il est nécessaire de lui ajouter ou de lui retirer des champs, parfois même de remplacer une table mal conçue par deux autres, etc. Il n'est donc pas prudent de programmer des portions de code trop spécifiques d'une structure particulière, « en dur ».

Au contraire, il est hautement recommandable de décrire plutôt la structure complète de la base de données en un seul endroit du programme, et d'utiliser ensuite cette description comme référence pour la génération semi-automatique des instructions particulières concernant telle table ou tel champ. On évite ainsi, dans une large mesure, le cauchemar de devoir traquer et modifier un grand nombre d'instructions un peu partout dans le code, chaque fois que la structure de la base de données change un tant soit peu. Au lieu de cela, il suffit de changer seulement la description de référence, et la plus grosse partie du code reste correcte sans nécessiter de modification.

 Nous tenons là une idée maîtresse pour réaliser des applications robustes : un logiciel destiné au traitement de données devrait toujours être construit sur la base d'un dictionnaire d'application.

Ce que nous entendons ici par « dictionnaire d'application » ne doit pas nécessairement revêtir la forme d'un dictionnaire Python. N'importe quelle structure de données peut convenir, l'essentiel étant de se construire une référence centrale décrivant les données que l'on se propose de manipuler, avec peut-être aussi un certain nombre d'informations concernant leur mise en forme.

Du fait de leur capacité à rassembler en une même entité des données de n'importe quel type, les listes, tuples et dictionnaires de Python conviennent parfaitement pour ce travail. Dans l'exemple des pages suivantes, nous avons utilisé nous-mêmes un dictionnaire, dont les valeurs sont des listes de tuples, mais vous pourriez tout aussi bien opter pour une organisation différente des mêmes informations.

Tout cela étant bien établi, il nous reste encore à régler une question d'importance : où allons-nous installer concrètement ce dictionnaire d'application ?

Ses informations devront pouvoir être consultées depuis n'importe quel endroit du programme. Il semble donc obligatoire de l'installer dans une variable globale, de même d'ailleurs que d'autres données nécessaires au fonctionnement de l'ensemble de notre logiciel. Or vous savez que l'utilisation de variables globales n'est pas recommandée : elle comporte des risques, qui augmentent avec la taille du programme. De toute façon, les variables dites globales ne sont en fait globales qu'à l'intérieur d'un même module. Si nous souhaitons organiser notre logiciel comme un ensemble de modules (ce qui constitue par ailleurs une excellente pratique), nous n'aurons accès à nos variables globales que dans un seul d'entre eux.

Pour résoudre ce petit problème, il existe cependant une solution simple et élégante : regrouper dans une classe particulière toutes les variables qui nécessitent un statut global pour l'ensemble de l'application. Ainsi encapsulées dans l'espace de noms d'une classe, ces variables peuvent être utilisées sans problème dans n'importe quel module : il suffit en effet que celui-ci importe la classe en question. De plus, l'utilisation de cette technique entraîne une conséquence intéressante : le caractère « global » des variables définies de cette manière apparaît très clairement dans leur nom qualifié, puisque ce nom commence par celui de la classe contenante.

Si vous choisissez, par exemple, un nom explicite tel que Glob pour la classe destinée à accueillir vos variables « globales », vous vous assurez de devoir faire référence à ces variables partout dans votre code avec des noms tout aussi explicites tels que Glob.ceci , Glob.cela , etc[6].

C'est cette technique que vous allez découvrir à présent dans les premières lignes de notre script. Nous y définissons effectivement une classe Glob(), qui n'est donc rien d'autre qu'un simple conteneur. Aucun objet ne sera instancié à partir de celle classe, laquelle ne comporte d'ailleurs aucune méthode. Nos variables « globales » y sont définies comme de simples variables de classe, et nous pourrons donc y faire référence dans tout le reste du programme en tant qu'attributs de Glob. Le nom de la base de données, par exemple, pourra être retrouvé partout dans la variable Glob.dbName ; le nom ou l'adresse IP du serveur dans la variable Glob.host, etc. :


class Glob:
    """Espace de noms pour les variables et fonctions <pseudo-globales>"""

    dbName = "discotheque"      # nom de la base de données
    user = "jules"              # propriétaire ou utilisateur
    passwd = "abcde"            # mot de passe d'accès
    host = "192.168.0.235"      # nom ou adresse IP du serveur

    # Structure de la base de données.  Dictionnaire des tables & champs :
    dicoT ={"compositeurs":[('id_comp', "k", "clé primaire"),
                            ('nom', 25, "nom"),
                            ('prenom', 25, "prénom"),
                            ('a_naiss', "i", "année de naissance"),
                            ('a_mort', "i", "année de mort")],
            "oeuvres":[('id_oeuv', "k", "clé primaire"),
                       ('id_comp', "i", "clé compositeur"),
                       ('titre', 50, "titre de l'oeuvre"),
                       ('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 Glob.dicoT.

Il s'agit d'un dictionnaire Python, dont les clés sont les noms des tables. Quant aux valeurs, chacune d'elles est une liste contenant la description de tous les champs de la table, sous la forme d'autant de tuples.

Chaque tuple décrit donc un champ particulier de la table. Pour ne pas encombrer notre exercice, nous avons limité cette description à trois informations seulement : le nom du champ, son type et un bref commentaire. Dans une véritable application, il serait judicieux d'ajouter encore d'autres informations ici, concernant par exemple des valeurs limites éventuelles pour les données de ce champ, le formatage à leur appliquer lorsqu'il s'agit de les afficher à l'écran ou de les imprimer, le texte qu'il faut placer en haut de colonne lorsque l'on veut les présenter dans un tableau, etc.

Il peut vous paraître assez fastidieux de décrire ainsi très en détail la structure de vos données, alors que vous voudriez probablement commencer tout de suite une réflexion sur les divers algorithmes à mettre en oeuvre afin de les traiter. Sachez cependant que si elle est bien faite, une telle description structurée vous fera certainement gagner beaucoup de temps par la suite, parce qu'elle vous permettra d'automatiser pas mal de choses. Vous en verrez une démonstration un peu plus loin. En outre, vous devez vous convaincre que cette tâche un peu ingrate vous prépare à bien structurer aussi le reste de votre travail : organisation des formulaires, tests à effectuer, etc.

Définir une classe d'objets-interfaces[modifier | modifier le wikicode]

La classe Glob() décrite à la rubrique précédente sera donc installée en début de script, ou bien dans un module séparé importé en début de script. Pour la suite de l'exposé, nous supposerons que c'est cette dernière formule qui est retenue : nous avons sauvegardé la classe Glob() dans un module nommé dict_app.py, d'où nous pouvons à présent l'importer dans le script suivant.

Ce nouveau script définit une classe d'objets-interfaces. Nous voulons en effet essayer de mettre à profit ce que nous avons appris dans les chapitres précédents, et donc privilégier la programmation par objets, afin de créer des portions de code bien encapsulées et largement réutilisables.

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 open(). 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 GestionBD(), 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.

1.import MySQLdb, sys
2.from dict_app import *
3.
4.class GestionBD:
5.    """Mise en place et interfaçage d'une base de données MySQL"""
6.    def __init__(self, dbName, user, passwd, host, port =3306):
7.        "Établissement de la connexion - Création du curseur"
8.        try:
9.            self.baseDonn = MySQLdb.connect(db =dbName,
10.                  user =user, passwd =passwd, host =host, port =port)
11.        except Exception, err:
12.            print 'La connexion avec la base de données a échoué :\n'\
13.                  'Erreur détectée :\n%s' % err
14.            self.echec =1
15.        else:    
16.            self.cursor = self.baseDonn.cursor()   # création du curseur
17.            self.echec =0
18.
19.    def creerTables(self, dicTables):
20.        "Création des tables décrites dans le dictionnaire <dicTables>."
21.        for table in dicTables:            # parcours des clés du dict.
22.            req = "CREATE TABLE %s (" % table
23.            pk =''
24.            for descr in dicTables[table]:
25.                nomChamp = descr[0]        # libellé du champ à créer
26.                tch = descr[1]             # type de champ à créer
27.                if tch =='i':
28.                    typeChamp ='INTEGER'
29.                elif tch =='k':
30.                    # champ 'clé primaire' (incrémenté automatiquement)
31.                    typeChamp ='INTEGER AUTO_INCREMENT'   
32.                    pk = nomChamp
33.                else:
34.                    typeChamp ='VARCHAR(%s)' % tch                
35.                req = req + "%s %s, " % (nomChamp, typeChamp)
36.            if pk == '':
37.                req = req[:-2] + ")"
38.            else:
39.                req = req + "CONSTRAINT %s_pk PRIMARY KEY(%s))" % (pk, pk)
40.            self.executerReq(req)
41.
42.    def supprimerTables(self, dicTables):
43.        "Suppression de toutes les tables décrites dans <dicTables>"
44.        for table in dicTables.keys():
45.            req ="DROP TABLE %s" % table
46.            self.executerReq(req) 
47.        self.commit()                       # transfert -> disque
48.
49.    def executerReq(self, req):
50.        "Exécution de la requête <req>, avec détection d'erreur éventuelle"
51.        try:
52.            self.cursor.execute(req)
53.        except Exception, err:
54.            # afficher la requête et le message d'erreur système :
55.            print "Requête SQL incorrecte :\n%s\nErreur détectée :\n%s"\
56.                   % (req, err)
57.            return 0
58.        else:
59.            return 1
60.
61.    def resultatReq(self):
62.        "renvoie le résultat de la requête précédente (un tuple de tuples)"
63.        return self.cursor.fetchall()
64.
65.    def commit(self):
66.        if self.baseDonn:
67.            self.baseDonn.commit()         # transfert curseur -> disque        
68.
69.    def close(self):
70.        if self.baseDonn:
71.            self.baseDonn.close()
Commentaires
  • Lignes 1-2 : Outre notre propre module dict_app qui contient les variables « globales », nous importons le module sys qui contient quelques fonctions système, et le module MySQLdb qui contient tout ce qui est nécessaire pour communiquer avec MySQL. Rappelons que ce module ne fait pas partie de la distribution standard de Python, et qu'il doit donc être installé séparément.
  • Ligne 5 : Lors de la création des objets-interfaces, nous devrons fournir les paramètres de la connexion : nom de la base de données, nom de son utilisateur, nom ou adresse IP de la machine où est situé le serveur. Le nunméro du port de communication est habituellement celui que nous avons prévu par défaut. Toutes ces informations sont supposées être en votre possession.
  • Lignes 8 à 17 : Il est hautement recommandable de placer le code servant à établir la connexion à l'intérieur d'un gestionnaire d'exceptions try-except-else, car nous ne pouvons pas présumer que le serveur sera nécessairement accessible. Remarquons au passage que la méthode __init__() ne peut pas renvoyer de valeur (à l'aide de l'instruction return), du fait qu'elle est invoquée automatiquement par Python lors de l'instanciation d'un objet. En effet : ce qui est renvoyé dans ce cas au programme appelant est l'objet nouvellement construit. Nous ne pouvons donc pas signaler la réussite ou l'échec de la connexion au programme appelant à l'aide d'une valeur de retour. Une solution simple à ce petit problème consiste à mémoriser le résultat de la tentative de connexion dans un attribut d'instance (variable self.echec), que le programme appelant peut ensuite tester quand bon lui semble.
Nuvola apps korganizer.svg
À faire...

Ajouter un exemple

  • Lignes 19 à 40 : Cette méthode automatise la création de toutes les tables de la base de données, en tirant profit de la description du dictionnaire d'application, lequel doit lui être transmis en argument. Une telle automatisation sera évidemment d'autant plus appréciable, que la structure de la base de données sera plus complexe (Imaginez par exemple une base de données contenant 35 tables !). Afin de ne pas alourdir la démonstration, nous avons restreint les capacités de cette méthode à la création de champs des types integer et varchar. Libre à vous d'ajouter les instructions nécessaires pour créer des champs d'autres types. Si vous détaillez le code, vous constaterez qu'il consiste simplement à construire une requête SQL pour chaque table, morceau par morceau, dans la chaîne de caractères req. Celle-ci est ensuite transmise à la méthode executerReq() pour exécution. Si vous souhaitez visualiser la requête ainsi construite, vous pouvez évidemment ajouter une instruction print req juste après la ligne 40. Vous pouvez également ajouter à cette méthode la capacité de mettre en place les contraintes d'intégrité référentielle, sur la base d'un complément au dictionnaire d'application qui décrirait ces contraintes. Nous ne développons pas cette question ici, mais cela ne devrait pas vous poser de problème si vous savez de quoi il retourne.
  • Lignes 42 à 47 : Beaucoup plus simple que la précédente, cette méthode utilise le même principe pour supprimer toutes les tables décrites dans le dictionnaire d'application.
  • Lignes 49 à 59 : Cette méthode transmet simplement la requête à l'objet curseur. Son utilité est de simplifier l'accès à celui-ci et de produire un message d'erreur si nécessaire.
  • Lignes 61 à 71 : Ces méthodes ne sont que de simples relais vers les objets produits par le module MySQLdb : l'objet-connecteur produit par la fonction-fabrique MySQLdb.connect(), et l'objet curseur correspondant. Elles permettent de simplifier légèrement le code du programme appelant.

Construire un générateur de formulaires[modifier | modifier le wikicode]

Nous avons ajouté cette classe à notre exercice pour vous expliquer comment vous pouvez utiliser le même dictionnaire d'application afin d'élaborer du code généraliste. L'idée développée ici est de réaliser une classe d'objets-formulaires capables de prendre en charge l'encodage des enregistrements de n'importe quelle table, en construisant automatiquement les instructions d'entrée adéquates grâce aux informations tirées du dictionnaire d'application.

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.

class Enregistreur:                                                        #1
    """classe pour gérer l'entrée d'enregistrements divers"""              #2
    def __init__(self, bd, table):                                         #3
        self.bd =bd                                                        #4
        self.table =table                                                  #5
        self.descriptif =Glob.dicoT[table]   # descriptif des champs       #6
                                                                           #7
    def entrer(self):                                                      #8
        "procédure d'entrée d'un enregistrement entier"                    #9
        champs ="("           # ébauche de chaîne pour les noms de champs  #10
        valeurs ="("          # ébauche de chaîne pour les valeurs         #11
        # Demander successivement une valeur pour chaque champ :           #12
        for cha, type, nom in self.descriptif:                             #13
            if type =="k":    # on ne demandera pas le n° d'enregistrement #14
                continue      # à l'utilisateur (numérotation auto.)       #15
            champs = champs + cha + ","                                    #16
            val = raw_input("Entrez le champ %s :" % nom)                  #17
            if type =="i":                                                 #18
                valeurs = valeurs + val +","                               #19
            else:                                                          #20
                valeurs = valeurs + "'%s'," % (val)                        #21
                                                                           #22
        champs = champs[:-1] + ")"    # supprimer la dernière virgule,     #23
        valeurs = valeurs[:-1] + ")"  # ajouter une parenthèse             #24
        req ="INSERT INTO %s %s VALUES %s" % (self.table, champs, valeurs) #25
        self.bd.executerReq(req)                                           #26
                                                                           #27
        ch =raw_input("Continuer (O/N) ? ")                                #28
        if ch.upper() == "O":                                              #29
            return 0                                                       #30
        else:                                                              #31
            return 1                                                       #32
Commentaires
  • Lignes 1 à 6 : Au moment de leur instanciation, les objets de cette classe reçoivent la référence de l'une des tables du dictionnaire. C'est ce qui leur donne accès au descriptif des champs.
  • Ligne 8 : Cette méthode entrer() génère le formulaire proprement dit. Elle prend en charge l'entrée des enregistrements dans la table, en s'adaptant à leur structure propre grâce au descriptif trouvé dans le dictionnaire. Sa fonctionnalité concrète consiste encore une fois à construire morceau par morceau une chaîne de caractères qui deviendra une requête SQL, comme dans la méthode creerTables() de la classe GestionBD() décrite à la rubrique précédente. Vous pourriez bien entendu ajouter à la présente classe encore d'autres méthodes, pour gérer par exemple la suppression et/ou la modification d'enregistrements.
  • Lignes 12 à 21 : L'attribut d'instance self.descriptif contient une liste de tuples, et chacun de ceux-ci est fait de trois éléments, à savoir le nom d'un champ, le type de données qu'il est censé recevoir, et sa description « en clair ». La boucle for de la ligne 13 parcourt cette liste et affiche pour chaque champ un message d'invite construit sur la base de la description qui accompagne ce champ. Lorsque l'utilisateur a entré la valeur demandée, celle-ci et formatée dans une chaîne en construction. Le formatage s'adapte aux conventions du langage SQL, conformément au type requis pour le champ.
  • Lignes 23 à 26 : Lorsque tous les champs ont été parcourus, la requête proprement dite est assemblée et exécutée. Si vous souhaitez visualiser cette requête, vous pouvez bien évidemment ajouter une instruction print req juste après la ligne 25.

Le corps de l'application[modifier | modifier le wikicode]

Il ne nous paraît pas utile de développer davantage encore cet exercice dans le cadre d'un manuel d'initiation. Si le sujet vous intéresse, vous devriez maintenant en savoir assez pour commencer déjà quelques expériences personnelles. Veuillez alors consulter les bons ouvrages de référence, comme par exemple Python : How to program de Deitel & coll., ou encore les sites web consacrés aux extensions de Python.

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 !

1.###### Programme principal : #########
2.
3.# Création de l'objet-interface avec la base de données : 
4.bd = GestionBD(Glob.dbName, Glob.user, Glob.passwd, Glob.host)
5.if bd.echec:
6.    sys.exit()
7.    
8.while 1:
9.    print "\nQue voulez-vous faire :\n"\
10.          "1) Créer les tables de la base de données\n"\
11.          "2) Supprimer les tables de la base de données ?\n"\
12.          "3) Entrer des compositeurs\n"\
13.          "4) Entrer des oeuvres\n"\
14.          "5) Lister les compositeurs\n"\
15.          "6) Lister les oeuvres\n"\
16.          "7) Exécuter une requête SQL quelconque\n"\
17.          "9) terminer ?                         Votre choix :",
18.    ch = int(raw_input())
19.    if ch ==1:
20.        # création de toutes les tables décrites dans le dictionnaire :
21.        bd.creerTables(Glob.dicoT)
22.    elif ch ==2:
23.        # suppression de toutes les tables décrites dans le dic. :
24.        bd.supprimerTables(Glob.dicoT)     
25.    elif ch ==3 or ch ==4:
26.        # création d'un <enregistreur> de compositeurs ou d'oeuvres :
27.        table ={3:'compositeurs', 4:'oeuvres'}[ch]
28.        enreg =Enregistreur(bd, table)
29.        while 1:
30.            if enreg.entrer():
31.                break
32.    elif ch ==5 or ch ==6:
33.        # listage de tous les compositeurs, ou toutes les oeuvres :
34.        table ={5:'compositeurs', 6:'oeuvres'}[ch]
35.        if bd.executerReq("SELECT * FROM %s" % table):
36.            # analyser le résultat de la requête ci-dessus :
37.            records = bd.resultatReq()      # ce sera un tuple de tuples
38.            for rec in records:             # => chaque enregistrement
39.                for item in rec:            # => chaque champ dans l'enreg.
40.                    print item,
41.                print
42.    elif ch ==7:
43.        req =raw_input("Entrez la requête SQL : ")
44.        if bd.executerReq(req):
45.            print bd.resultatReq()          # ce sera un tuple de tuples
46.    else:
47.        bd.commit()
48.        bd.close()
49.        break
Commentaires

On supposera bien évidemment que les classes décrites plus haut soient présentes dans le même script, ou qu'elles aient été importées.

  • Lignes 3 à 6 : L'objet-interface est créé ici. Si la création échoue, l'attribut d'instance bd.echec contient la valeur 1. Le test des lignes 5 et 6 permet alors d'arrêter l'application immédiatement (la fonction exit() du module sys sert spécifiquement à cela).
  • Ligne 8 : Le reste de l'application consiste à proposer sans cesse le même menu, jusqu'à ce que l'utilisateur choisisse l'option n° 9.
  • Lignes 27 et 28 : La classe Enregistreur() accepte de gérer les enregistrements de n'importe quelle table. Afin de déterminer laquelle doit être utilisée lors de l'instanciation, on utilise un petit dictionnaire qui indique quel nom retenir, en fonction du choix opéré par l'utilisateur (option n° 3 ou n° 4).
  • Lignes 29 à 31 : La méthode entrer() de l'objet-enregistreur renvoie une valeur 0 ou 1 suivant que l'utilisateur ait choisi de continuer à entrer des enregistrements, ou bien d'arrêter. Le test de cette valeur permet d'interrompre la boucle de répétition en conséquence.
  • Lignes 35 et 44 : La méthode executerReq() renvoie une valeur 0 ou 1 suivant que la requête ait été acceptée ou non par le serveur. On peut donc tester cette valeur pour décider si le résultat doit être affiché ou non.

Exercices

  1. Modifiez le script décrit dans ces pages de manière à ajouter une table supplémentaire à la base de données. Ce pourrait être par exemple une table « orchestres », dont chaque enregistrement contiendrait le nom de l'orchestre, le nom de son chef, et le nombre total d'instruments.
  2. Ajoutez d'autres types de champ à l'une des tables (par exemple un champ de type float (réel) ou de type date), et modifiez le script en conséquence.

Solution

  1. Réfléchissez !
  2. Réfléchissez !

Notes[modifier | modifier le wikicode]

  1. Il vous faudra certainement entrer quelques informations pour obtenir l'accès : adresse du serveur sur le réseau, nom de la base de données, nom d'utilisateur, mot de passe, ...
  2. Quelques variantes subsistent entre différentes implémentations du SQL, pour des requêtes très spécifiques, mais la base reste cependant la même.
  3. Gadfly se révèle relativement efficace pour la gestion de bases de données de taille moyenne, en mode mono-utilisateur. Pour gérer de grosses bases de données en mode multi-utilisateur, il faut faire appel à des SGDBR plus ambitieux tels que PostgreSQL, pour lesquels des modules clients Python existent aussi (Pygresql, par ex.).
  4. Le module Gadfly est disponible gratuitement sur l'internet. Voir http://sourceforge.net/projects/gadfly L'installation de ce module est décrite dans l'annexe A, page
    Nuvola apps korganizer.svg
    À faire...


  5. Veuillez noter qu'en SQL, les chaînes de caractères doivent être délimitées par des apostrophes. Si vous souhaitez que la chaîne contienne elle-même une ou plusieurs apostrophes, il vous suffit de doubler celles-ci.
  6. Vous pourriez également placer vos variables « globales » dans un module nommé Glob.py, puis importer celui-ci. Utiliser un module ou une classe comme espace de noms pour stocker des variables sont donc des techniques assez similaires. L'utilisation d'une classe est peut-être un peu plus souple et plus lisible, puisque la classe peut accompagner le reste du script, alors qu'un module est nécessairement un fichier distinct.