Plongez au coeur de Python ,De débutant à expert

>>> fsock = open("/notthere", "r")      ***1***
	Traceback (innermost last):
  File "<interactive input>", line 1, in ?
	IOError: [Errno 2] No such file or directory: '/notthere'
	>>> try:
	...     fsock = open("/notthere")       ***2***
	... except IOError:                     ***3***
	...     print "The file does not exist, exiting gracefully"
	... print "This line will always print" ***4***
	The file does not exist, exiting gracefully
	This line will always print

***1*** En utilisant la fonction prédéfinie open, nous pouvons ouvrir un fichier en lecture (nous verrons open plus en détail dans la section suivante). Mais le fichier n'existe pas, ce qui déclenche une exception IOError. Comme nous n'avons pas fourni de gestionnaire pour l'exception IOError, Python se contente d'afficher des informations de débogage et abandonne.

***2*** Nous allons essayer d'ouvrir le même fichier non-existant, mais cette fois à l'intérieur d'un bloc try...except.

***3*** Quand la méthode open déclenche une exception IOError, nous sommes prêts. La ligne except IOError: intercepte l'exception et exécute notre propre bloc de code, qui en l'occurence ne fait qu'afficher un message d'erreur plus agréable.

***4*** Une fois qu'une exception a été traitée, le traitement continue normalement à la première ligne après le bloc try...except. Notez que cette ligne sera toujours affichée, qu'une exception se produise ou pas. Si vous aviez vraiment un fichier appelé notthere dans votre répertoire racine, l'appel a open réussirait, la clause except serait ignorée, mais cette ligne serait quand même exécutée.

Les exceptions peuvent sembler hostiles (après tout, si vous ne les interceptez pas, votre programme plante), mais réflechissez à l'alternative. Voudriez-vous plutôt un objet-fichier inutilisable pointant vers un fichier non-existant ? De toute manière, vous auriez quand même à vérifier sa validité, sinon votre programme produirait des erreurs bizarres plus loin dont vous auriez à retrouver la source. Je suis sûr que vous avez déjà fait cela, ce n'est pas drôle. Avec les exceptions, les erreurs se produisent immédiatement et vous pouvez les gérer de manière standardisée à la source du problème.

Il y a de nombreux autres usages pour les exceptions en dehors de la prise en compte de véritables conditions d'erreurs. Un des usages commun dans la bibliothèque standard Python est d'essayer d'importer un module, puis de vérifier si cela à marché. Importer un module qui n'existe pas déclenchera une exception ImportError. Vous pouvez utiliser cela pour définir des niveaux multiples de fonctionnalité basé sur la disponibilité des modules à l'exécution, ou pour supporter plusieurs plateformes (dans ce cas le code spécifique à chaque plateforme est séparé dans différents modules).

Vous pouvez aussi définir vos propre exceptions en créant un classe qui hérite de la classe prédéfinie Exception et déclencher vos exceptions avec l'instruction raise. Cela dépasse le champ de cette section, voyez la section «Pour en savoir plus» si vous êtes intéressé.

L'exemple suivant démontre l'utilisation d'une exception pour le support d'une fonctionnalité spécifique à une plate-forme. Ce code vient du module getpass, un module enveloppe pour obtenir un mot de passe de l'utilisateur. Obtenir un mot de passe est fait de manière différente sous UNIX, Windows et Mac OS, mais ce code encapsule toutes ces différences.

Exemple 6.2. Support de fonctionnalités propre à une plate-forme▲

	  # Bind the name getpass to the appropriate function
	  try:
	      import termios, TERMIOS                     ***1***
	  except ImportError:
	      try:
		  import msvcrt                           ***2***
	      except ImportError:
		  try:
		      from EasyDialogs import AskPassword ***3***
		  except ImportError:
		      getpass = default_getpass           ***4***
		  else:                                   ***5***
		      getpass = AskPassword
	      else:
		  getpass = win_getpass
	  else:
	      getpass = unix_getpass

>>> f = open("/music/_singles/kairo.mp3", "rb") ***1***
	>>> f                                           ***2***
	<open file '/music/_singles/kairo.mp3', mode 'rb' at 010E3988>
