Как импортировать модуль по полному пути?
https://stackoverflow.com/questions/67631
-
09-06-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianВопрос
Как загрузить модуль Python, учитывая его полный путь?Обратите внимание, что файл может находиться где угодно в файловой системе, поскольку это опция конфигурации.
Решение
Для Python 3.5+ используйте:
import importlib.util
spec = importlib.util.spec_from_file_location("module.name", "/path/to/file.py")
foo = importlib.util.module_from_spec(spec)
spec.loader.exec_module(foo)
foo.MyClass()
Для Python 3.3 и 3.4 используйте:
from importlib.machinery import SourceFileLoader
foo = SourceFileLoader("module.name", "/path/to/file.py").load_module()
foo.MyClass()
(Хотя это устарело в Python 3.4.)
Для Python 2 используйте:
import imp
foo = imp.load_source('module.name', '/path/to/file.py')
foo.MyClass()
Существуют эквивалентные удобные функции для скомпилированных файлов Python и DLL.
Смотрите также http://bugs.python.org/issue21436.
Другие советы
Преимущество добавления пути к sys.path (по сравнению с использованием imp) заключается в том, что это упрощает импорт более одного модуля из одного пакета.Например:
import sys
# the mock-0.3.1 dir contains testcase.py, testutils.py & mock.py
sys.path.append('/foo/bar/mock-0.3.1')
from testcase import TestCase
from testutils import RunTests
from mock import Mock, sentinel, patch
Вы также можете сделать что-то подобное и добавить каталог, в котором находится файл конфигурации, в путь загрузки Python, а затем просто выполнить обычный импорт, предполагая, что вы заранее знаете имя файла, в данном случае «config».
Грязно, но это работает.
configfile = '~/config.py'
import os
import sys
sys.path.append(os.path.dirname(os.path.expanduser(configfile)))
import config
Похоже, вы не хотите специально импортировать файл конфигурации (который имеет множество побочных эффектов и дополнительных сложностей), вы просто хотите запустить его и иметь доступ к полученному пространству имен.Стандартная библиотека предоставляет специально для этого API в виде runpy.run_path:
from runpy import run_path
settings = run_path("/path/to/file.py")
Этот интерфейс доступен в Python 2.7 и Python 3.2+.
Если ваш модуль верхнего уровня не является файлом, а упакован в каталог с __init__.py, то принятое решение почти работает, но не совсем.В Python 3.5+ необходим следующий код (обратите внимание на добавленную строку, начинающуюся с «sys.modules»):
MODULE_PATH = "/path/to/your/module/__init__.py"
MODULE_NAME = "mymodule"
import importlib
import sys
spec = importlib.util.spec_from_file_location(MODULE_NAME, MODULE_PATH)
module = importlib.util.module_from_spec(spec)
sys.modules[spec.name] = module
spec.loader.exec_module(module)
Без этой строки при выполнении exec_module он пытается связать относительный импорт в вашем верхнем уровне __init__.py с именем модуля верхнего уровня - в данном случае «mymodule».Но «mymodule» еще не загружен, поэтому вы получите сообщение об ошибке «SystemError:Родительский модуль «mymodule» не загружен, не может выполнить относительный импорт».Поэтому вам нужно привязать имя перед его загрузкой.Причиной этого является фундаментальный инвариант системы относительного импорта:«Инвариантным условием является то, что если у вас есть sys.modules['spam'] и sys.modules['spam.foo'] (как и после импорта выше), последний должен появиться как атрибут foo первого» как обсуждалось здесь.
Я придумал немного измененную версию Замечательный ответ @SebastianRittau (я думаю, для Python> 3.4), что позволит вам загрузить файл с любым расширением в качестве модуля, используя spec_from_loader вместо spec_from_file_location:
from importlib.util import spec_from_loader, module_from_spec
from importlib.machinery import SourceFileLoader
spec = spec_from_loader("module.name", SourceFileLoader("module.name", "/path/to/file.py"))
mod = module_from_spec(spec)
spec.loader.exec_module(mod)
Преимущество кодирования пути в явном виде SourceFileLoader в том, что техника не будет пытаться определить тип файла по расширению.Это означает, что вы можете загрузить что-то вроде .txt файл, используя этот метод, но вы не могли сделать это с помощью spec_from_file_location без указания загрузчика, потому что .txt не в importlib.machinery.SOURCE_SUFFIXES.
Вот код, который работает во всех версиях Python, от 2.7 до 3.5 и, возможно, даже в других.
config_file = "/tmp/config.py"
with open(config_file) as f:
code = compile(f.read(), config_file, 'exec')
exec(code, globals(), locals())
Я проверил это.Возможно, это некрасиво, но пока это единственный вариант, который работает во всех версиях.
Чтобы импортировать модуль, вам необходимо добавить его каталог в переменную среды временно или навсегда.
Временно
import sys
sys.path.append("/path/to/my/modules/")
import my_module
Постоянно
Добавив следующую строку в ваш .bashrc файл (в Linux) и выполните source ~/.bashrc в терминале:
export PYTHONPATH="${PYTHONPATH}:/path/to/my/modules/"
Кредит/Источник: Саарррр, еще один вопрос по обмену стеками
Вы имеете в виду загрузку или импорт?
Вы можете манипулировать списком sys.path, указывая путь к вашему модулю, а затем импортировать его.Например, учитывая модуль по адресу:
/foo/bar.py
Вы можете сделать:
import sys
sys.path[0:0] = ['/foo'] # puts the /foo directory at the start of your path
import bar
def import_file(full_path_to_module):
try:
import os
module_dir, module_file = os.path.split(full_path_to_module)
module_name, module_ext = os.path.splitext(module_file)
save_cwd = os.getcwd()
os.chdir(module_dir)
module_obj = __import__(module_name)
module_obj.__file__ = full_path_to_module
globals()[module_name] = module_obj
os.chdir(save_cwd)
except:
raise ImportError
import_file('/home/somebody/somemodule.py')
Я верю, что ты можешь использовать imp.find_module() и imp.load_module() для загрузки указанного модуля.Вам нужно будет отделить имя модуля от пути, т.е.если ты хочешь загрузить /home/mypath/mymodule.py вам нужно будет сделать:
imp.find_module('mymodule', '/home/mypath/')
...но это должно помочь выполнить работу.
Это должно сработать
path = os.path.join('./path/to/folder/with/py/files', '*.py')
for infile in glob.glob(path):
basename = os.path.basename(infile)
basename_without_extension = basename[:-3]
# http://docs.python.org/library/imp.html?highlight=imp#module-imp
imp.load_source(basename_without_extension, infile)
Вы можете использовать pkgutil модуль (в частности, walk_packages метод), чтобы получить список пакетов в текущем каталоге.Отсюда тривиально использовать importlib оборудование для импорта нужных модулей:
import pkgutil
import importlib
packages = pkgutil.walk_packages(path='.')
for importer, name, is_package in packages:
mod = importlib.import_module(name)
# do whatever you want with module now, it's been imported!
Эта область Python 3.4 кажется чрезвычайно сложной для понимания!Однако, немного потрудившись и используя для начала код Криса Кэллоуэя, мне удалось заставить что-то работать.Вот основная функция.
def import_module_from_file(full_path_to_module):
"""
Import a module given the full path/filename of the .py file
Python 3.4
"""
module = None
try:
# Get module name and path from full path
module_dir, module_file = os.path.split(full_path_to_module)
module_name, module_ext = os.path.splitext(module_file)
# Get module "spec" from filename
spec = importlib.util.spec_from_file_location(module_name,full_path_to_module)
module = spec.loader.load_module()
except Exception as ec:
# Simple error printing
# Insert "sophisticated" stuff here
print(ec)
finally:
return module
Похоже, здесь используются неустаревшие модули из Python 3.4.Я не претендую на понимание почему, но, похоже, это работает изнутри программы.Я обнаружил, что решение Криса работает в командной строке, но не изнутри программы.
Я не говорю, что так лучше, но для полноты картины хотел предложить exec функция, доступная как в Python 2, так и в 3.exec позволяет выполнять произвольный код либо в глобальной области, либо во внутренней области, предоставленной в виде словаря.
Например, если у вас есть модуль, хранящийся в "/path/to/module"с функцией foo(), вы можете запустить его, выполнив следующие действия:
module = dict()
with open("/path/to/module") as f:
exec(f.read(), module)
module['foo']()
Это делает более очевидным, что вы загружаете код динамически, и дает вам некоторые дополнительные возможности, такие как возможность предоставлять собственные встроенные функции.
И если для вас важен доступ через атрибуты, а не ключи, вы можете создать собственный класс dict для глобальных переменных, который обеспечивает такой доступ, например:
class MyModuleClass(dict):
def __getattr__(self, name):
return self.__getitem__(name)
Чтобы импортировать модуль из файла с заданным именем, вы можете временно расширить путь и восстановить системный путь в блоке Final. ссылка:
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
Создайте модуль Python test.py
import sys
sys.path.append("<project-path>/lib/")
from tes1 import Client1
from tes2 import Client2
import tes3
Создайте модуль Python test_check.py.
from test import Client1
from test import Client2
from test import test3
Мы можем импортировать импортированный модуль из модуля.
Я сделал пакет, который использует imp для тебя.Я называю это import_file и вот как он используется:
>>>from import_file import import_file
>>>mylib = import_file('c:\\mylib.py')
>>>another = import_file('relative_subdir/another.py')
Вы можете получить его по адресу:
http://pypi.python.org/pypi/import_file
или в
Импортируйте модули пакета во время выполнения (рецепт Python)
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)
В Linux добавление символической ссылки в каталог, где находится ваш скрипт Python, работает.
то есть:
ln -s /absolute/path/to/module/module.py /absolute/path/to/script/module.py
питон создаст /absolute/path/to/script/module.pyc и обновит его, если вы измените содержимое /absolute/path/to/module/module.py
затем включите следующее в mypythonscript.py
from module import *
довольно простой способ:предположим, вы хотите импортировать файл с относительным путем ../../MyLibs/pyfunc.py
libPath = '../../MyLibs'
import sys
if not libPath in sys.path: sys.path.append(libPath)
import pyfunc as pf
Но если вы сделаете это без охраны, вы, наконец, сможете получить очень длинный путь.
Простое решение с использованием importlib вместо imp пакет (протестирован для Python 2.7, хотя он должен работать и для Python 3):
import importlib
dirname, basename = os.path.split(pyfilepath) # pyfilepath: '/my/path/mymodule.py'
sys.path.append(dirname) # only directories should be added to PYTHONPATH
module_name = os.path.splitext(basename)[0] # '/my/path/mymodule.py' --> 'mymodule'
module = importlib.import_module(module_name) # name space of defined module (otherwise we would literally look for "module_name")
Теперь вы можете напрямую использовать пространство имен импортированного модуля, например:
a = module.myvar
b = module.myfunc(a)
Преимущество этого решения в том, что нам даже не нужно знать фактическое имя модуля, который мы хотим импортировать., чтобы использовать его в нашем коде.Это полезно, например.в случае, если путь к модулю является настраиваемым аргументом.
Добавляю это в список ответов, так как не смог найти ничего подходящего.Это позволит импортировать скомпилированные (pyd) модули Python в версии 3.4:
import sys
import importlib.machinery
def load_module(name, filename):
# If the Loader finds the module name in this list it will use
# module_name.__file__ instead so we need to delete it here
if name in sys.modules:
del sys.modules[name]
loader = importlib.machinery.ExtensionFileLoader(name, filename)
module = loader.load_module()
locals()[name] = module
globals()[name] = module
load_module('something', r'C:\Path\To\something.pyd')
something.do_something()
Этот ответ является дополнением к ответу Себастьяна Риттау на комментарий:"Но что, если у вас нет имени модуля?" Это быстрый и грязный способ получить вероятное имя модуля Python с учетом имени файла - оно просто поднимается на дерево, пока не найдет каталог без __init__.py файл, а затем превращает его обратно в имя файла.Для Python 3.4+ (используется pathlib), что имеет смысл, поскольку люди Py2 могут использовать «imp» или другие способы относительного импорта:
import pathlib
def likely_python_module(filename):
'''
Given a filename or Path, return the "likely" python module name. That is, iterate
the parent directories until it doesn't contain an __init__.py file.
:rtype: str
'''
p = pathlib.Path(filename).resolve()
paths = []
if p.name != '__init__.py':
paths.append(p.stem)
while True:
p = p.parent
if not p:
break
if not p.is_dir():
break
inits = [f for f in p.iterdir() if f.name == '__init__.py']
if not inits:
break
paths.append(p.stem)
return '.'.join(reversed(paths))
Конечно, есть возможности для улучшения, и опционально __init__.py файлы могут потребовать других изменений, но если у вас есть __init__.py в общем, это помогает.
Думаю, лучше всего из официальной документации (29.1.imp — Доступ к внутренним функциям импорта):
import imp
import sys
def __import__(name, globals=None, locals=None, fromlist=None):
# Fast path: see if the module has already been imported.
try:
return sys.modules[name]
except KeyError:
pass
# If any of the following calls raises an exception,
# there's a problem we can't handle -- let the caller handle it.
fp, pathname, description = imp.find_module(name)
try:
return imp.load_module(name, fp, pathname, description)
finally:
# Since we may exit via an exception, close fp explicitly.
if fp:
fp.close()
