Wie importiere ich ein Modul unter Angabe des vollständigen Pfads?

Question

Wie lade ich ein Python-Modul mit seinem vollständigen Pfad?

Beachten Sie, dass die Datei überall im Dateisystem liegen kann.

Answer 1

Ich habe ein Paket erstellt, das Folgendes verwendet imp für Sie. Ich nenne es import_file und so wird es verwendet:

>>>from import_file import import_file
>>>mylib = import_file('c:\\mylib.py')
>>>another = import_file('relative_subdir/another.py')

Sie erhalten es unter:

http://pypi.python.org/pypi/import_file

oder bei

http://code.google.com/p/import-file/

Answer 2

Um ein Modul von einem bestimmten Dateinamen zu importieren, können Sie den Pfad vorübergehend erweitern und den Systempfad im abschließenden Block wiederherstellen Hinweis:

filename = "directory/module.py"

directory, module_name = os.path.split(filename)
module_name = os.path.splitext(module_name)[0]

path = list(sys.path)
sys.path.insert(0, directory)
try:
    module = __import__(module_name)
finally:
    sys.path[:] = path # restore

Answer 3

Ich sage nicht, dass es besser ist, aber der Vollständigkeit halber wollte ich die exec Funktion, die sowohl in Python 2 als auch in Python 3 verfügbar ist.

exec erlaubt es Ihnen, beliebigen Code entweder im globalen Bereich oder in einem internen Bereich, der als Wörterbuch bereitgestellt wird, auszuführen.

Wenn Sie zum Beispiel ein Modul in "/path/to/module " mit der Funktion foo() können Sie ihn wie folgt ausführen:

module = dict()
with open("/path/to/module") as f:
    exec(f.read(), module)
module['foo']()

Dadurch wird es etwas deutlicher, dass Sie Code dynamisch laden, und Sie erhalten einige zusätzliche Möglichkeiten, wie z. B. die Möglichkeit, benutzerdefinierte Buildins bereitzustellen.

Und wenn Ihnen der Zugriff über Attribute anstelle von Schlüsseln wichtig ist, können Sie eine eigene dict-Klasse für die Globals entwerfen, die einen solchen Zugriff ermöglicht, z. B.:

class MyModuleClass(dict):
    def __getattr__(self, name):
        return self.__getitem__(name)

Answer 4

Paketmodule zur Laufzeit importieren (Python-Rezept)

http://code.activestate.com/recipes/223972/

###################
##                #
## classloader.py #
##                #
###################

import sys, types

def _get_mod(modulePath):
    try:
        aMod = sys.modules[modulePath]
        if not isinstance(aMod, types.ModuleType):
            raise KeyError
    except KeyError:
        # The last [''] is very important!
        aMod = __import__(modulePath, globals(), locals(), [''])
        sys.modules[modulePath] = aMod
    return aMod

def _get_func(fullFuncName):
    """Retrieve a function object from a full dotted-package name."""

    # Parse out the path, module, and function
    lastDot = fullFuncName.rfind(u".")
    funcName = fullFuncName[lastDot + 1:]
    modPath = fullFuncName[:lastDot]

    aMod = _get_mod(modPath)
    aFunc = getattr(aMod, funcName)

    # Assert that the function is a *callable* attribute.
    assert callable(aFunc), u"%s is not callable." % fullFuncName

    # Return a reference to the function itself,
    # not the results of the function.
    return aFunc

def _get_class(fullClassName, parentClass=None):
    """Load a module and retrieve a class (NOT an instance).

    If the parentClass is supplied, className must be of parentClass
    or a subclass of parentClass (or None is returned).
    """
    aClass = _get_func(fullClassName)

    # Assert that the class is a subclass of parentClass.
    if parentClass is not None:
        if not issubclass(aClass, parentClass):
            raise TypeError(u"%s is not a subclass of %s" %
                            (fullClassName, parentClass))

    # Return a reference to the class itself, not an instantiated object.
    return aClass

######################
##       Usage      ##
######################

class StorageManager: pass
class StorageManagerMySQL(StorageManager): pass

def storage_object(aFullClassName, allOptions={}):
    aStoreClass = _get_class(aFullClassName, StorageManager)
    return aStoreClass(allOptions)

Answer 5

Ich habe meine eigene globale und portable Importfunktion geschrieben, die auf importlib Modul, für:

• In der Lage sein, beide Module als Submodule zu importieren und den Inhalt eines Moduls in ein übergeordnetes Modul zu importieren (oder in ein globales, wenn es kein übergeordnetes Modul hat).
• In der Lage sein, Module mit einem Punkt im Dateinamen zu importieren.
• Sie müssen in der Lage sein, Module mit beliebigen Erweiterungen zu importieren.
• Die Möglichkeit, einen eigenständigen Namen für ein Submodul zu verwenden, anstatt eines Dateinamens ohne Erweiterung, der standardmäßig verwendet wird.
• Die Importreihenfolge kann auf der Grundlage des zuvor importierten Moduls festgelegt werden, anstatt abhängig von sys.path oder auf einem wie auch immer gearteten Suchpfadspeicher.

