如何在给定完整路径的情况下导入模块？

我提出了一个稍微修改过的 @SebastianRittau's wonderful answer 版本（我认为是 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 中编码路径的优点是 machinery 不会尝试从扩展名中找出文件的类型。这意味着您可以使用此方法加载类似于 .txt 的文件，但如果不指定加载程序，您将无法使用 spec_from_file_location 执行此操作，因为 .txt 不在 importlib.machinery.SOURCE_SUFFIXES 中。

我已将基于此的实现和 @SamGrondahl's useful modification 放入我的实用程序库 haggis。该函数称为 haggis.load.load_module。它添加了一些巧妙的技巧，例如在加载模块命名空间时将变量注入模块命名空间的能力。

---

您可以使用 __import__ 和 chdir 执行此操作：

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 Exception as e:
        raise ImportError(e)
    return module_obj


import_file('/home/somebody/somemodule.py')

---

如果我们在同一个项目中有脚本，但在不同的目录下，我们可以通过以下方法解决这个问题。

在这种情况下，utils.py 在 src/main/util/

import sys
sys.path.append('./')

import src.main.util.utils
#or
from src.main.util.utils import json_converter # json_converter is example method

---

我相信你可以使用imp.find_module()和imp.load_module()来加载指定的模块。您需要将模块名称从路径中拆分出来，即如果您想加载 /home/mypath/mymodule.py，您需要执行以下操作：

imp.find_module('mymodule', '/home/mypath/')

...但这应该可以完成工作。

---

创建 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

我们可以从模块中导入导入的模块。

---

您可以使用 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!

---

有一个专门用于此的 package：

from thesmuggler import smuggle

# À la `import weapons`
weapons = smuggle('weapons.py')

# À la `from contraband import drugs, alcohol`
drugs, alcohol = smuggle('drugs', 'alcohol', source='contraband.py')

# À la `from contraband import drugs as dope, alcohol as booze`
dope, booze = smuggle('drugs', 'alcohol', source='contraband.py')

它在 Python 版本（Jython 和 PyPy 也是）中进行了测试，但根据项目的大小，它可能会有些过大。

---

Python 3.4 的这个领域似乎理解起来极其曲折！然而，在开始使用 Chris Calloway 的代码进行一些黑客攻击后，我设法得到了一些工作。这是基本功能。

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 中未弃用的模块。我不假装理解为什么，但它似乎在程序中起作用。我发现 Chris 的解决方案在命令行上有效，但在程序内部无效。

---

我为您制作了一个使用 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

或

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

---

要从给定文件名导入模块，您可以临时扩展路径，并在 finally 块 reference: 中恢复系统路径

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

---

使用 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)

这个解决方案的优点是我们甚至不需要知道我们想要导入的模块的实际名称，就可以在我们的代码中使用它。这很有用，例如在模块路径是可配置参数的情况下。

---

我并不是说它更好，但为了完整起见，我想推荐 exec 函数，它在 Python 2 和 Python 3 中都可用。

exec 允许您在以字典形式提供的全局范围或内部范围内执行任意代码。

例如，如果您有一个使用函数 foo() 存储在 "/path/to/module" 中的模块，您可以通过执行以下操作来运行它：

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)

---

添加到 Sebastian Rittau 的答案：至少对于 CPython，有 pydoc，虽然没有正式声明，但导入文件就是它的作用：

from pydoc import importfile
module = importfile('/path/to/module.py')

PS。为了完整起见，在撰写本文时引用了当前的实现：pydoc.py，我很高兴地说，在 xkcd 1987 的脉络中，它既不使用issue 21436 中提到的实现——至少，不是逐字记录。

---

这应该工作

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)

---

在运行时导入包模块（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 脚本所在的目录中添加符号链接是可行的。

IE：

ln -s /absolute/path/to/module/module.py /absolute/path/to/script/module.py

Python 解释器将创建 /absolute/path/to/script/module.pyc 并在您更改 /absolute/path/to/module/module.py 的内容时更新它。

然后在文件 mypythonscript.py 中包含以下内容：

from module import *

---

这将允许在 3.4 中导入已编译的 (pyd) Python 模块：

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()

---

一个非常简单的方法：假设你想要导入文件的相对路径 ../../MyLibs/pyfunc.py

libPath = '../../MyLibs'
import sys
if not libPath in sys.path: sys.path.append(libPath)
import pyfunc as pf

但是，如果您没有守卫就成功了，那么您最终可以走很长的路。

---

我基于 importlib 模块编写了自己的全局和可移植导入函数，用于：

