如何导入所有子模块？

Question

我有一个目录结构如下：

| main.py
| scripts
|--| __init__.py
   | script1.py
   | script2.py
   | script3.py

从main.py导入模块scripts 。 我尝试将pkgutils.walk_packages与__all__结合使用，但是使用它，我只能使用from scripts import *直接在main下导入所有子模块。 我想把它们都放在scripts下。 导入scripts所有子模块以便我可以从main访问scripts.script1的最干净的方法是什么？

编辑：对不起，我有点含糊。 我想在运行时导入子模块而不在__init__.py明确指定它们。 我可以使用pkgutils.walk_packages来获取子模块名称（除非有人知道更好的方法），但我不确定使用这些名称的最简洁方法（或者walk_packages返回的 ImpImporters？）来导入它们。

Answer 1

编辑：这是在运行时递归导入所有内容的一种方法......

（顶层包目录中__init__.py内容）

import pkgutil

__all__ = []
for loader, module_name, is_pkg in  pkgutil.walk_packages(__path__):
    __all__.append(module_name)
    _module = loader.find_module(module_name).load_module(module_name)
    globals()[module_name] = _module

我没有在这里使用__import__(__path__+'.'+module_name) ，因为使用它很难正确递归地导入包。 但是，如果您没有嵌套的子包，并且想避免使用globals()[module_name] ，这是一种方法。

可能有更好的方法，但无论如何，这是我能做的最好的方法。

原始答案（对于上下文，忽略其他。我最初误解了这个问题）：

你的scripts/__init__.py什么样的？ 它应该是这样的：

import script1
import script2
import script3
__all__ = ['script1', 'script2', 'script3']

你甚至可以不定义__all__ ，但如果你定义它，事情（pydoc，如果没有别的）会更干净地工作，即使它只是你导入的列表。

Answer 2

这是基于kolypto 提供的答案，但他的答案不执行包的递归导入，而这样做。 尽管主要问题不需要，但我相信递归导入适用并且在许多类似情况下非常有用。 首先，我在搜索该主题时发现了这个问题。

这是执行子包模块导入的一种很好、干净的方式，并且应该是可移植的，并且它使用 python 2.7+ / 3.x 的标准库。

import importlib
import pkgutil


def import_submodules(package, recursive=True):
    """ Import all submodules of a module, recursively, including subpackages

    :param package: package (name or actual module)
    :type package: str | module
    :rtype: dict[str, types.ModuleType]
    """
    if isinstance(package, str):
        package = importlib.import_module(package)
    results = {}
    for loader, name, is_pkg in pkgutil.walk_packages(package.__path__):
        full_name = package.__name__ + '.' + name
        results[full_name] = importlib.import_module(full_name)
        if recursive and is_pkg:
            results.update(import_submodules(full_name))
    return results

用法：

# from main.py, as per the OP's project structure
import scripts
import_submodules(scripts)

# Alternatively, from scripts.__init__.py
import_submodules(__name__)

Answer 3

简单有效，并允许在包内进行相对导入：

def import_submodules(package_name):
    """ Import all submodules of a module, recursively

    :param package_name: Package name
    :type package_name: str
    :rtype: dict[types.ModuleType]
    """
    package = sys.modules[package_name]
    return {
        name: importlib.import_module(package_name + '.' + name)
        for loader, name, is_pkg in pkgutil.walk_packages(package.__path__)
    }

用法：

__all__ = import_submodules(__name__).keys()

Answer 4

不像我想要的那么干净，但没有一种更清洁的方法对我有用。 这实现了指定的行为：

目录结构：

| pkg
|--| __init__.py
   | main.py
   | scripts
   |--| __init__.py
      | script1.py
      | script2.py
      | script3.py

其中pkg/scripts/__init__.py为空，而pkg/__init__.py包含：

import importlib as _importlib
import pkgutil as _pkgutil
__all__ = [_mod[1].split(".")[-1] for _mod in
           filter(lambda _mod: _mod[1].count(".") == 1 and not 
                               _mod[2] and __name__ in _mod[1],
                  [_mod for _mod in _pkgutil.walk_packages("." + __name__)])]
__sub_mods__ = [".".join(_mod[1].split(".")[1:]) for _mod in
                filter(lambda _mod: _mod[1].count(".") > 1 and not 
                                    _mod[2] and __name__ in _mod[1],
                       [_mod for _mod in 
                        _pkgutil.walk_packages("." + __name__)])]
from . import *
for _module in __sub_mods__:
    _importlib.import_module("." + _module, package=__name__)

虽然很乱，但应该是便携的。 我已经将此代码用于几个不同的包。

Answer 5

要加载一个包的所有子模块，你可以使用这个简单的函数：

import importlib
import pkgutil

def import_submodules(module):
    """Import all submodules of a module, recursively."""
    for loader, module_name, is_pkg in pkgutil.walk_packages(
            module.__path__, module.__name__ + '.'):
        importlib.import_module(module_name)

用例：加载 Flask 应用程序的所有数据库模型，以便 Flask-Migrate 可以检测到架构的更改。 用法：

import myproject.models
import_submodules(myproject.models)

Answer 6

我自己也厌倦了这个问题，所以我写了一个名为 automodinit 的包来修复它。 您可以从http://pypi.python.org/pypi/automodinit/获取它。 用法是这样的：