>>> f.mode                                      ***3***
'rb'
>>> f.name                                      ***4***
'/music/_singles/kairo.mp3'

***1*** La méthode open peut prendre jusqu'à trois paramètres : un nom de fichier, un mode et un paramètre de tampon. Seul le premier, le nom de fichier, est nécéssaire, les deux autres sont optionnels. Si le mode n'est pas spécifié, le fichier est ouvert en mode texte pour la lecture. Ici nous ouvrons le fichier en mode binaire pour la lecture (print open.__doc__ affiche une bonne explication de tous les modes possibles).

***2*** La fonction open retourne un objet (arrivé à ce point cela ne doit pas vous surprendre). Un objet-fichier à plusieurs attributs utiles.

***3*** L'attribut mode d'un objet-fichier vous indique dans quel mode le fichier a été ouvert.

***4*** L'attribut name d'un objet-fichier vous indique le nom du fichier qui a été ouvert.

Une fois un fichier ouvert, la première chose que l'on peut faire est de le lire, comme nous allons le voir dans l'exemple suivant.

Exemple 6.4. Lecture d'un fichier▲

>>> f
<open file '/music/_singles/kairo.mp3', mode 'rb' at 010E3988>
>>> f.tell()              ***1***
0
>>> f.seek(-128, 2)       ***2***
>>> f.tell()              ***3***
7542909
>>> tagData = f.read(128) ***4***
>>> tagData
'TAGKAIRO****THE BEST GOA         ***DJ MARY-JANE***            
Rave Mix                      2000http://mp3.com/DJMARYJANE     \037'
>>> f.tell()              ***5***
7543037

Les fichiers ouverts consomment des ressources système et, en fonction du mode d'ouverture, peuvent ne pas être accessibles à d'autres programmes. Il est donc important de fermer les fichiers dès que vous ne les utilisez plus.

Exemple 6.5. Fermeture d'un fichier▲

>>> f
<open file '/music/_singles/kairo.mp3', mode 'rb' at 010E3988>
>>> f.closed       ***1***
False
>>> f.close()      ***2***
>>> f
<closed file '/music/_singles/kairo.mp3', mode 'rb' at 010E3988>
>>> f.closed       ***3***
True
>>> f.seek(0)      ***4***
Traceback (innermost last):
  File "<interactive input>", line 1, in ?
ValueError: I/O operation on closed file
>>> f.tell()
Traceback (innermost last):
  File "<interactive input>", line 1, in ?
ValueError: I/O operation on closed file
>>> f.read()
Traceback (innermost last):
  File "<interactive input>", line 1, in ?
ValueError: I/O operation on closed file
>>> f.close()      ***5***

Maintenant vous en avez vu assez pour comprendre le code de gestion de fichier dans le programme d'exemple fileinfo.py du chapitre précédent. L'exemple suivant montre comment ouvrir et lire un fichier de manière sûre en gérant les erreurs.

Exemple 6.6. Les objets-fichier dans MP3FileInfo▲

       try:                                ***1***
            fsock = open(filename, "rb", 0) ***2***
            try:                           
                fsock.seek(-128, 2)         ***3***
                tagdata = fsock.read(128)   ***4***
            finally:                        ***5***
                fsock.close()              
            .
            .
            .
        except IOError:                     ***6***
            pass

Nous pouvons bien sûr écrire dans un fichier, cela se fait en grande partie de la même manière que pour la lecture. Il y a deux modes d'ouverture de base :

• Le mode Append (ajout) pour ajouter des données à la fin du fichier.
• Le mode Write (écriture) pour écraser le contenu du fichier.

Les deux modes créeront le fichier automatiquement s'il n'existe pas encore, il n'y a donc pas besoin de logique du type «si le fichier de journalisation n'existe pas, créer un nouveau fichier vide et l'ouvrir en écriture.» Il suffit d'ouvrir le fichier pour commencer à y écrire.

Exemple 6.7. Ecriture dans un fichier▲

