Wie kann ich den Pfad eines Moduls abrufen?

Ich möchte feststellen, ob sich das Modul geändert hat. Die Verwendung von inotify ist jetzt einfach. Sie müssen nur noch das Verzeichnis kennen, aus dem Sie Benachrichtigungen erhalten möchten.

Wie rufe ich den Pfad eines Moduls in Python ab?

import a_module
print(a_module.__file__)

Gibt Ihnen tatsächlich den Pfad zu der .pyc-Datei, die geladen wurde, zumindest unter Mac OS X. Sie können also Folgendes tun:

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

Sie können auch versuchen:

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

Um das Verzeichnis des Moduls abzurufen.

Es gibt ein inspectModul in Python.

Offizielle Dokumentation

Das Inspect-Modul bietet verschiedene nützliche Funktionen, um Informationen zu Live-Objekten wie Modulen, Klassen, Methoden, Funktionen, Tracebacks, Frame-Objekten und Code-Objekten abzurufen. Sie können beispielsweise den Inhalt einer Klasse untersuchen, den Quellcode einer Methode abrufen, die Argumentliste für eine Funktion extrahieren und formatieren oder alle Informationen abrufen, die Sie zum Anzeigen eines detaillierten Tracebacks benötigen.

Beispiel:

>>> 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'

Wie die anderen Antworten bereits sagten, ist der beste Weg, dies zu tun, mit __file__(unten noch einmal gezeigt). Es gibt jedoch eine wichtige Einschränkung, die __file__NICHT besteht, wenn Sie das Modul alleine ausführen (dh als__main__ ).

Angenommen, Sie haben zwei Dateien (beide befinden sich auf Ihrem PYTHONPATH):

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

und

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

Wenn Sie foo.py ausführen, erhalten Sie folgende Ausgabe:

/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

Wenn Sie jedoch versuchen, bar.py alleine auszuführen, erhalten Sie:

/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 

Hoffe das hilft. Diese Einschränkung hat mich beim Testen der anderen vorgestellten Lösungen viel Zeit und Verwirrung gekostet.

Ich werde auch versuchen, einige Variationen dieser Frage anzugehen:

1. Finden des Pfades des aufgerufenen Skripts
2. Suchen des Pfads des aktuell ausgeführten Skripts
3. Suchen des Verzeichnisses des aufgerufenen Skripts

(Einige dieser Fragen wurden auf SO gestellt, aber als Duplikate geschlossen und hier umgeleitet.)

Vorsichtsmaßnahmen bei der Verwendung __file__

Für ein Modul, das Sie importiert haben:

import something
something.__file__ 

gibt den absoluten Pfad des Moduls zurück. Angesichts des folgenden Skripts foo.py:

#foo.py
print '__file__', __file__

Wenn Sie es mit 'python foo.py' aufrufen, wird einfach 'foo.py' zurückgegeben. Wenn Sie einen Schebang hinzufügen:

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

und rufen Sie es mit ./foo.py auf, es wird './foo.py' zurückgeben. Rufen Sie es aus einem anderen Verzeichnis auf (z. B. foo.py in die Verzeichnisleiste einfügen) und rufen Sie dann eines der beiden auf

python bar/foo.py

oder einen Shebang hinzufügen und die Datei direkt ausführen:

bar/foo.py

gibt 'bar / foo.py' (den relativen Pfad) zurück.

Das Verzeichnis finden

Jetzt von dort aus das Verzeichnis zu bekommen, os.path.dirname(__file__)kann auch schwierig sein. Zumindest auf meinem System wird eine leere Zeichenfolge zurückgegeben, wenn Sie sie aus demselben Verzeichnis wie die Datei aufrufen. Ex.

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

wird ausgegeben:

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

Mit anderen Worten, es wird eine leere Zeichenfolge zurückgegeben, sodass dies nicht zuverlässig erscheint, wenn Sie es für die aktuelle Datei verwenden möchten (im Gegensatz zur Datei eines importierten Moduls). Um dies zu umgehen, können Sie es in einen Aufruf an abspath einwickeln:

# 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__))

welches etwas ausgibt wie:

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