1. 将 automodinit 包包含到setup.py依赖项中。
2. 将以下内容添加到__init__.py文件的开头：

__all__ = ["I will get rewritten"]
# Don't modify the line above, or this line!
import automodinit
automodinit.automodinit(__name__, __file__, globals())
del automodinit
# Anything else you want can go after here, it won't get modified.

就是这样！ 从现在开始，导入模块会将__all__设置为模块中的 .py[co] 文件列表，并且还将导入每个文件，就像您输入的一样：

for x in __all__: import x

因此from M import *的效果与import M完全匹配。

automodinit 很高兴从 ZIP 档案中运行，因此是 ZIP 安全的。

Answer 7

我玩过Joe Kington 的答案，并构建了一个使用globals和get/setattr的解决方案，因此不需要 eval。 一个小小的修改是，我没有直接使用包__path__ for walk_packages ，而是使用包父目录，然后只导入以__name__ + "."开头的模块__name__ + "." . 这样做是为了从walk_packages可靠地获取所有子包 - 在我的用例中，我有一个名为test的子包，它导致 pkgutil 从 python 库中迭代test包； 此外，使用__path__不会递归到包子目录中。 所有这些问题都是使用 jython 和 python2.5 观察到的，以下代码目前仅在 jython 中进行了测试。

另请注意，OP 问题仅讨论从包中导入所有模块，此代码也递归导入所有包。

from pkgutil import walk_packages
from os import path

__all__ = []
__pkg_prefix = "%s." % __name__
__pkg_path = path.abspath(__path__[0]).rsplit("/", 1)[0] #parent directory

for loader, modname, _ in walk_packages([__pkg_path]):
    if modname.startswith(__pkg_prefix):
        #load the module / package
        module = loader.find_module(modname).load_module(modname)
        modname = modname[len(__pkg_prefix):] #strip package prefix from name
        #append all toplevel modules and packages to __all__
        if not "." in modname:
            __all__.append(modname)
            globals()[modname] = module
        #set everything else as an attribute of their parent package
        else:
            #get the toplevel package from globals()
            pkg_name, rest = modname.split(".", 1)
            pkg = globals()[pkg_name]
            #recursively get the modules parent package via getattr
            while "." in rest:
                subpkg, rest = rest.split(".", 1)
                pkg = getattr(pkg, subpkg)
            #set the module (or package) as an attribute of its parent package
            setattr(pkg, rest, module)

作为未来的改进，我将尝试通过包上的__getattr__钩子使其动态化，因此实际模块仅在访问时才导入...

Answer 8

这在 Python 3.3 中对我来说很好用。 请注意，这仅适用于与__init__.py位于同一目录中的文件中的子模块。 但是，通过一些工作，它也可以增强以支持目录中的子模块。

from glob import iglob
from os.path import basename, relpath, sep, splitext

def import_submodules(__path__to_here):
    """Imports all submodules.
    Import this function in __init__.py and put this line to it:
    __all__ = import_submodules(__path__)"""
    result = []
    for smfile in iglob(relpath(__path__to_here[0]) + "/*.py"):
        submodule = splitext(basename(smfile))[0]
        importstr = ".".join(smfile.split(sep)[:-1])
        if not submodule.startswith("_"):
            __import__(importstr + "." + submodule)
            result.append(submodule)
    return result

Answer 9

我正在编写一个小型个人库并一直在添加新模块，因此我编写了一个 shell 脚本来查找脚本并创建__init__.py 。 该脚本在我的包 pylux 的主目录之外执行。

我知道这可能不是您正在寻找的答案，但它为我服务了它的目的，它也可能对其他人有用。

#!/bin/bash

echo 'Traversing folder hierarchy...'

CWD=`pwd`


for directory in `find pylux -type d -exec echo {} \;`;
do
    cd $directory
    #echo Entering $directory
    echo -n "" > __init__.py

    for subdirectory in `find . -type d -maxdepth 1 -mindepth 1`;
    do
        subdirectory=`echo $subdirectory | cut -b 3-`
        #echo -n '    ' ...$subdirectory
        #echo -e '\t->\t' import $subdirectory
        echo import $subdirectory >> __init__.py
    done

    for pyfile in *.py ;
    do
        if [ $pyfile = $(echo __init__.py) ]; then
            continue
        fi
        #echo -n '    ' ...$pyfile
        #echo -e '\t->\t' import `echo $pyfile | cut -d . -f 1`
        echo import `echo $pyfile | cut -d . -f 1` >> __init__.py
    done
    cd $CWD

done


for directory in `find pylux -type d -exec echo {} \;`;
do
    echo $directory/__init__.py:
    cat $directory/__init__.py | awk '{ print "\t"$0 }'
done

Answer 10

在Python 3中，您可以将以下代码放在scripts.__init__.py文件中：

import os
import os.path as op

__all__ = [
    op.splitext(f)[0]  # remove .py extension
    for f in os.listdir(BASE_DIR)  # list contents of current dir
    if not f.startswith('_') and
    ((op.isfile(op.join(BASE_DIR, f)) and f.endswith('.py')) or
     (op.isdir(op.join(BASE_DIR, f)) and op.isfile(op.join(BASE_DIR, f, '__init__.py'))))
]

from . import *  # to make `scripts.script1` work after `import script`

有关Python导入的更多信息，我推荐David Beazley在PyCon 2015上的演讲： https ： //youtu.be/0oTh1CXRaQ0