>>> logfile = open('test.log', 'w') ***1***
>>> logfile.write('test succeeded') ***2***
>>> logfile.close()
>>> print file('test.log').read()   ***3***
test succeeded
>>> logfile = open('test.log', 'a') ***4***
>>> logfile.write('line 2')
>>> logfile.close()
>>> print file('test.log').read()   ***5***
test succeededline 2

>>> li = ['a', 'b', 'e']
>>> for s in li:         ***1***
...     print s          ***2***
a
b
e
>>> print "\n".join(li)  ***3***
a
b
e

***1*** La syntaxe d'une boucle for est similaire aux list comprehensions. li est une liste et s prend successivement la valeur de chaque élément, en commençant par le premier.

***2*** Comme une instruction if ou n'importe quel autre bloc indenté, une boucle for peut contenir autant de lignes de codes que vous le voulez.

***3*** Voici la raison pour laquelle vous n'aviez pas encore vu la boucle for : nous n'en avions pas eu besoin. C'est incroyable la fréquence à laquelle nous utilisons les boucles for dans d'autres langages alors que ce que nous voudrions vraiment et un join ou une list comprehension.

Faire un compteur «normal» (selon les critères de Visual Basic) pour la boucle for est également simple.

>>> for i in range(5):             ***1***
...     print i
0
1
2
3
4
>>> li = ['a', 'b', 'c', 'd', 'e']
>>> for i in range(len(li)):       ***2***
...     print li[i]
a
b
c
d
e