Die Verzeichnisstruktur der Beispiele:

<root>
 |
 +- test.py
 |
 +- testlib.py
 |
 +- /std1
 |   |
 |   +- testlib.std1.py
 |
 +- /std2
 |   |
 |   +- testlib.std2.py
 |
 +- /std3
     |
     +- testlib.std3.py

Eingliederungsabhängigkeit und Ordnung:

test.py
  -> testlib.py
    -> testlib.std1.py
      -> testlib.std2.py
    -> testlib.std3.py

Umsetzung:

Letzte Änderungen speichern: https://sourceforge.net/p/tacklelib/tacklelib/HEAD/tree/trunk/python/tacklelib/tacklelib.py

test.py :

import os, sys, inspect, copy

SOURCE_FILE = os.path.abspath(inspect.getsourcefile(lambda:0)).replace('\\','/')
SOURCE_DIR = os.path.dirname(SOURCE_FILE)

print("test::SOURCE_FILE: ", SOURCE_FILE)

# portable import to the global space
sys.path.append(TACKLELIB_ROOT) # TACKLELIB_ROOT - path to the library directory
import tacklelib as tkl

tkl.tkl_init(tkl)

# cleanup
del tkl # must be instead of `tkl = None`, otherwise the variable would be still persist
sys.path.pop()

tkl_import_module(SOURCE_DIR, 'testlib.py')

print(globals().keys())

testlib.base_test()
testlib.testlib_std1.std1_test()
testlib.testlib_std1.testlib_std2.std2_test()
#testlib.testlib.std3.std3_test()                             # does not reachable directly ...
getattr(globals()['testlib'], 'testlib.std3').std3_test()     # ... but reachable through the `globals` + `getattr`

tkl_import_module(SOURCE_DIR, 'testlib.py', '.')

print(globals().keys())

base_test()
testlib_std1.std1_test()
testlib_std1.testlib_std2.std2_test()
#testlib.std3.std3_test()                                     # does not reachable directly ...
globals()['testlib.std3'].std3_test()                         # ... but reachable through the `globals` + `getattr`

testlib.py :

# optional for 3.4.x and higher
#import os, inspect
#
#SOURCE_FILE = os.path.abspath(inspect.getsourcefile(lambda:0)).replace('\\','/')
#SOURCE_DIR = os.path.dirname(SOURCE_FILE)

print("1 testlib::SOURCE_FILE: ", SOURCE_FILE)

tkl_import_module(SOURCE_DIR + '/std1', 'testlib.std1.py', 'testlib_std1')

# SOURCE_DIR is restored here
print("2 testlib::SOURCE_FILE: ", SOURCE_FILE)

tkl_import_module(SOURCE_DIR + '/std3', 'testlib.std3.py')

print("3 testlib::SOURCE_FILE: ", SOURCE_FILE)

def base_test():
  print('base_test')

testlib.std1.py :

# optional for 3.4.x and higher
#import os, inspect
#
#SOURCE_FILE = os.path.abspath(inspect.getsourcefile(lambda:0)).replace('\\','/')
#SOURCE_DIR = os.path.dirname(SOURCE_FILE)

print("testlib.std1::SOURCE_FILE: ", SOURCE_FILE)

tkl_import_module(SOURCE_DIR + '/../std2', 'testlib.std2.py', 'testlib_std2')

def std1_test():
  print('std1_test')

testlib.std2.py :

# optional for 3.4.x and higher
#import os, inspect
#
#SOURCE_FILE = os.path.abspath(inspect.getsourcefile(lambda:0)).replace('\\','/')
#SOURCE_DIR = os.path.dirname(SOURCE_FILE)

print("testlib.std2::SOURCE_FILE: ", SOURCE_FILE)

def std2_test():
  print('std2_test')

testlib.std3.py :

# optional for 3.4.x and higher
#import os, inspect
#
#SOURCE_FILE = os.path.abspath(inspect.getsourcefile(lambda:0)).replace('\\','/')
#SOURCE_DIR = os.path.dirname(SOURCE_FILE)

print("testlib.std3::SOURCE_FILE: ", SOURCE_FILE)

def std3_test():
  print('std3_test')

Ausgabe ( 3.7.4 ):