Beachten Sie, dass abspath () Symlinks NICHT auflöst. Wenn Sie dies tun möchten, verwenden Sie stattdessen realpath (). Erstellen Sie beispielsweise einen Symlink file_import_testing_link, der auf file_import_testing.py verweist, mit dem folgenden Inhalt:

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

Beim Ausführen werden absolute Pfade wie folgt gedruckt:

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

file_import_testing_link -> file_import_testing.py

Mit inspizieren

@SummerBreeze erwähnt die Verwendung der Inspektion Modul.

Dies scheint für importierte Module gut zu funktionieren und ist recht prägnant:

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

gibt gehorsam den absoluten Pfad zurück. Um den Pfad des aktuell ausgeführten Skripts zu finden, habe ich jedoch keine Möglichkeit gefunden, es zu verwenden.

Ich verstehe nicht, warum niemand darüber spricht, aber für mich ist die einfachste Lösung die Verwendung von imp.find_module ("Modulname") (Dokumentation) hier ):

import imp
imp.find_module("os")

Es gibt ein Tupel mit dem Pfad an zweiter Stelle:

(<open file '/usr/lib/python2.7/os.py', mode 'U' at 0x7f44528d7540>,
'/usr/lib/python2.7/os.py',
('.py', 'U', 1))

Der Vorteil dieser Methode gegenüber der "Inspect" -Methode besteht darin, dass Sie das Modul nicht importieren müssen, damit es funktioniert, und Sie können eine Zeichenfolge für die Eingabe verwenden. Nützlich, wenn Sie beispielsweise Module überprüfen, die in einem anderen Skript aufgerufen wurden.

BEARBEITEN :

In Python3 importlib Modul tun:

Doc von importlib.util.find_spec :

Geben Sie die Spezifikation für das angegebene Modul zurück.

Zunächst wird sys.modules überprüft, ob das Modul bereits importiert wurde. Wenn ja, dann sys.modules [Name]. spez wird zurückgegeben. Wenn dies zufällig auf Keine gesetzt ist, wird ValueError ausgelöst. Befindet sich das Modul nicht in sys.modules, wird sys.meta_path nach einer geeigneten Spezifikation mit dem Wert 'path' durchsucht, der den Findern zugewiesen wurde. Keine wird zurückgegeben, wenn keine Spezifikation gefunden werden konnte.

Wenn der Name für das Submodul steht (einen Punkt enthält), wird das übergeordnete Modul automatisch importiert.

Die Argumente name und package funktionieren genauso wie importlib.import_module (). Mit anderen Worten, relative Modulnamen (mit führenden Punkten) funktionieren.

Das war trivial.

Jedes Modul hat eine __file__ Variable, die den relativen Pfad anzeigt, von dem aus Sie sich gerade befinden.

Daher ist es einfach, ein Verzeichnis für das Modul zu erhalten, um es zu benachrichtigen:

os.path.dirname(__file__)

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

import module
print module.__path__

Pakete unterstützen ein weiteres spezielles Attribut __path__. Dies wird als Liste initialisiert, die den Namen des Verzeichnisses enthält, in dem sich das Paket befindet__init__.py bevor der Code in dieser Datei ausgeführt wird. Diese Variable kann geändert werden. Dies wirkt sich auf zukünftige Suchvorgänge nach Modulen und Unterpaketen aus, die im Paket enthalten sind.

Diese Funktion wird zwar nicht oft benötigt, kann jedoch zum Erweitern der in einem Paket enthaltenen Module verwendet werden.

Quelle

Befehlszeilenprogramm

Sie können es an einem Befehlszeilenprogramm anpassen.

python-which <package name>

Erstellen /usr/local/bin/python-which

#!/usr/bin/env python

import importlib
import os
import sys

args = sys.argv[1:]
if len(args) > 0:
    module = importlib.import_module(args[0])
    print os.path.dirname(module.__file__)

Mach es ausführbar

sudo chmod +x /usr/local/bin/python-which

Daher habe ich ziemlich viel Zeit damit verbracht, dies mit py2exe zu versuchen. Das Problem bestand darin, den Basisordner des Skripts abzurufen, unabhängig davon, ob es als Python-Skript oder als ausführbare py2exe-Datei ausgeführt wurde. Damit es funktioniert, ob es aus dem aktuellen Ordner, einem anderen Ordner oder (dies war der schwierigste) aus dem Systempfad ausgeführt wurde.