能够将两个模块作为子模块导入，并将模块的内容导入父模块（如果没有父模块，则导入全局）。

能够导入文件名中带有句点字符的模块。

能够导入具有任何扩展名的模块。

能够为子模块使用独立名称，而不是默认情况下不带扩展名的文件名。

能够根据先前导入的模块定义导入顺序，而不是依赖于 sys.path 或任何搜索路径存储。

示例目录结构：

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

包含依赖和顺序：

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

执行：

最新更改存储：https://sourceforge.net/p/tacklelib/tacklelib/HEAD/tree/trunk/python/tacklelib/tacklelib.py

测试.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`

测试库.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')

输出 (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

在 Python 3.7.4、3.2.5、2.7.16 中测试

优点：

可以将两个模块作为子模块导入，也可以将模块的内容导入父模块（如果没有父模块，则导入全局）。

可以导入文件名中带有句点的模块。

可以从任何扩展模块导入任何扩展模块。

可以为子模块使用独立名称，而不是默认情况下不带扩展名的文件名（例如，testlib.std.py 作为 testlib，testlib.blabla.py 作为 testlib_blabla 等等）。

不依赖于 sys.path 或任何搜索路径存储。

不需要在调用 tkl_import_module 之间保存/恢复全局变量，如 SOURCE_FILE 和 SOURCE_DIR。

[对于 3.4.x 和更高版本] 可以在嵌套的 tkl_import_module 调用中混合模块命名空间（例如：named->local->named 或 local->named->local 等）。

[对于 3.4.x 及更高版本] 可以自动将全局变量/函数/类从声明的位置导出到通过 tkl_import_module 导入的所有子模块（通过 tkl_declare_global 函数）。

缺点：

[对于 3.3.x 及更低版本] 需要在所有调用 tkl_import_module 的模块中声明 tkl_import_module（代码重复）

更新 1,2（仅适用于 3.4.x 及更高版本）：

在 Python 3.4 及更高版本中，您可以通过在顶级模块中声明 tkl_import_module 来绕过在每个模块中声明 tkl_import_module 的要求，并且该函数将在一次调用中将自身注入所有子模块（这是一种自我部署导入）。

更新 3：

添加了函数 tkl_source_module 作为 bash source 的模拟，并在导入时支持执行保护（通过模块合并而不是导入实现）。

更新 4：

添加了函数 tkl_declare_global 以自动将模块全局变量导出到模块全局变量不可见的所有子模块，因为它不是子模块的一部分。

更新 5：

所有函数都移到了土库库中，请参见上面的链接。

---

这是我仅使用 pathlib 的两个实用程序函数。它从路径推断模块名称。

默认情况下，它会递归地从文件夹中加载所有 Python 文件，并将 init.py 替换为父文件夹名称。但是您也可以提供 Path 和/或 glob 来选择某些特定文件。

from pathlib import Path
from importlib.util import spec_from_file_location, module_from_spec
from typing import Optional


def get_module_from_path(path: Path, relative_to: Optional[Path] = None):
    if not relative_to:
        relative_to = Path.cwd()

    abs_path = path.absolute()
    relative_path = abs_path.relative_to(relative_to.absolute())
    if relative_path.name == "__init__.py":
        relative_path = relative_path.parent
    module_name = ".".join(relative_path.with_suffix("").parts)
    mod = module_from_spec(spec_from_file_location(module_name, path))
    return mod


def get_modules_from_folder(folder: Optional[Path] = None, glob_str: str = "*/**/*.py"):
    if not folder:
        folder = Path(".")

    mod_list = []
    for file_path in sorted(folder.glob(glob_str)):
        mod_list.append(get_module_from_path(file_path))

    return mod_list

---

这是一种加载文件的方法，类似于 C 等。

from importlib.machinery import SourceFileLoader
import os

def LOAD(MODULE_PATH):
    if (MODULE_PATH[0] == "/"):
        FULL_PATH = MODULE_PATH;
    else:
        DIR_PATH = os.path.dirname (os.path.realpath (__file__))
        FULL_PATH = os.path.normpath (DIR_PATH + "/" + MODULE_PATH)

    return SourceFileLoader (FULL_PATH, FULL_PATH).load_module ()

实现方式：

Y = LOAD("../Z.py")
A = LOAD("./A.py")
D = LOAD("./C/D.py")
A_ = LOAD("/IMPORTS/A.py")

Y.DEF();
A.DEF();
D.DEF();
A_.DEF();

每个文件如下所示：

def DEF():
    print("A");

---