Comment récupérer le chemin d'accès d'un module ?

Question

Je veux détecter si le module a changé. Maintenant, l'utilisation de inotify est simple, vous devez juste connaître le répertoire à partir duquel vous voulez obtenir des notifications.

Comment récupérer le chemin d'accès d'un module en python ?

Answer 1

import a_module
print(a_module.__file__)

vous donnera en fait le chemin d'accès au fichier .pyc qui a été chargé, du moins sous Mac OS X. Donc je suppose que vous pouvez le faire :

import os
path = os.path.abspath(a_module.__file__)

Vous pouvez également essayer :

path = os.path.dirname(a_module.__file__)

Pour obtenir le répertoire du module.

Answer 2

Il y a inspect en python.

Documentation officielle

Le module inspect fournit plusieurs fonctions utiles pour aider à obtenir informations sur des objets vivants tels que des modules, des classes, des méthodes, les fonctions, les traces, les objets frame et les objets code. Par exemple, il peut vous aider à examiner le contenu d'une classe, à récupérer le code source source d'une méthode, extraire et formater la liste des arguments d'une fonction, ou obtenir toutes les informations dont vous avez besoin pour afficher un traceback détaillé.

Exemple :

>>> import os
>>> import inspect
>>> inspect.getfile(os)
'/usr/lib64/python2.7/os.pyc'
>>> inspect.getfile(inspect)
'/usr/lib64/python2.7/inspect.pyc'
>>> os.path.dirname(inspect.getfile(inspect))
'/usr/lib64/python2.7'

Answer 3

Comme les autres réponses l'ont dit, le meilleur moyen de le faire est avec __file__ (démontrée à nouveau ci-dessous). Cependant, il y a une mise en garde importante, à savoir que __file__ n'existe PAS si vous exécutez le module seul (c'est-à-dire en tant que __main__ ).

Par exemple, disons que vous avez deux fichiers (qui se trouvent tous deux dans votre PYTHONPATH) :

#/path1/foo.py
import bar
print(bar.__file__)

et

#/path2/bar.py
import os
print(os.getcwd())
print(__file__)

L'exécution de foo.py donnera la sortie :

/path1        # "import bar" causes the line "print(os.getcwd())" to run
/path2/bar.py # then "print(__file__)" runs
/path2/bar.py # then the import statement finishes and "print(bar.__file__)" runs

CEPENDANT, si vous essayez d'exécuter bar.py tout seul, vous obtiendrez :

/path2                              # "print(os.getcwd())" still works fine
Traceback (most recent call last):  # but __file__ doesn't exist if bar.py is running as main
  File "/path2/bar.py", line 3, in <module>
    print(__file__)
NameError: name '__file__' is not defined 

J'espère que cela vous aidera. Cette mise en garde m'a coûté beaucoup de temps et de confusion alors que je testais les autres solutions présentées.

Answer 4

Je vais essayer de m'attaquer à quelques variations de cette question également :

1. trouver le chemin du script appelé
2. Trouver le chemin du script en cours d'exécution.
3. trouver le répertoire du script appelé

(Certaines de ces questions ont été posées sur SO, mais ont été fermées en tant que doublons et redirigées ici).

Mises en garde concernant l'utilisation __file__

Pour un module que vous avez importé :

import something
something.__file__ 

retournera le absolu chemin du module. Cependant, étant donné le script suivant foo.py :

#foo.py
print '__file__', __file__

L'appeler avec 'python foo.py' retournera simplement 'foo.py'. Si vous ajoutez un shebang :

#!/usr/bin/python 
#foo.py
print '__file__', __file__

et l'appeler en utilisant ./foo.py, il retournera './foo.py'. Si vous l'appelez à partir d'un autre répertoire (par exemple, mettez foo.py dans le répertoire bar), puis appelez soit

python bar/foo.py

ou ajouter un shebang et exécuter le fichier directement :

bar/foo.py

renverra 'bar/foo.py' (l'option relatif chemin).

Trouver le répertoire

Maintenant, il faut partir de là pour obtenir le répertoire, os.path.dirname(__file__) peut également s'avérer délicat. Au moins sur mon système, il retourne une chaîne vide si vous l'appelez depuis le même répertoire que le fichier. ex.

# foo.py
import os
print '__file__ is:', __file__
print 'os.path.dirname(__file__) is:', os.path.dirname(__file__)

produira un résultat :

__file__ is: foo.py
os.path.dirname(__file__) is: 

En d'autres termes, il renvoie une chaîne vide, ce qui ne semble pas fiable si vous voulez l'utiliser pour l'actuel fichier (par opposition à la fichier d'un module importé). Pour contourner ce problème, vous pouvez l'envelopper dans un appel à abspath :

# foo.py
import os
print 'os.path.abspath(__file__) is:', os.path.abspath(__file__)
print 'os.path.dirname(os.path.abspath(__file__)) is:', os.path.dirname(os.path.abspath(__file__))

ce qui donne quelque chose comme :

os.path.abspath(__file__) is: /home/user/bar/foo.py
os.path.dirname(os.path.abspath(__file__)) is: /home/user/bar

Notez que abspath() ne résout PAS les liens symboliques. Si vous voulez le faire, utilisez realpath() à la place. Par exemple, créer un lien symbolique file_import_testing_link pointant vers file_import_testing.py, avec le contenu suivant :

import os
print 'abspath(__file__)',os.path.abspath(__file__)
print 'realpath(__file__)',os.path.realpath(__file__)

L'exécution imprimera les chemins absolus comme suit :

abspath(__file__) /home/user/file_test_link
realpath(__file__) /home/user/file_test.py

fichier_import_testing_lien -> fichier_import_testing.py

Utilisation de l'inspection

@SummerBreeze mentionne l'utilisation des inspecter module.

Cela semble bien fonctionner, et est assez concis, pour les modules importés :

import os
import inspect
print 'inspect.getfile(os) is:', inspect.getfile(os)

renvoie docilement le chemin absolu. Pour trouver le chemin du script en cours d'exécution :

inspect.getfile(inspect.currentframe())

(merci @jbochi)

Answer 5

import os
path = os.path.abspath(__file__)
dir_path = os.path.dirname(path)