test::SOURCE_FILE:  <root>/test01/test.py
import : <root>/test01/testlib.py as testlib -> []
1 testlib::SOURCE_FILE:  <root>/test01/testlib.py
import : <root>/test01/std1/testlib.std1.py as testlib_std1 -> ['testlib']
import : <root>/test01/std1/../std2/testlib.std2.py as testlib_std2 -> ['testlib', 'testlib_std1']
testlib.std2::SOURCE_FILE:  <root>/test01/std1/../std2/testlib.std2.py
2 testlib::SOURCE_FILE:  <root>/test01/testlib.py
import : <root>/test01/std3/testlib.std3.py as testlib.std3 -> ['testlib']
testlib.std3::SOURCE_FILE:  <root>/test01/std3/testlib.std3.py
3 testlib::SOURCE_FILE:  <root>/test01/testlib.py
dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', '__file__', '__cached__', 'os', 'sys', 'inspect', 'copy', 'SOURCE_FILE', 'SOURCE_DIR', 'TackleGlobalImportModuleState', 'tkl_membercopy', 'tkl_merge_module', 'tkl_get_parent_imported_module_state', 'tkl_declare_global', 'tkl_import_module', 'TackleSourceModuleState', 'tkl_source_module', 'TackleLocalImportModuleState', 'testlib'])
base_test
std1_test
std2_test
std3_test
import : <root>/test01/testlib.py as . -> []
1 testlib::SOURCE_FILE:  <root>/test01/testlib.py
import : <root>/test01/std1/testlib.std1.py as testlib_std1 -> ['testlib']
import : <root>/test01/std1/../std2/testlib.std2.py as testlib_std2 -> ['testlib', 'testlib_std1']
testlib.std2::SOURCE_FILE:  <root>/test01/std1/../std2/testlib.std2.py
2 testlib::SOURCE_FILE:  <root>/test01/testlib.py
import : <root>/test01/std3/testlib.std3.py as testlib.std3 -> ['testlib']
testlib.std3::SOURCE_FILE:  <root>/test01/std3/testlib.std3.py
3 testlib::SOURCE_FILE:  <root>/test01/testlib.py
dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', '__file__', '__cached__', 'os', 'sys', 'inspect', 'copy', 'SOURCE_FILE', 'SOURCE_DIR', 'TackleGlobalImportModuleState', 'tkl_membercopy', 'tkl_merge_module', 'tkl_get_parent_imported_module_state', 'tkl_declare_global', 'tkl_import_module', 'TackleSourceModuleState', 'tkl_source_module', 'TackleLocalImportModuleState', 'testlib', 'testlib_std1', 'testlib.std3', 'base_test'])
base_test
std1_test
std2_test
std3_test

Geprüft in Python 3.7.4 , 3.2.5 , 2.7.16

Profis :

• Kann sowohl ein Modul als Submodul importieren als auch den Inhalt eines Moduls in ein übergeordnetes Modul importieren (oder in ein globales Modul, wenn es kein übergeordnetes Modul hat).
• Kann Module mit Punkten in einem Dateinamen importieren.
• Kann jedes Erweiterungsmodul von jedem Erweiterungsmodul importieren.
• Kann einen eigenständigen Namen für ein Submodul anstelle eines Dateinamens ohne Erweiterung verwenden, der standardmäßig verwendet wird (z. B, testlib.std.py als testlib , testlib.blabla.py als testlib_blabla und so weiter).
• Hängt nicht von einer sys.path oder auf einem wie auch immer gearteten Suchpfadspeicher.
• Erfordert nicht das Speichern/Wiederherstellen von globalen Variablen wie SOURCE_FILE y SOURCE_DIR zwischen Aufrufen von tkl_import_module .
• [für 3.4.x und höher] Kann die Modul-Namensräume in verschachtelten tkl_import_module Anrufe (z.B.: named->local->named o local->named->local und so weiter).
• [für 3.4.x und höher] Kann globale Variablen/Funktionen/Klassen von dort, wo sie deklariert werden, automatisch in alle untergeordneten Module exportieren, die durch die tkl_import_module (durch die tkl_declare_global Funktion).

Nachteile :

• [für 3.3.x und niedriger] Erforderlich für die Anmeldung tkl_import_module in allen Modulen mit Aufrufen zu tkl_import_module (Code-Verdoppelung)

Aktualisierung 1,2 (für 3.4.x und höher):

In Python 3.4 und höher können Sie das Erfordernis der Deklaration von tkl_import_module in jedem Modul durch Deklaration tkl_import_module in einem Modul der obersten Ebene und die Funktion würde sich selbst in alle untergeordneten Module in einem einzigen Aufruf injizieren (es ist eine Art von selbst entfalteter Import).

Aktualisierung 3 :

Hinzugefügte Funktion tkl_source_module als Analogon zur Bash source mit Unterstützung der Ausführungsüberwachung beim Import (implementiert durch die Modulzusammenführung anstelle des Imports).

Aktualisierung 4 :

Hinzugefügte Funktion tkl_declare_global um eine globale Modulvariable automatisch in alle untergeordneten Module zu exportieren, wenn eine globale Modulvariable nicht sichtbar ist, weil sie nicht zu einem untergeordneten Modul gehört.

Aktualisierung 5 :

Alle Funktionen sind in die Tacklelib-Bibliothek umgezogen, siehe den Link oben.