Voir le contenu d’un module de Python

Python fournit plusieurs méthodes différentes pour voir le contenu d’un module. La plus courante est la fonction dir() , qui renvoie les att...

Python fournit plusieurs méthodes différentes pour voir le contenu d’un module. La plus courante est la fonction dir(), qui renvoie les attributs fournis par le module.

Si vous revenez à ce code, la liste contient bien d’autres entrées que nos fonctions SayHello() et SayGoodbye().

>>> import os
>>> os.chdir('D:\\Python\\Code\\Nuls\\Chapitre10')
>>> import MyLibrary
>>> dir(MyLibrary)
['SayGoodbye', 'SayHello', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__']

Ces attributs sont automatiquement générés par Python et ils servent à effectuer certaines tâches, ou à contenir certaines informations :

• __builtins__ : Contient une liste de tous les attributs intégrés qui sont accessibles dans le module. Ce sont ces attributs qui sont automatiquement ajoutés par Python.
• __cached__ : Vous indique le nom et l’emplacement du fichier mis en cache lorsque vous importez le module. Ce chemin d’accès est défini de façon relative par rapport au dossier courant de Python.
• __doc__ : Affiche une information d’aide sur le module, du moins si celle-ci a été rédigée. Par exemple, si vous tapez os.__doc__ et que vous appuyez sur Entrée, Python va afficher l’aide associée à la bibliothèque os.

  >>> os.__doc__
  "OS routines for NT or Posix depending on what system we're on.\n\nThis exports:\n  - all functions from posix or nt, e.g. unlink, stat, etc.\n  - os.path is either posixpath or ntpath\n  - os.name is either 'posix' or 'nt'\n  - os.curdir is a string representing the current directory (always '.')\n  - os.pardir is a string representing the parent directory (always '..')\n  - os.sep is the (or a most common) pathname separator ('/' or '\\\\')\n  - os.extsep is the extension separator (always '.')\n  - os.altsep is the alternate pathname separator (None or '/')\n  - os.pathsep is the component separator used in $PATH etc\n  - os.linesep is the line separator in text files ('\\r' or '\\n' or '\\r\\n')\n  - os.defpath is the default search path for executables\n  - os.devnull is the file path of the null device ('/dev/null', etc.)\n\nPrograms that import and use 'os' stand a better chance of being\nportable between different platforms.  Of course, they must then\nonly use functions that are defined by all platforms (e.g., unlink\nand opendir), and leave all pathname manipulation to os.path\n(e.g., split and join).\n"

• __file__ : Vous indique le nom et l’emplacement du module. Le chemin d’accès est défini relativement au dossier courant de Python.
• __initializing__ : Détermine si le module est en cours d’initialisation. Normalement, cet attribut renvoie la valeur False, puisque le module devrait déjà avoir terminé son initialisation à ce moment. Cet attribut peut cependant être utile si vous avez besoin d’attendre qu’un module ait terminé son chargement avant d’importer un autre module dépendant du premier.
• __loader__ : Affiche des informations sur le chargement du module. Vous ne devriez pas avoir à utiliser cet attribut.
• __name__ : Rappelle simplement le nom du module.
• __package__ : Sert uniquement au système d’importation pour faciliter le chargement et la gestion des modules. Vous n’avez pas à vous en soucier.

Plongez au cœur des modules pour mieux comprendre ce que vous utilisez dans Python.

>>> import os
>>> os.chdir('D:\\Python\\Code\\Nuls\\Chapitre10')
>>> import MyLibrary
>>> dir(MyLibrary)
['SayGoodbye', 'SayHello', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__']
>>> dir(MyLibrary.SayHello)
['__annotations__', '__builtins__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']

En fait, vous pouvez même plonger encore plus profondément dans la liste des attributs. Tapez dir(MyLibrary.SayHello) et appuyez sur Entrée. Vous voyez la sortie illustrée sur la Figure.

Certaines de ces entrées, comme __name__, apparaissent aussi dans le listing du module. Cependant, certaines autres entrées peuvent attirer votre curiosité. Par exemple, vous voudriez savoir à quoi correspond __sizeof__. Pour cela, tapez help(__sizeof__) et appuyez sur Entrée. Vous obtenez une information d’aide très sommaire, mais utile.

>>> help(__sizeof__)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name '__sizeof__' is not defined

>>> help(__doc__)
Help on NoneType object:

class NoneType(object)
 |  Methods defined here:
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.

Vous pouvez essayer d’obtenir de l’aide sur un certain attribut.

Python ne va pas vous manger si vous essayez l’attribut. Même si le Shell rencontre des problèmes, vous pouvez toujours ouvrir une autre fenêtre. Une autre manière de rechercher des informations sur un modèle consiste donc à tester simplement les attributs. Si vous tapez par exemple MyLibrary. SayHello.__sizeof__() et que vous appuyez sur Entrée, vous allez voir s’afficher la taille de la fonction SayHello() en octets, comme l’illustre le code.

>>> MyLibrary. SayHello.__sizeof__()
128

Contrairement à d’autres langages, Python rend public le code source de ses propres bibliothèques. Par exemple, si vous ouvrez le dossier \Python310\Lib, vous y trouverez toute une série de fichiers.py que vous pouvez ouvrir dans IDLE sans aucun problème. Essayez par exemple d’ouvrir la bibliothèque os.py déjà utilisée à plusieurs reprises dans ce chapitre. Vous allez voir s’afficher le contenu illustré sur la Figure.

Utiliser les attributs vous aide à mieux comprendre leur rôle et leur fonctionnement.

Voir directement le contenu d’une bibliothèque peut vous aider à découvrir de nouvelles techniques de programmation et à mieux comprendre le fonctionnement de Python. Plus vous y passerez de temps, et mieux vous serez à même de construire des applications intéressantes.

Contentez-vous de consulter le contenu des bibliothèques, et surtout n’y modifiez rien ! Si vous changiez accidentellement des morceaux de code, vous pourriez introduire des bogues dans votre application. Ces problèmes apparaîtraient uniquement sur votre propre système, et pas sur d’autres plates-formes. La prudence la plus extrême est donc de rigueur.