python - 如何使用 __import__ 函数从子模块中导入名称？

Question

我正在尝试使用 __import__ 函数从 foo.bar import object 复制 ，但我似乎碰壁了。

一个更简单的例子 from glob import glob 很简单:glob = __import__("glob").glob

我遇到的问题是我从子包中导入一个名称(即 from foo.bar):

所以我想要的是类似的东西

string_to_import = "bar"
object = __import__("foo." + string_to_import).object

但这只是导入顶级 foo 包，而不是 foo.bar 子包:

__import__("foo.bar")
<module 'foo' from 'foo/__init__.pyc'>

Answer 1

How to use python's __import__() function properly?

有两种用途:

• 直接导入
• 改变导入行为的钩子(Hook)

在大多数情况下，您也不需要这样做。

用于用户空间导入

最佳做法是改用 importlib。但如果你坚持:

琐碎的用法:

>>> sys = __import__('sys')
>>> sys
<module 'sys' (built-in)>

复杂的:

>>> os = __import__('os.path')
>>> os
<module 'os' from '/home/myuser/anaconda3/lib/python3.6/os.py'>
>>> os.path
<module 'posixpath' from '/home/myuser/anaconda3/lib/python3.6/posixpath.py'>

如果您想要名称中最右边的子模块，请传递一个非空列表，例如[None]，到fromlist:

>>> path = __import__('os.path', fromlist=[None])
>>> path
<module 'posixpath' from '/home/myuser/anaconda3/lib/python3.6/posixpath.py'>

或者，如文档所述，使用 importlib.import_module:

>>> importlib = __import__('importlib')
>>> futures = importlib.import_module('concurrent.futures')
>>> futures
<module 'concurrent.futures' from '/home/myuser/anaconda3/lib/python3.6/concurrent/futures/__init__.py'>

文档

__import__ 的文档是最令人困惑的内置函数。

__import__(...)
    __import__(name, globals=None, locals=None, fromlist=(), level=0) -> module

    Import a module. Because this function is meant for use by the Python
    interpreter and not for general use it is better to use
    importlib.import_module() to programmatically import a module.

    The globals argument is only used to determine the context;
    they are not modified.  The locals argument is unused.  The fromlist
    should be a list of names to emulate ``from name import ...'', or an
    empty list to emulate ``import name''.
    When importing a module from a package, note that __import__('A.B', ...)
    returns package A when fromlist is empty, but its submodule B when
    fromlist is not empty.  Level is used to determine whether to perform 
    absolute or relative imports. 0 is absolute while a positive number
    is the number of parent directories to search relative to the current module.

如果您仔细阅读，您会感觉到 API 最初旨在允许从模块中延迟加载函数。然而，这不是 CPython 的工作方式，我不知道是否有任何其他 Python 实现能够做到这一点。

相反，CPython 在第一次导入时执行模块命名空间中的所有代码，之后模块缓存在 sys.modules 中。

__import__ 仍然有用。但是根据文档理解它的作用是相当困难的。

__import__的完整使用

为了调整完整的功能来演示当前的 __import__ API，这里有一个包装函数，它具有更简洁、文档更好的 API。

def importer(name, root_package=False, relative_globals=None, level=0):
    """ We only import modules, functions can be looked up on the module.
    Usage: 

    from foo.bar import baz
    >>> baz = importer('foo.bar.baz')

    import foo.bar.baz
    >>> foo = importer('foo.bar.baz', root_package=True)
    >>> foo.bar.baz

    from .. import baz (level = number of dots)
    >>> baz = importer('baz', relative_globals=globals(), level=2)
    """
    return __import__(name, locals=None, # locals has no use
                      globals=relative_globals, 
                      fromlist=[] if root_package else [None],
                      level=level)

为了演示，例如从姐妹包到baz:

baz = importer('foo.bar.baz')    
foo = importer('foo.bar.baz', root_package=True)
baz2 = importer('bar.baz', relative_globals=globals(), level=2)

assert foo.bar.baz is baz is baz2

模块中名称的动态访问

要从 baz 模块按名称动态访问全局变量，请使用 getattr。例如:

for name in dir(baz):
    print(getattr(baz, name))

改变导入行为的钩子(Hook)

您可以使用 __import__ 来更改或拦截导入行为。在这种情况下，让我们打印它得到的参数来证明我们正在拦截它:

old_import = __import__

def noisy_importer(name, locals, globals, fromlist, level):
    print(f'name: {name!r}')
    print(f'fromlist: {fromlist}')
    print(f'level: {level}')
    return old_import(name, locals, globals, fromlist, level)

import builtins
builtins.__import__ = noisy_importer

现在，当您导入时，您可以看到这些重要参数。

>>> from os.path import join as opj
name: 'os.path'
fromlist: ('join',)
level: 0
>>> opj
<function join at 0x7fd08d882618>

也许在这种情况下，获取全局变量或局部变量可能很有用，但没有立即想到它的具体用途。