Schließlich habe ich diesen Ansatz verwendet und sys.frozen als Indikator für die Ausführung in py2exe verwendet:

import os,sys
if hasattr(sys,'frozen'): # only when running in py2exe this exists
    base = sys.prefix
else: # otherwise this is a regular python script
    base = os.path.dirname(os.path.realpath(__file__))

Sie können Ihr Modul einfach importieren und dann auf seinen Namen klicken, um den vollständigen Pfad zu erhalten

>>> import os
>>> os
<module 'os' from 'C:\\Users\\Hassan Ashraf\\AppData\\Local\\Programs\\Python\\Python36-32\\lib\\os.py'>
>>>

Wenn Sie den Stammpfad des Pakets von einem seiner Module abrufen möchten, funktioniert Folgendes (getestet in Python 3.6):

from . import __path__ as ROOT_PATH
print(ROOT_PATH)

Der Hauptpfad __init__.pykann auch mit referenziert werden __file__.

Hoffe das hilft!

Wenn die einzige Einschränkung bei der Verwendung darin __file__besteht, dass das aktuelle relative Verzeichnis leer ist (dh wenn es als Skript aus demselben Verzeichnis ausgeführt wird, in dem sich das Skript befindet), lautet die einfache Lösung:

import os.path
mydir = os.path.dirname(__file__) or '.'
full  = os.path.abspath(mydir)
print __file__, mydir, full

Und das Ergebnis:

$ python teste.py 
teste.py . /home/user/work/teste

Der Trick ist or '.'nach dem dirname()Anruf. Es setzt das Verzeichnis als ., was aktuelles Verzeichnis bedeutet und ein gültiges Verzeichnis für jede pfadbezogene Funktion ist.

Daher ist die Verwendung abspath()nicht wirklich erforderlich. Wenn Sie es trotzdem verwenden, wird der Trick nicht benötigt: abspath()Akzeptiert leere Pfade und interpretiert es ordnungsgemäß als aktuelles Verzeichnis.

Ich möchte mit einem gemeinsamen Szenario (in Python 3) einen Beitrag leisten und einige Ansätze dafür untersuchen.

Die integrierte Funktion open () akzeptiert entweder den relativen oder den absoluten Pfad als erstes Argument. Der relative Pfad wird jedoch als relativ zum aktuellen Arbeitsverzeichnis behandelt. Es wird daher empfohlen, den absoluten Pfad an die Datei zu übergeben.

Wenn Sie eine Skriptdatei mit dem folgenden Code ausführen, kann nicht garantiert werden, dass die example.txtDatei in demselben Verzeichnis erstellt wird, in dem sich die Skriptdatei befindet:

with open('example.txt', 'w'):
    pass

Um diesen Code zu reparieren, müssen wir den Pfad zum Skript ermitteln und absolut machen. Um sicherzustellen, dass der Pfad absolut ist, verwenden wir einfach die Funktion os.path.realpath () . Um den Pfad zum Skript abzurufen, gibt es mehrere allgemeine Funktionen, die verschiedene Pfadergebnisse zurückgeben:

• os.getcwd()
• os.path.realpath('example.txt')
• sys.argv[0]
• __file__

Beide Funktionen os.getcwd () und os.path.realpath () geben Pfadergebnisse basierend auf dem aktuellen Arbeitsverzeichnis zurück . Im Allgemeinen nicht das, was wir wollen. Das erste Element der Liste sys.argv ist der Pfad des Stammskripts (des von Ihnen ausgeführten Skripts), unabhängig davon, ob Sie die Liste im Stammskript selbst oder in einem seiner Module aufrufen. In einigen Situationen kann dies hilfreich sein. Die Variable __file__ enthält den Pfad des Moduls, von dem aus sie aufgerufen wurde.

Der folgende Code erstellt eine Datei korrekt example.txtin demselben Verzeichnis, in dem sich das Skript befindet:

filedir = os.path.dirname(os.path.realpath(__file__))
filepath = os.path.join(filedir, 'example.txt')

with open(filepath, 'w'):
    pass

Wenn Sie den absoluten Pfad aus Ihrem Skript kennen möchten, können Sie das Path- Objekt verwenden:

from pathlib import Path

