16.6. Importation dynamique de modules

Assez de discours philosophiques. Parlons plutôt de l'importation dynamique de modules.

D'abord, regardons à l'importation normale de modules. La syntaxe import module regarde dans le chemin de recherche si il y a un module portant ce nom et l'importe. Vous pouvez également importer plusieurs modules en une seule fois de cette manière, en les séparant par des virgules. Nous l'avons fait à la toute première ligne du script de ce chapitre.

Exemple 16.13. Importation de plusieurs modules à la fois


import sys, os, re, unittest

Cette instruction importe quatre modules à la fois : sys (pour les fonctions systèmes et l'accès aux paramètres de ligne de commande), os (pour les fonctions liées au système d'exploitation comme obtenir la liste de fichiers du répertoire), re (pour les expressions régulières) et unittest (pour les tests unitaires).

Maintenant, nous allons faire la même chose mais par importation dynamique.

Exemple 16.14. Importation dynamique de modules

>>> sys = __import__('sys')           
>>> os = __import__('os')
>>> re = __import__('re')
>>> unittest = __import__('unittest')
>>> sys                               
>>> <module 'sys' (built-in)>
>>> os
>>> <module 'os' from '/usr/local/lib/python2.2/os.pyc'>

	La fonction prédéfinie `__import__` remplit la même tâche que l'utilisation de l'instruction `import`, mais c'est une fonction qui prend une chaîne en argument.
	La variable `sys` est maintenant le module `sys`, comme si nous avions juste écrit `import sys`. La variable `os` est maintenant le module `os` etc.

Donc __import__ importe un module, mais prend une chaîne en argument. Dans ce cas, le module que nous importons est une chaîne littérale, mais il pourrait tout au si bien s'agir d'une variable ou du résultat d'un appel de fonction. Et le nom de la variable à laquelle vous assignez le module n'a pas besoin de correspondre au nom du module. Nous pourrions importer une série de modules et les assigner à une liste.

Exemple 16.15. Importation d'une liste de modules

>>> moduleNames = ['sys', 'os', 're', 'unittest'] 
>>> moduleNames
['sys', 'os', 're', 'unittest']
>>> modules = map(__import__, moduleNames)        
>>> modules                                       
[<module 'sys' (built-in)>,
<module 'os' from 'c:\Python22\lib\os.pyc'>,
<module 're' from 'c:\Python22\lib\re.pyc'>,
<module 'unittest' from 'c:\Python22\lib\unittest.pyc'>]
>>> modules[0].version                            
'2.2.2 (#37, Nov 26 2002, 10:24:37) [MSC 32 bit (Intel)]'
>>> import sys
>>> sys.version
'2.2.2 (#37, Nov 26 2002, 10:24:37) [MSC 32 bit (Intel)]'

	`moduleNames` est juste une liste de chaînes. Rien de particulier si ce n'est que les chaînes ressemblent à des noms de modules que nous pourrions importer.
	Et voilà, nous voulions les importer et nous l'avons fait en appliquant la fonction `__import__` à la liste, ce qui prend chaque élément de la liste (`moduleNames`), le passe en argument à la fonction (`__import__`) et construit une nouvelle liste avec les valeurs retournées par cette fonction.
	ous avons donc construit une liste de modules à partir d'une liste de chaînes (Vos chemins peuvent être différents en fonction de votre système d'exploitation, de l'emplacement de votre installation Python etc.)
	Pour bien retenir qu'il s'agit de véritables modules, regardons quelques uns de leurs attributs. Rappelez-vous que `modules[0]` est le module `sys`, donc `modules[0].version` est `sys.version`. Tous les autres attributs et méthodes de ces modules sonts également disponibles. Il n'y a rien de magique à propos de l'instruction `import`, ni à propos des modules. Les modules sont des objets. Tout est objet.

Maintenant vous devez être en mesure d'assembler tout cela et de comprendre ce que fait la majeure partie du code d'exemple de ce chapitre.

Plongez au coeur de Python