***1*** Comme nous l'avons vu dans l'Exemple 3.20, «Assignation de valeurs consécutives», range produit une liste d'entiers que nous pouvons parcourir. Je sais que ça peut sembler étrange, mais c'est parfois (et j'insiste sur le parfois) utile d'avoir une boucle sur un compteur.

***2*** Ne faites jamais ça. C'est un style de pensée Visual Basic. Libérez-vous en. Parcourez simplement la liste comme dans l'exemple précédent.

Les boucles for ne sont seulement faites pour les compteurs simples. Elles peuvent parcourir de nombreuses choses. Voici un exemple d'utilisation d'une boucle for pour parcourir un dictionnaire.

>>> import os
>>> for k, v in os.environ.items():      ***1*** ***2***
...     print "%s=%s" % (k, v)
USERPROFILE=C:\Documents and Settings\mpilgrim
OS=Windows_NT
COMPUTERNAME=MPILGRIM
USERNAME=mpilgrim

[...snip...]
>>> print "\n".join(["%s=%s" % (k, v)
...     for k, v in os.environ.items()]) ***3***
USERPROFILE=C:\Documents and Settings\mpilgrim
OS=Windows_NT
COMPUTERNAME=MPILGRIM
USERNAME=mpilgrim

[...snip...]

***1*** os.environ est un dictionnaire des variables d'environnement définies dans votre système. Sous Windows ce sont vos variables utilisateur et système. Sous UNIX ce sont les variables exportées par le script de démarrage de votre shell. Sous Mac OS il n'y a pas de notion de variables d'environnement, ce dictionnaire est donc vide.

***2*** os.environ.items() retourne une liste de tuples : [(key1, value1), (key2, value2), ...]. La boucle for parcourt cette liste. A la première itération, il assigne key1 à k et value1 à v, donc k = USERPROFILE et v = C:\Documents and Settings\mpilgrim. A la seconde, k reçoit la deuxième clé, OS et v la valeur correspondante, Windows_NT.

***3*** Avec l'assignement multiple de variable et les list comprehensions, vous pouvez entièrement remplacer la boucle for par une seule instruction. Le choix d'une des deux formes dans votre code est une question de style personnel. J'aime ce style parce qu'il rend clair que ce que nous faisons est une mutation d'un dictionnaire en une liste, puis de joindre cette liste en une chaîne unique. D'autres programmeurs préfèrent la forme de la boucle for. Notez que la sortie est la même dans les deux cas, bien que cette version-ci soit légèrement plus rapide car il n'y a qu'une instruction print au lieu d'une par itération.

Maintenant nous pouvons examiner l'usage de la boucle for dans la classe MP3FileInfo du programme d'exemple fileinfo.py présenté au Chapitre 5.

tagDataMap = {"title"   : (  3,  33, stripnulls),
                  "artist"  : ( 33,  63, stripnulls),
                  "album"   : ( 63,  93, stripnulls),
                  "year"    : ( 93,  97, stripnulls),
                  "comment" : ( 97, 126, stripnulls),
                  "genre"   : (127, 128, ord)}                               ***1***
    .
    .
    .
            if tagdata[:3] == "TAG":
                for tag, (start, end, parseFunc) in self.tagDataMap.items(): ***2***
                    self[tag] = parseFunc(tagdata[start:end])                ***3***

***1*** tagDataMap est un attribut de classe qui définit les balises que nous recherchons dans un fichier MP3 file. Les balises sont stockées dans des champ de longueur fixe, une fois que nous avons lu les derniers 128 octets du fichier, les octets 3 à 32 contiennent toujours le titre de la chanson, 33-62 le nom de l'artiste, 63-92 le nom de l'album etc. Notez que tagDataMap est un dictionnaire de tuples et que chaque tuple contient deux entiers et une référence de fonction.

***2*** Ceci à l'air compliqué, mais ne l'est pas. La structure des variables de for correspond à la structure des éléments de la liste retournée par items. Rappelez-vous, items retourne une liste de tuples de la forme (key, value). Le premier élément de cette liste est ("title", (3, 33, <function stripnulls>)), donc à la première itération de la boucle tag reçoit "title", start reçoit 3, end reçoit 33 et parseFunc reçoit la fonction stripnulls.

***3*** Maintenant que nous avons extrait tous les paramètres pour une balise MP3 unique, sauvegarder les données de la balise data est simple. Nous découpons tagdata de start à end pour obtenir les véritables données de cette balise, nous appelons parseFunc pour le traitement final des données et assignons le résultat comme valeur de la clé tag dans le pseudo-dictionnaire self. Après itération de tous les éléments de tagDataMap, self a les valeurs de toutes les balises et vous savez à quoi ça ressemble.

>>> import sys                          ***1***
>>> print '\n'.join(sys.modules.keys()) ***2***
win32api
os.path
os
exceptions
__main__
ntpath
nt
sys
__builtin__
site
signal
UserDict
stat

***1*** Le module sys contient des informations système, comme la version de Python que vous utilisez (sys.version ou sys.version_info) et des options système comme la profondeur maximale de récursion autorisée (sys.getrecursionlimit() et sys.setrecursionlimit()).

***2*** sys.modules est un dictionnaire qui contient tous les modules qui ont été importés depuis que Python a été démarré. La clé est le nom de module, la valeur est l'objet module. Notez que cela comprend plus que les modules que votre programme a importé. Python charge certains modules au démarrage et si vous êtes dans une IDE Python, sys.modules contient tous les modules importés par tous les programmes que vous avez exécutés dans l'IDE.

Cet exemple présente l'utilisation de sys.modules.

>>> import fileinfo         ***1***
>>> print '\n'.join(sys.modules.keys())
win32api
os.path
os
fileinfo
exceptions
__main__
ntpath
nt
sys
__builtin__
site
signal
UserDict
stat
>>> fileinfo
<module 'fileinfo' from 'fileinfo.pyc'>
>>> sys.modules["fileinfo"] ***2***
<module 'fileinfo' from 'fileinfo.pyc'>

***1*** Au fur et à mesure que des nouveaux modules sont importés, ils sont ajoutés à sys.modules. Cela explique pourquoi importer le même module deux fois est très rapide : Python a déjà chargé et mis en cache le module dans sys.modules, donc l'importer une deuxième fois n'est qu'une simple consultation de dictionnaire.

***2*** A partir du nom (sous forme de chaîne) de n'importe quel module déjà importé, vous pouvez obtenir une référence au module lui-même du dictionnaire sys.modules.

L'exemple suivant montre l'utilisation de l'attribut de classe __module__ avec le dictionnaire sys.modules pour obtenir une référence vers le module dans lequel la classe est définie.

>>> from fileinfo import MP3FileInfo
>>> MP3FileInfo.__module__              ***1***
'fileinfo'
>>> sys.modules[MP3FileInfo.__module__] ***2***
<module 'fileinfo' from 'fileinfo.pyc'>

***1*** Chaque classe Python a un attribut de classe __module__ prédéfini, dont la valeur est le nom du module dans lequel la classe est définie.

***2*** En combinant cela au dictionnaire sys.modules vous pouvez obtenir une référence au module dans lequel la classe est définie.

Maintenant vous pouvez comprendre l'utilisation de sys.modules dans fileinfo.py, le programme d'exemple présenté au Chapitre 5. Cet exemple montre cette partie du code.

  def getFileInfoClass(filename, module=sys.modules[FileInfo.__module__]):       ***1***
        "get file info class from filename extension"                             
        subclass = "%sFileInfo" % os.path.splitext(filename)[1].upper()[1:]        ***2***
        return hasattr(module, subclass) and getattr(module, subclass) or FileInfo ***3***

***1*** Ceci est une fonction avec deux arguments, filename est obligatoire, mais module est optionnel et est par défaut le module qui contient la classe FileInfo. Cela peut sembler peu efficace si on pense que Python évalue l'expression sys.modules à chaque fois que la fonction est appelée. En fait, Python n'évalue les expressions par défaut qu'une fois, la première fois que le module est importé. Comme nous le verrons plus loin nous n'appelons jamais cette fonction avec un argument module, module sert donc de constante au niveau de la fonction.

***2*** Nous détaillerons cette ligne plus tard, après avoir étudié le module os. Pour l'instant retenez simplement que subclass obtient le nom d'un classe, comme MP3FileInfo.

***3*** Vous connaissez déjà getattr, qui obtient une référence a un objet par son nom. hasattr est une fonction complémentaire qui vérifie si un objet possède un attribut particulier. Dans le cas présent, si un module possède une classe particulière (bien que cela fonctionne pour tout objet et tout attribut, tout comme getattr). En français, cette ligne de code dit «si le module a la classe nommée par subclass alors la retourner, sinon retourner la classe de base FileInfo».

Pour en savoir plus

• Le Python Tutorial traite de quand et comment les arguments par défaut sont évalués.
• La Python Library Reference documente le module sys.

>>> import os
>>> os.path.join("c:\\music\\ap\\", "mahadeva.mp3") ***1*** ***2***
'c:\\music\\ap\\mahadeva.mp3'
>>> os.path.join("c:\\music\\ap", "mahadeva.mp3")   ***3***
'c:\\music\\ap\\mahadeva.mp3'
>>> os.path.expanduser("~")                         ***4***
'c:\\Documents and Settings\\mpilgrim\\My Documents'
>>> os.path.join(os.path.expanduser("~"), "Python") ***5***
'c:\\Documents and Settings\\mpilgrim\\My Documents\\Python'

***1*** os.path est une référence à un module, quel module exactement dépend de la plateforme que vous utilisez. Tout comme getpass encapsule les différences entre plateforme en assignant à getpass une fonction spécifique à la plateforme, os encapsule les différences entre plateformes en assignant à path un module spécifique à la plateforme.

***2*** La fonction join de os.path construit un nom de chemin à partir d'un ou de plusieurs noms de chemins partiels. Dans ce cas simple il ne fait que concaténer des chaînes (notez que traiter des noms de chemins sous Windows est ennuyeux car le backslash force à utiliser le caractère d'échappement).