print(Path().absolute())
print(Path().resolve('.'))
print(Path().cwd())

cwd () -Methode

Gibt ein neues Pfadobjekt zurück, das das aktuelle Verzeichnis darstellt (wie von os.getcwd () zurückgegeben).

Lösung () Methode

Machen Sie den Pfad absolut und lösen Sie alle Symlinks auf. Ein neues Pfadobjekt wird zurückgegeben:

Innerhalb der Module eines Python-Pakets musste ich auf eine Datei verweisen, die sich im selben Verzeichnis wie das Paket befand. Ex.

some_dir/
  maincli.py
  top_package/
    __init__.py
    level_one_a/
      __init__.py
      my_lib_a.py
      level_two/
        __init__.py
        hello_world.py
    level_one_b/
      __init__.py
      my_lib_b.py

Also musste ich oben maincli.py aus dem Modul my_lib_a.py aufrufen, da ich wusste, dass sich top_package und maincli.py im selben Verzeichnis befinden. So erhalte ich den Pfad zu maincli.py:

import sys
import os
import imp


class ConfigurationException(Exception):
    pass


# inside of my_lib_a.py
def get_maincli_path():
    maincli_path = os.path.abspath(imp.find_module('maincli')[1])
    # top_package = __package__.split('.')[0]
    # mod = sys.modules.get(top_package)
    # modfile = mod.__file__
    # pkg_in_dir = os.path.dirname(os.path.dirname(os.path.abspath(modfile)))
    # maincli_path = os.path.join(pkg_in_dir, 'maincli.py')

    if not os.path.exists(maincli_path):
        err_msg = 'This script expects that "maincli.py" be installed to the '\
        'same directory: "{0}"'.format(maincli_path)
        raise ConfigurationException(err_msg)

    return maincli_path

Basierend auf der Veröffentlichung von PlasmaBinturong habe ich den Code geändert.

Wenn Sie dies dynamisch in einem "Programm" tun möchten, versuchen Sie diesen Code:
Mein Punkt ist, dass Sie möglicherweise nicht den genauen Namen des Moduls kennen, um es "fest zu codieren". Es kann aus einer Liste ausgewählt werden oder wird derzeit nicht ausgeführt, um __file__ zu verwenden.

(Ich weiß, es wird in Python 3 nicht funktionieren)

global modpath
modname = 'os' #This can be any module name on the fly
#Create a file called "modname.py"
f=open("modname.py","w")
f.write("import "+modname+"\n")
f.write("modpath = "+modname+"\n")
f.close()
#Call the file with execfile()
execfile('modname.py')
print modpath
<module 'os' from 'C:\Python27\lib\os.pyc'>

Ich habe versucht, das "globale" Problem zu beseitigen, aber Fälle gefunden, in denen es nicht funktioniert hat. Ich denke, "execfile ()" kann in Python 3 emuliert werden. Da dies in einem Programm enthalten ist, kann es leicht in eine Methode oder ein Modul für eingefügt werden Wiederverwendung.

Wenn Sie es mit pip installiert haben, funktioniert "pip show" hervorragend ('Location')

$ pip show detektron2

Name: detectron2
Version: 0.1
Summary: Detectron2 is FAIR next-generation research platform for object detection and segmentation.
Home-page: https://github.com/facebookresearch/detectron2
Author: FAIR
Author-email: None
License: UNKNOWN
Location: /home/ubuntu/anaconda3/envs/pytorch_p36/lib/python3.6/site-packages
Requires: yacs, tabulate, tqdm, pydot, tensorboard, Pillow, termcolor, future, cloudpickle, matplotlib, fvcore

Hier ist ein kurzes Bash-Skript für den Fall, dass es für irgendjemanden nützlich ist. Ich möchte nur in der Lage sein, eine Umgebungsvariable festzulegen, damit ich pushdauf den Code zugreifen kann .

#!/bin/bash
module=${1:?"I need a module name"}

python << EOI
import $module
import os
print os.path.dirname($module.__file__)
EOI

Shell-Beispiel:

[root@sri-4625-0004 ~]# export LXML=$(get_python_path.sh lxml)
[root@sri-4625-0004 ~]# echo $LXML
/usr/lib64/python2.7/site-packages/lxml
[root@sri-4625-0004 ~]#