- À propos de sys.modules
- Afficher les modules chargés avec sys.modules
- Comprendre la structure de sys.modules
- Vérifier si un module est déjà chargé
- Récupérer un module depuis sys.modules
- Connaître le nombre de modules chargés
- Comprendre le rôle de sys.modules lors d'un import
- Obtenir le chemin d'un module chargé
- Précautions lors de la modification de sys.modules
- À retenir !
1. À propos de sys.modules
Le module sys fournit l'attribut sys.modules qui permet d'accéder aux modules actuellement chargés dans le processus Python.
sys.modules est un dictionnaire. Ses clés correspondent aux noms des modules et ses valeurs correspondent aux objets modules déjà chargés.
Le programme suivant affiche le type de sys.modules.
1 2 3 | import sys print(type(sys.modules)) |
Sortie :
1 | <class 'dict'> |
Il faut remarquer que Python charge déjà plusieurs modules au démarrage. sys.modules n'est donc généralement pas vide même si notre programme ne contient qu'un seul import sys.
2. Afficher les modules chargés avec sys.modules
Puisque sys.modules est un dictionnaire, nous pouvons parcourir ses clés pour afficher les noms des modules actuellement chargés.
Le programme suivant affiche les noms des modules présents dans sys.modules.
1 2 3 4 | import sys for nom in sys.modules: print(nom) |
Sortie possible :
1 2 3 4 5 6 7 8 9 10 11 | sys builtins _frozen_importlib _imp _thread _warnings _weakref _io marshal posix ... |
La liste exacte dépend de la version de Python, du système d'exploitation, de l'environnement d'exécution et des modules précédemment importés.
Pour obtenir un affichage plus pratique, nous pouvons trier les noms des modules avec sorted().
1 2 3 4 | import sys for nom in sorted(sys.modules): print(nom) |
Sortie possible :
1 2 3 4 5 6 7 8 9 10 11 12 | __main__ _abc _codecs _collections _frozen_importlib _io abc builtins codecs encodings sys ... |
3. Comprendre la structure de sys.modules
sys.modules est un dictionnaire dont les clés sont généralement les noms utilisés par le système d'importation et dont les valeurs sont les objets modules correspondants.
Nous pouvons par exemple récupérer l'objet associé au module sys.
1 2 3 4 5 6 | import sys module = sys.modules["sys"] print(module) print(type(module)) |
Sortie possible :
1 2 | <module 'sys' (built-in)> <class 'module'> |
Nous pouvons donc représenter de manière simplifiée une partie de sys.modules sous la forme suivante :
1 2 3 4 5 | { "sys": <module 'sys' (built-in)>, "builtins": <module 'builtins' (built-in)>, ... } |
Sortie :
1 | Chaque clé désigne un nom de module et chaque valeur contient l'objet module correspondant. |
Cette représentation est uniquement destinée à expliquer la structure du dictionnaire. Le contenu réel de sys.modules est beaucoup plus important.
4. Vérifier si un module est déjà chargé
L'opérateur in permet de vérifier facilement si le nom d'un module est présent dans sys.modules.
Le programme suivant vérifie si le module sys est déjà chargé.
1 2 3 4 5 6 | import sys if "sys" in sys.modules: print("Le module sys est chargé.") else: print("Le module sys n'est pas chargé.") |
Sortie :
1 | Le module sys est chargé. |
Nous pouvons observer l'effet d'un import sur sys.modules. Dans l'exemple suivant, nous testons la présence du module fractions avant et après son importation.
1 2 3 4 5 6 7 | import sys print("fractions" in sys.modules) import fractions print("fractions" in sys.modules) |
Sortie possible :
1 2 | False True |
La première valeur peut dépendre de l'environnement : si fractions avait déjà été chargé auparavant, le premier test retournerait également True. Dans un processus Python classique où il n'a pas encore été importé, l'exemple montre son apparition dans sys.modules après l'importation.
5. Récupérer un module depuis sys.modules
Comme sys.modules est un dictionnaire, nous pouvons récupérer directement un module déjà chargé à partir de son nom.
Le programme suivant importe le module math puis récupère l'objet correspondant depuis sys.modules.
1 2 3 4 5 6 | import sys import math module_math = sys.modules["math"] print(module_math) |
Sortie possible :
1 | <module 'math' from '...'> |
Le chemin affiché dépend de l'installation de Python.
L'objet récupéré peut être utilisé comme le module importé normalement. Nous pouvons par exemple appeler sa fonction sqrt().
1 2 3 4 5 6 | import sys import math module_math = sys.modules["math"] print(module_math.sqrt(25)) |
Sortie :
1 | 5.0 |
Dans ce cas, math et sys.modules["math"] désignent le même objet module.
1 2 3 4 | import sys import math print(math is sys.modules["math"]) |
Sortie :
1 | True |
6. Connaître le nombre de modules chargés
Puisque sys.modules est un dictionnaire, la fonction len() permet de connaître le nombre d'entrées actuellement présentes.
Le programme suivant affiche ce nombre.
1 2 3 | import sys print("Nombre de modules chargés :", len(sys.modules)) |
Sortie possible :
1 | Nombre de modules chargés : 53 |
Le nombre exact varie selon la version de Python et l'environnement utilisé.
Nous pouvons également observer comment ce nombre peut évoluer après l'importation de nouveaux modules.
1 2 3 4 5 6 7 8 9 10 11 12 | import sys avant = len(sys.modules) import fractions import statistics apres = len(sys.modules) print("Avant :", avant) print("Après :", apres) print("Nouvelles entrées :", apres - avant) |
Sortie possible :
1 2 3 | Avant : 53 Après : 72 Nouvelles entrées : 19 |
Le nombre d'entrées ajoutées peut être supérieur au nombre d'instructions import, car un module peut lui-même importer d'autres modules nécessaires à son fonctionnement.
7. Comprendre le rôle de sys.modules lors d'un import
sys.modules joue un rôle essentiel dans le système d'importation de Python. Lorsqu'un module est importé et chargé, il est normalement enregistré dans ce dictionnaire.
Lors d'un nouvel import, Python consulte notamment sys.modules. Si le module demandé y est déjà présent, l'objet module existant peut être réutilisé au lieu d'être chargé à nouveau de la manière habituelle.
Le programme suivant montre que deux instructions import math successives donnent accès au même objet module.
1 2 3 4 5 6 7 8 9 | import math module1 = math import math module2 = math print(module1 is module2) |
Sortie :
1 | True |
Nous pouvons également comparer directement le module avec l'entrée correspondante dans sys.modules.
1 2 3 4 | import sys import math print(math is sys.modules["math"]) |
Sortie :
1 | True |
Ce mécanisme évite notamment de recréer inutilement le même objet module lors de chaque instruction import dans un même processus Python.
8. Obtenir le chemin d'un module chargé
De nombreux modules possèdent un attribut __file__ indiquant le chemin du fichier à partir duquel le module a été chargé. Nous pouvons utiliser sys.modules pour accéder au module puis consulter cet attribut.
Le programme suivant affiche le chemin du module random.
1 2 3 4 5 6 | import sys import random module = sys.modules["random"] print(module.__file__) |
Sortie possible sous Windows :
1 | C:\Python314\Lib\random.py |
Le chemin exact dépend de l'installation de Python.
Tous les modules ne possèdent cependant pas nécessairement un fichier Python associé accessible avec __file__. C'est notamment le cas de certains modules intégrés. Il est donc préférable d'utiliser getattr() lorsque nous voulons traiter différents types de modules.
1 2 3 4 5 6 | import sys module = sys.modules["sys"] chemin = getattr(module, "__file__", "Aucun fichier associé") print(chemin) |
Sortie possible :
1 | Aucun fichier associé |
Cette technique permet d'éviter une erreur lorsque l'attribut __file__ n'existe pas.
9. Précautions lors de la modification de sys.modules
sys.modules est un dictionnaire modifiable, mais il représente une partie fondamentale du mécanisme d'importation de Python. Il est donc généralement déconseillé de modifier ou de supprimer ses entrées sans raison précise.
Pour comprendre ce comportement sans modifier le dictionnaire, le programme suivant crée une copie de sys.modules puis supprime une entrée uniquement dans cette copie.
1 2 3 4 5 6 7 8 9 10 11 | import sys import math copie = sys.modules.copy() print("math" in copie) del copie["math"] print("math" in copie) print("math" in sys.modules) |
Sortie :
1 2 3 | True False True |
La suppression a uniquement affecté copie. Le véritable dictionnaire sys.modules contient toujours le module math.
Pour parcourir sys.modules de manière sûre lorsque le code exécuté pendant la boucle pourrait provoquer de nouveaux imports, nous pouvons également travailler sur une copie de ses éléments.
1 2 3 4 5 6 | import sys modules = list(sys.modules.items()) for nom, module in modules[:5]: print(nom, ":", module) |
Sortie possible :
1 2 3 4 5 | sys : <module 'sys' (built-in)> builtins : <module 'builtins' (built-in)> _frozen_importlib : <module '_frozen_importlib' (frozen)> _imp : <module '_imp' (built-in)> _thread : <module '_thread' (built-in)> |
L'ordre et le contenu exacts peuvent varier selon l'environnement. Dans les programmes courants, sys.modules est surtout utilisé pour inspecter les modules chargés plutôt que pour modifier directement le fonctionnement du système d'importation.
10. À retenir !
sys.modules est un dictionnaire utilisé par le système d'importation de Python pour conserver les modules déjà chargés dans le processus courant.
- sys.modules est un objet de type dict.
- Ses clés correspondent aux noms des modules chargés.
- Ses valeurs correspondent aux objets modules associés.
- "math" in sys.modules permet de vérifier si le nom du module math est présent.
- sys.modules["math"] permet de récupérer l'objet module correspondant lorsqu'il existe.
- len(sys.modules) permet de connaître le nombre d'entrées actuellement enregistrées.
- Un module importé peut lui-même provoquer le chargement d'autres modules.
- Python consulte sys.modules dans son mécanisme d'importation afin de réutiliser les modules déjà chargés.
- L'attribut __file__ permet de connaître le fichier associé à de nombreux modules, mais il n'existe pas pour tous les modules.
- Il est généralement préférable de ne pas modifier directement sys.modules sans comprendre précisément les conséquences sur le système d'importation.
Le programme suivant rassemble les principales opérations permettant d'inspecter un module chargé avec sys.modules.
1 2 3 4 5 6 7 8 9 10 11 | import sys import math print("math" in sys.modules) module = sys.modules["math"] print("Module :", module) print("Même objet :", module is math) print("Chemin :", getattr(module, "__file__", "Aucun fichier associé")) print("Nombre de modules :", len(sys.modules)) |
Sortie possible :
1 2 3 4 5 | True Module : <module 'math' from '...'> Même objet : True Chemin : C:\Python314\DLLs\math.pyd Nombre de modules : 54 |
Auteur : Younes Derfoufi
Lieu de travail : CRMEF OUJDA
Site Web : www.tresfacile.net
Chaine YouTube : https://www.youtube.com/user/InformatiquesFacile
Me contacter : https://www.tresfacile.net/me-contacter/