***3*** Dans cette exemple un peu moins simple, join ajoute un backslash supplémentaire au nom de chemin avant de le joindre au nom de fichier. J'étais ravi quand j'ai découvert cela car addSlashIfNecessary est une des petites fonctions stupides que je dois toujours écrire quand je construis ma boîte à outil dans un nouveau langage. N'écrivez pas cette petite fonction stupide en Python, des gens intelligents l'ont déjà fait pour vous.

***4*** expanduser développe un nom de chemin qui utilise ~ pour représenter le répertoire de l'utilisateur. Cela fonctionne sur toutes les plateformes où les utilisateurs ont un répertoire propre comme Windows, UNIX et Mac OS X, c'est sans effet sous Mac OS.

***5*** En combinant ces techniques, vous pouvez facilement construire des noms de chemins pour les répertoires et les fichiers contenus dans le répertoire utilisateur.

>>> os.path.split("c:\\music\\ap\\mahadeva.mp3")                        ***1***
('c:\\music\\ap', 'mahadeva.mp3')
>>> (filepath, filename) = os.path.split("c:\\music\\ap\\mahadeva.mp3") ***2***
>>> filepath                                                            ***3***
'c:\\music\\ap'
>>> filename                                                            ***4***
'mahadeva.mp3'
>>> (shortname, extension) = os.path.splitext(filename)                 ***5***
>>> shortname
'mahadeva'
>>> extension
'.mp3'

