Apprendre à programmer avec Python 3

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, SQLite, 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, appelés 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, 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(88). 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.

À la lecture de ce qui précède, vous aurez bien compris qu'il ne peut être question de vous expliquer dans ces pages comment vous pourriez réaliser vous-même un logiciel serveur. C'est vraiment là une affaire de spécialistes (au même titre que le développement d'un nouveau langage de programmation, par exemple). L'élaboration d'un logiciel client, par contre, est tout à fait à votre portée et peut vous apporter un immense bénéfice. Il faut savoir en effet que la plupart des applications « sérieuses » de l'informatique s'articulent autour d'une base de données plus ou moins complexe : même les logiciels de jeu doivent mémoriser une foule de données, et maintenir entre elles des relations.

En fonction des besoins de votre application, vous devrez donc choisir, soit de vous connecter à un gros serveur distant géré par d'autres personnes, soit de mettre en place un serveur local plus ou moins performant. Dans le cas particulier d'une application monoposte, vous pourrez utiliser un logiciel serveur installé sur la même machine que votre application, ou plus simplement encore exploiter une bibliothèque-serveur compatible avec votre langage de programmation. Vous verrez cependant que dans tous les cas de figure, les mécanismes à mettre en œuvre restent fondamentalement les mêmes.

On aurait pu craindre, en effet, qu'étant donnée la grande diversité des systèmes serveurs existants, il soit nécessaire de faire usage de protocoles et de langages différents pour adresser des requêtes à chacun d'eux. Mais fort heureusement, de grands efforts de standardisation ont été accomplis pour la mise au point d'un langage de requêtes commun, qui porte le nom de SQL (Structured Query Language, ou langage de requêtes structuré)(89). En ce qui concerne Python, un effort supplémentaire a été accompli pour standardiser les procédures d'accès aux serveurs eux-mêmes, sous la forme d'une interface commune (DBAPI(90)).

Vous allez donc devoir apprendre quelques rudiments de ce langage pour pouvoir continuer, mais cela ne doit pas vous effrayer. Vous aurez d'ailleurs certainement l'occasion de rencontrer SQL dans d'autres domaines (bureautique, par exemple). Dans le cadre restreint de ce cours, il vous suffira de connaître quelques instructions SQL très simples pour comprendre les mécanismes de base et peut-être déjà réaliser quelques projets intéressants.

Cela signifie donc que vous pouvez écrire en Python une application contenant son propre SGBDR intégré, sans qu'il soit nécessaire d'installer quoi que ce soit d'autre, et que les performances seront au rendez-vous.

Nous verrons en fin de chapitre comment les choses se présentent si votre application doit utiliser plutôt un serveur de bases de données hébergé par une autre machine, mais les principes resteront les mêmes. Tout ce que vous aurez appris à faire avec SQLite sera transposable sans modification si vous devez plus tard travailler avec un SGDBR plus « imposant » tel que PostgreSQL, MySQL ou Oracle.

Commençons donc tout de suite à explorer les bases de ce système, à la ligne de commande. Nous écrirons ensuite un petit script pour gérer une base de données simple à deux tables.

Comme vous vous y attendez certainement, il suffit d'importer un module pour accéder aux fonctionnalités attendues :

>>> import sqlite3

(Le chiffre à la fin du nom est le numéro de la version actuelle du module d'interface au moment où nous écrivons ces lignes. Il est possible que ce soit modifié dans des versions futures de Python).

Il faut ensuite décider le nom de fichier que vous voulez attribuer à la base de données. SQLite mémorise toutes les tables d'une base de données dans un seul fichier multi-plateformes que vous pouvez sauvegarder où vous voulez (cela devrait grandement vous faciliter la vie pour les archivages !) :

>>> fichierDonnees ="E:/python3/essais/bd_test.sq3"

Le nom de fichier peut comporter un chemin et une extension quelconques. Il est également possible d'utiliser le nom spécial « :memory: », ce qui indiquera au système de traiter la base de données en mémoire vive seulement. Ainsi les temps d'accès aux données seront raccourcis, et l'application pourra être ultra-rapide, ce qui peut vous intéresser dans le contexte d'un logiciel de jeu, par exemple, à la condition de prévoir un mécanisme distinct pour les sauvegardes sur disque.

Vous créez alors un objet-connexion, à l'aide de la fonction-fabrique connect(). Cet objet assurera l'interface entre votre programme et la base de données. L'opération est tout à fait comparable à l'ouverture d'un simple fichier texte, l'instanciation de l'objet créant le fichier de mémorisation au passage (s'il n'existe pas déjà) :

>>> conn =sqlite3.connect(fichierDonnees)

L'objet connexion est désormais en place, et vous allez pouvoir dialoguer avec lui à l'aide du langage SQL. Il serait possible de le faire directement à l'aide de certaines méthodes de cet objet(91) , mais il est préférable de mettre en place pour ce dialogue, encore un autre objet-interface que l'on appelle 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 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 (vous pouvez en apprendre davantage sur ce concept en consultant l'un des nombreux manuels qui traitent du langage SQL).

>>> cur =conn.cursor()

Une base de données se compose toujours d'une ou plusieurs tables, qui contiendront les enregistrements (ou records), ceux-ci comportant eux-mêmes un certain nombre de champs de différents types. Ces concepts vous sont probablement familiers si vous avez déjà travaillé avec un logiciel tableur quelconque : les enregistrements sont les lignes du tableau, et les champs les cellules d'une ligne. Nous allons donc rédiger une première requête SQL pour demander la création d'une nouvelle table :

>>> cur.execute("CREATE TABLE membres (age INTEGER, nom TEXT, taille REAL)")

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(). Notez bien que le langage SQL ne tient aucun compte de la casse des caractères : vous pouvez donc encoder vos requêtes SQL indifféremment en majuscules ou en minuscules. Nous avons personnellement choisi d'écrire en majuscules les instructions de ce langage, afin de bien marquer la différence avec les instructions Python environnantes, mais vous pouvez bien évidemment adopter d'autres habitudes.

Veuillez également remarquer au passage que les types de données ne portent pas les mêmes noms en Python et en SQL. La traduction ne devrait cependant pas vous tracasser outre mesure. Signalons simplement que les chaînes de caractères seront encodées par défaut en Utf-8, suivant en cela la même convention que celle déjà mentionnée précédemment pour les fichiers texte (voir page ).

Nous pouvons maintenant entrer des enregistrements :

>>> cur.execute("INSERT INTO membres(age,nom,taille) VALUES(21,'Dupont',1.83)")
>>> cur.execute("INSERT INTO membres(age,nom,taille) VALUES(15,'Blumâr',1.57)")
>>> cur.execute("INSERT Into membres(age,nom,taille) VALUES(18,'Özémir',1.69)")

Attention : à ce stade des opérations, les enregistrement sont dans le tampon du curseur, mais ils n'ont pas encore été transférés véritablement dans la base de données. Vous pourriez donc annuler tout, si nécessaire, comme nous le verrons un peu plus loin. Le transfert dans la basse de données sera déclenché par la méthode commit() de l'objet connexion :

>>> conn.commit()

Le curseur peut alors être refermé, de même que la connexion, si le travail est terminé(92) :

>>> cur.close() 
>>> conn.close()

À la suite des opérations ci-dessus, un fichier nommé bd_test.sq3 aura été crée à l'emplacement indiqué dans votre machine. Vous pourriez dès lors quitter Python, et même éventuellement même éteindre votre ordinateur : les données sont enregistrées. Maintenant, comment faut-il procéder pour y accéder à nouveau ? C'est très simple : il suffit d'utiliser exactement les mêmes instructions :

>>> import sqlite3
>>> conn =sqlite3.connect("E:/python3/essais/bd_test.sq3") 
>>> cur =conn.cursor()

L'interrogation de la base s'effectue bien évidemment à l'aide de requêtes SQL, que l'on confie à 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. Dans le cas présent, la sélection n'en n'est pas tout à fait une, car nous y demandons en effet d'extraire tous les enregistrements de la table membres (rappelons que le symbole * est fréquemment utilisé en informatique comme un « joker » ayant la signification « tout » ou « tous »).

Les enregistrement 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(93).

Vous pouvez parcourir directement la séquence qu'il produit, à l'aide d'une boucle for classique. Vous obtenez une série de tuples :

>>> for l in cur:
...    print(l) 
... 
(21, 'Dupont', 1.83)
(15, 'Blumâr', 1.57)
(18, 'Özémir', 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, 'Dupont', 1.83), (15, 'Blumâr', 1.57), (18, 'Özémir', 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, 'Dupont', 1.83), (15, 'Blumâr', 1.57), (18, 'Özémir', 1.69)]

Tant que le curseur reste ouvert, vous pouvez bien entendu ajouter des enregistrements supplémentaires :

>>> cur.execute("INSERT INTO membres(age,nom,taille) VALUES(19,'Ricard',1.75)")

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. Il est cependant fortement déconseillé de faire appel dans ce but aux techniques ordinaires de formatage des chaînes, car cela peut ouvrir une faille de sécurité dans vos programmes, en y autorisant les intrusions par la méthode de piratage connue sous le nom de SQL injection(94). Il faut donc plutôt confier le formatage de vos requêtes au module d'interface lui-même. 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,"Durand",1.74),(22,"Berger",1.71),(20,"Weber",1.65)] 
>>> for tu 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.

À ce stade des opérations, vous pourriez penser que tout ce que nous venons de voir est bien compliqué pour écrire et relire ensuite des informations dans un fichier. Ne serait-il pas plus simple de faire appel aux procédés de traitement des fichiers texte que nous connaissons déjà ? Oui et Non. Cela reste vrai pour de petites quantités d'informations ne nécessitant guère de changements au fil du temps qui passe, mais n'est plus défendable si l'on considère déjà le simple problème de la modification ou de la suppression d'un enregistrement quelconque au sein du fichier. Dans une base de données, c'est très simple :

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'")

Avec ce que nous connaissons des fichiers texte, nous devrions certainement déjà écrire pas mal de lignes de code pour arriver faire la même chose ! Mais il y a encore beaucoup plus.

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()

Exercice

.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 valablement les fonctions de recherche et de tri prises en charge par le SGBDR) :

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
Haendel        1685	  1759
Schubert       1797	  1828
Vivaldi        1678	  1741
Monteverdi     1567	  1643
Chopin		1810	   1849
Bach	      1685	 1750
Shostakovich   1906	  1975

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, veuillez consulter le corrigé de l'exercice 16.1, à la page .

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 sqlite3
 
baseDonn = sqlite3.connect("musique.sq3")
cur = baseDonn.cursor()
while 1:
  print("Veuillez entrer votre requête SQL (ou <Enter> pour terminer) :")
  requete = input()
  if requete =="":
      break
  try:
      cur.execute(requete)	   # exécution de la requête SQL
  except:
      print('*** Requête SQL incorrecte ***')
  else:
      for enreg in cur: 	# Affichage du résultat
      print(enreg)
  print()
 
choix = input("Confirmez-vous l'enregistrement de l'état actuel (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 .

L'une des instructions les plus puissantes du langage SQL est la requête 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
select * from compositeurs where a_mort <1800
select * from compositeurs where a_mort <1800 limit 3

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.comp, c.a_naiss from oeuvres as o, compositeurs as c
 where o.comp =c.comp
select comp, titre, a_naiss from oeuvres join compositeurs using(comp)	    
select * from oeuvres join compositeurs using(comp) order by a_mort
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 cet ouvrage. 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.). Du fait qu'il existe d'excellents logiciels libres et gratuits, vous pouvez aisément mettre en service vous-même un serveur extrêmement performant tel que PostgreSQL(95). L'exercice sera particulièrement intéressant si vous prenez la peine d'installer le logiciel serveur sur une machine distincte de votre poste de travail habituel, et de relier les deux par l'intermédiaire d'une connexion réseau de type TCP/IP.

Une application dialoguant avec une base de données est presque toujours une application complexe. Elle comporte donc nécessairement 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(96).

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 cette 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(object):
  """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 = "127.0.0.1"	      # nom ou adresse IP du serveur
  port =5432
 
  # 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 œuvre 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.

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.

import sys
from pg8000 import DBAPI
from dict_app import *
 
class GestionBD(object):
  """Mise en place et interfaçage d'une base de données PostgreSQL"""
  def __init__(self, dbName, user, passwd, host, port =5432):
      "Établissement de la connexion - Création du curseur"
      try:
      self.baseDonn = DBAPI.connect(host =host, port =port,
		     database =dbName,
		     user=user, password=passwd)
      except Exception as err:
      print('La connexion avec la base de données a échoué :\n'\
	 'Erreur détectée :\n%s' % err)
      self.echec =1
      else:
      self.cursor = self.baseDonn.cursor()   # création du curseur
      self.echec =0
 
  def creerTables(self, dicTables):
      "Création des tables décrites dans le dictionnaire <dicTables>."
      for table in dicTables:	      # parcours des clés du dictionnaire
      req = "CREATE TABLE %s (" % table
      pk =''
      for descr in dicTables[table]:
	  nomChamp = descr[0]	  # libellé du champ à créer
	  tch = descr[1]	 # type de champ à créer
	  if tch =='i':
	  typeChamp ='INTEGER'
	  elif tch =='k':
	  # champ 'clé primaire' (entier incrémenté automatiquement)
	  typeChamp ='SERIAL'
	  pk = nomChamp
	  else:
	  typeChamp ='VARCHAR(%s)' % tch
	  req = req + "%s %s, " % (nomChamp, typeChamp)
      if pk == '':
	  req = req[:-2] + ")"
      else:
	  req = req + "CONSTRAINT %s_pk PRIMARY KEY(%s))" % (pk, pk)
      self.executerReq(req)
 
  def supprimerTables(self, dicTables):
      "Suppression de toutes les tables décrites dans <dicTables>"
      for table in list(dicTables.keys()):
      req ="DROP TABLE %s" % table
      self.executerReq(req)
      self.commit()		 # transfert -> disque
 
  def executerReq(self, req, param =None):
      "Exécution de la requête <req>, avec détection d'erreur éventuelle"
      try:
      self.cursor.execute(req, param)
      except Exception as err:
      # afficher la requête et le message d'erreur système :
      print("Requête SQL incorrecte :\n{}\nErreur détectée :".format(req))
      print(err)
      return 0
      else:
      return 1
 
  def resultatReq(self):
      "renvoie le résultat de la requête précédente (une liste de tuples)"
      return self.cursor.fetchall()
 
  def commit(self):
      if self.baseDonn:
      self.baseDonn.commit()	 # transfert curseur -> disque
 
  def close(self):
      if self.baseDonn:
      self.baseDonn.close()

18-B-2-A. Commentaires▲

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(object):
  """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 =[]	 # liste pour les valeurs correspondantes
      # 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 = input("Entrez le champ %s :" % nom)
      if type =="i":
	  val =int(val)
      valeurs.append(val)
 
      balises ="(" + "%s," * len(valeurs)     # balises de conversion
      champs = champs[:-1] + ")"    # supprimer la dernière virgule,
      balises = balises[:-1] + ")"  # et ajouter une parenthèse
      req ="INSERT INTO %s %s VALUES %s" % (self.table, champs, balises)
      self.bd.executerReq(req, valeurs)
 
      ch =input("Continuer (O/N) ? ")
      if ch.upper() == "O":
      return 0
      else:
      return 1

18-B-3-A. Commentaires▲

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 !

###### Programme principal : #########
 
# Création de l'objet-interface avec la base de données :
bd = GestionBD(Glob.dbName, Glob.user, Glob.passwd, Glob.host, Glob.port)
if bd.echec:
  sys.exit()
 
while 1:
  print("\nQue voulez-vous faire :\n"\
     "1) Créer les tables de la base de données\n"\
     "2) Supprimer les tables de la base de données ?\n"\
     "3) Entrer des compositeurs\n"\
     "4) Entrer des oeuvres\n"\
     "5) Lister les compositeurs\n"\
     "6) Lister les oeuvres\n"\
     "7) Exécuter une requête SQL quelconque\n"\
     "9) terminer ?		Votre choix :", end=' ')
  ch = int(input())
  if ch ==1:
      # création de toutes les tables décrites dans le dictionnaire :
      bd.creerTables(Glob.dicoT)
  elif ch ==2:
      # suppression de toutes les tables décrites dans le dic. :
      bd.supprimerTables(Glob.dicoT)
  elif ch ==3 or ch ==4:
      # création d'un <enregistreur> de compositeurs ou d'oeuvres :
      table ={3:'compositeurs', 4:'oeuvres'}[ch]
      enreg =Enregistreur(bd, table)
      while 1:
      if enreg.entrer():
	  break
  elif ch ==5 or ch ==6:
      # listage de tous les compositeurs, ou toutes les oeuvres :
      table ={5:'compositeurs', 6:'oeuvres'}[ch]
      if bd.executerReq("SELECT * FROM %s" % table):
      # analyser le résultat de la requête ci-dessus :
      records = bd.resultatReq()      # ce sera un tuple de tuples
      for rec in records:	   # => chaque enregistrement
	  for item in rec:	 # => chaque champ dans l'enreg.
	  print(item, end=' ')
	  print()
  elif ch ==7:
      req =input("Entrez la requête SQL : ")
      if bd.executerReq(req):
      print(bd.resultatReq())	    # ce sera un tuple de tuples
  else:
      bd.commit()
      bd.close()
      break

18-B-4-A. Commentaires▲