***1*** La fonction split divise un nom de chemin complet et retourne un tuple contenant le chemin et le nom de fichier. Vous vous rappelez quand je vous ai dit que vous pouviez utiliser l'assignement multiple de variables pour retourner des valeurs multiples d'une fonction ? Et bien split est une de ces fonctions.

***2*** Nous assignons la valeur de retour de la fonction split à un tuple de deux variables. Chaque variable reçoit la valeur de l'élément correspondant du tuple retourné.

***3*** La première variable, filepath, reçoit la valeur du premier élément du tuple retourné par split, le chemin du fichier.

***4*** La seconde variable, filename, reçoit la valeur du second élément du tuple retourné par split, le nom de fichier.

***5*** os.path contient aussi une fonction splitext, qui divise un nom de fichier et retourne un tuple contenant le nom de fichier et l'extension. Nous utilisons la même technique pour assigner chacun d'entre eux à des variables séparées.

>>> os.listdir("c:\\music\\_singles\\")              ***1***
['a_time_long_forgotten_con.mp3', 'hellraiser.mp3',
'kairo.mp3', 'long_way_home1.mp3', 'sidewinder.mp3', 
'spinning.mp3']
>>> dirname = "c:\\"
>>> os.listdir(dirname)                              ***2***
['AUTOEXEC.BAT', 'boot.ini', 'CONFIG.SYS', 'cygwin',
'docbook', 'Documents and Settings', 'Incoming', 'Inetpub', 'IO.SYS',
'MSDOS.SYS', 'Music', 'NTDETECT.COM', 'ntldr', 'pagefile.sys',
'Program Files', 'Python20', 'RECYCLER',
'System Volume Information', 'TEMP', 'WINNT']
>>> [f for f in os.listdir(dirname)
...     if os.path.isfile(os.path.join(dirname, f))] ***3***
['AUTOEXEC.BAT', 'boot.ini', 'CONFIG.SYS', 'IO.SYS', 'MSDOS.SYS',
'NTDETECT.COM', 'ntldr', 'pagefile.sys']
>>> [f for f in os.listdir(dirname)
...     if os.path.isdir(os.path.join(dirname, f))]  ***4***
['cygwin', 'docbook', 'Documents and Settings', 'Incoming',
'Inetpub', 'Music', 'Program Files', 'Python20', 'RECYCLER',
'System Volume Information', 'TEMP', 'WINNT']

***1*** La fonction listdir prend un nom de chemin et retourne une liste du contenu du répertoire.

***2*** listdir retourne à la fois les fichiers et les répertoires, sans indiquer lequel est quoi.

***3*** Vous pouvez utiliser le filtrage de liste et la fonction isfile du module os.path pour séparer les fichiers des répertoires. isfile prend un nom de chemin et retourne 1 si le chemin représente un fichier et 0 dans le cas contraire. Ici, nous utilisons os.path.join pour nous assurer que nous avons un nom de chemin complet, mais isfile marche aussi avec des chemins partiels, relatifs au répertoire en cours. Vous pouvez utiliser os.getcwd() pour obtenir le répertoire en cours.

***4*** os.path a aussi une fonction isdir qui retourne 1 si le chemin représente un répertoire et 0 dans le cas contraire. Vous pouvez l'utiliser pour obtenir une liste des sous-répertoires d'un répertoire.

def listDirectory(directory, fileExtList):                                        
    "get list of file info objects for files of particular extensions" 
    fileList = [os.path.normcase(f)
                for f in os.listdir(directory)]            ***1*** ***2***
    fileList = [os.path.join(directory, f) 
               for f in fileList
                if os.path.splitext(f)[1] in fileExtList]  ***3*** ***4*** ***5***

***1*** os.listdir(directory) retourne une liste de tous les fichiers et répertoires de directory.

***2*** En parcourant la liste avec f, nous utilisons os.path.normcase(f) pour normaliser la casse en fonction des paramètres par défaut du système d'exploitation. normcase est une petite fonction utile qui compense le problème des systèmes d'exploitation insensibles à la casse qui pensent que mahadeva.mp3 et mahadeva.MP3 sont le même fichier. Par exemple, sous Windows et Mac OS, normcase convertit l'ensemble du nom de fichier en minuscules, sous les systèmes compatibles UNIX, elle retourne le nom de fichier inchangé.

***3*** En parcourant la liste normalisée avec f à nouveau, nous utilisons os.path.splitext(f) pour diviser chaque nom de fichier en nom et extension.

***4*** Pour chaque fichier, nous regardons si l'extension est dans la liste d'extensions de fichier qui nous intéressent (fileExtList, qui a été passé à la fonction listDirectory).

***5*** Pour chaque fichier qui nous intéresse, nous utilisons os.path.join(directory, f) pour construire le chemin de fichier complet. Nous retournons une liste de noms de chemin complets.

A chaque fois que c'est possible, vous devriez utiliser les fonction de os et os.path pour les manipulations de fichier, de répertoire et de chemin. Ces modules enveloppent des modules spécifiques aux plateformes, les fonctions comme os.path.split marchent donc sous UNIX, Windows, Mac OS et toute autre plateforme supportée par Python.

Il existe une autre manière d'obtenir le contenu d'un répertoire. Elle est très puissante et utilise le type de jokers qui vous sont familier si vous utilisez la ligne de commande.

>>> os.listdir("c:\\music\\_singles\\")               ***1***
['a_time_long_forgotten_con.mp3', 'hellraiser.mp3',
'kairo.mp3', 'long_way_home1.mp3', 'sidewinder.mp3',
'spinning.mp3']
>>> import glob
>>> glob.glob('c:\\music\\_singles\\*.mp3')           ***2***
['c:\\music\\_singles\\a_time_long_forgotten_con.mp3',
'c:\\music\\_singles\\hellraiser.mp3',
'c:\\music\\_singles\\kairo.mp3',
'c:\\music\\_singles\\long_way_home1.mp3',
'c:\\music\\_singles\\sidewinder.mp3',
'c:\\music\\_singles\\spinning.mp3']
>>> glob.glob('c:\\music\\_singles\\s*.mp3')          ***3***
['c:\\music\\_singles\\sidewinder.mp3',
'c:\\music\\_singles\\spinning.mp3']
>>> glob.glob('c:\\music\\*\\*.mp3')                  ***4***

***1*** Comme nous l'avons vu plus haut, os.listdir prend simplement un chemin de répertoire et retourne la liste de tous les fichiers et répertoires qu'il contient.

***2*** Le module glob, par contre, prend un joker et retourne le chemin complet de tous les fichiers et répertoires qui lui correspondent. Ici, le joker est un chemin de répertoire plus "*.mp3", c'est à dire tous les fichiers .mp3. Notez que chaque élément de la liste retournée contient le chemin complet du fichier.

***3*** Voici le joker pour trouver tous les fichiers d'un répertoire qui commencent par "s" et finissent par ".mp3".

***4*** Maintenant considerez le scénario suivant : vous avez un répertoire music, contenant plusieurs sous-répertoires, avec des fichiers .mp3 dans chaque sous-répertoire. Vous pouvez obtenir une liste de tous ces fichiers avec un seul appel à glob, en utilisant deux jokers à la fois. Un des jokers est "*.mp3" (qui correspond aux fichiers .mp3) et l'autre est à l'intérieur du chemin de répertoire, ce qui correspond aux sous-répertoires de c:\music. C'est une énorme puissance contenue dans une fonction à l'air faussement simple !

Pour en savoir plus sur le module os

• La Python Knowledge Base répond aux questions sur le module os.
• La Python Library Reference documente le module os et le module os.path.

def listDirectory(directory, fileExtList):                                         ***1***
    "get list of file info objects for files of particular extensions"
    fileList = [os.path.normcase(f)
                for f in os.listdir(directory)]           
    fileList = [os.path.join(directory, f) 
               for f in fileList
                if os.path.splitext(f)[1] in fileExtList]                          ***2***
    def getFileInfoClass(filename, module=sys.modules[FileInfo.__module__]):       ***3***
        "get file info class from filename extension"                             
        subclass = "%sFileInfo" % os.path.splitext(filename)[1].upper()[1:]        ***4***
        return hasattr(module, subclass) and getattr(module, subclass) or FileInfo ***5***
    return [getFileInfoClass(f)(f) for f in fileList]                              ***6***

***1*** listDirectory est l'attraction principale de ce module. Elle prend un répertoire (c:\music\_singles\ dans mon cas) et une liste d'extensions intéressantes (comme ['.mp3']) et elle retourne une liste d'instances de classe qui se comportent comme des dictionnaires et qui contiennent des métadonnées concernant chaque fichier intéressant de ce répertoire. Et elle le fait en une poignée de ligne simples et directes.

***2*** Comme nous l'avons vu dans la section précédente, cette ligne de code permet d'obtenir une liste de noms de chemin complets de tous les fichiers de directory qui ont une extension de fichier intéressante (comme spécifiée par fileExtList).

***3*** Les programmeurs Pascal à l'ancienne les connaissent bien, mais la plupart des gens me jettent un regard vide quand je leur dit que Python supporte les fonctions imbriquées -- littéralement une fonction à l'intérieur d'une fonction. La fonction imbriquée getFileInfoClass peut seulement être appelée de la fonction dans laquelle elle est définie, listDirectory. Comme pour toute autre fonction, vous n'avez pas besoin d'une déclaration d'interface ou de quoi que ce soit d'autre, définissez juste la fonction et écrivez-la.

***4*** Maintenant que vous avez vu le module os, cette ligne devrait être plus compréhensible. Elle obtient l'extension du fichier (os.path.splitext(filename)[1]), la force en majuscules (.upper()), découpe le point ([1:]) et construit un nom de classe en formatant la chaîne. Donc, c:\music\ap\mahadeva.mp3 devient .mp3, puis .MP3, puis MP3 et enfin MP3FileInfo.

***5*** Ayant construit le nom de la classe qui doit manipuler ce fichier, nous vérifions si cette classe existe dans ce module. Si c'est le cas, nous retournons la classe, sinon, nous retournons la classe de base, FileInfo. C'est un point très important : cette fonction retourne une classe. Pas une instance de classe, mais la classe elle-même.

***6*** Pour chaque fichier dans notre liste de «fichiers intéressants» (fileList), nous appelons getFileInfoClass avec le nom de fichier (f). Appeler getFileInfoClass(f) retourne une classe, nous ne savons pas exactement laquelle mais cela ne nous intéresse pas. Nous créons alors une instance de cette classe (quelle qu'elle soit) et passons le nom du fichier (encore f), à la méthode __init__. Comme nous l'avons vu auparavant dans ce chapitre, la méthode __init__ de FileInfo définit self["name"], ce qui déclenche __setitem__, qui est redéfini dans la classe descendante (MP3FileInfo) comme une fonction traitant le fichier de manière à en extraire les métadonnées. Nous faisons cela pour tous les fichiers intéressants et retournons une liste des instances ainsi créées.

Notez que listDirectory est complètement générique. Il ne sait pas à l'avance quels types de fichiers iI va obtenir, ou quelles sont les classes qui pourraient triter ces fichiers. Il inspecte le répertoire à la recherche de fichiers à traiter, puis recourt à l'introspection sur son propre module pour voir quelles classes de traitement (comme MP3FileInfo) sont définies. Vous pouvez étendre ce programme pour gérer d'autres types de fichiers simplement en définissant une classe portant un nom approprié : HTMLFileInfo pour les fichiers HTML, DOCFileInfo pour les fichiers .doc de Word, etc. listDirectory les prendra tous en charge, sans modification, en se déchargeant du traitement proprement dit sur les classes appropriées et en assemblant les résultats.