Python如何获取任意模块m中导入的所有模块？

这个问题确实挺头疼的——当模块里用import a.b.c这种层级导入时，dir()只能返回顶层包a，没法直接拿到实际导入的子模块c。下面我给你几个直接操作模块对象就能实现的解决方案：

方法1：递归遍历模块的命名空间（适用于已加载的模块） #

当你用import a.b.c时，模块m的命名空间里会有a这个包对象，而a的命名空间里有b，b里又有c。我们可以写个递归函数，遍历模块的属性，收集所有模块/包对象：

import types

def collect_all_imported_modules(target_module):
    imported_modules = set()
    
    def traverse(obj):
        # 遍历对象的所有属性
        for name, item in obj.__dict__.items():
            # 跳过私有属性（避免拿到__name__、__file__这类内置属性）
            if name.startswith('_'):
                continue
            # 如果是模块对象
            if isinstance(item, types.ModuleType):
                # 用集合避免重复导入的模块
                if item not in imported_modules:
                    imported_modules.add(item)
                    # 如果是包（有__path__属性），递归遍历子模块
                    if hasattr(item, '__path__'):
                        traverse(item)
    
    traverse(target_module)
    return imported_modules

使用示例 #

假设模块m里有import os.path，调用collect_all_imported_modules(m)会返回包含os和os.path的集合。

方法2：解析模块源代码（更准确，支持静态导入） #

如果模块里的导入方式比较复杂，或者你想精准捕获所有静态导入的模块，可以用Python的ast模块分析源代码，找出所有导入语句，再通过importlib加载对应的模块：

import ast
import inspect
import importlib
import types

def get_imports_from_module_source(target_module):
    imported_modules = set()
    
    try:
        # 获取模块的源代码
        source_code = inspect.getsource(target_module)
    except TypeError:
        # 处理没有源代码的模块（比如C扩展）
        return imported_modules
    
    # 解析抽象语法树
    tree = ast.parse(source_code)
    
    for node in ast.walk(tree):
        # 处理 `import a.b.c` 形式的导入
        if isinstance(node, ast.Import):
            for alias in node.names:
                try:
                    module = importlib.import_module(alias.name)
                    imported_modules.add(module)
                except ImportError:
                    # 跳过导入失败的可选依赖
                    continue
        # 处理 `from a.b import c` 或 `from a.b import c as d` 形式的导入
        elif isinstance(node, ast.ImportFrom):
            if not node.module:
                continue
            for alias in node.names:
                full_module_name = f"{node.module}.{alias.name}"
                try:
                    module = importlib.import_module(full_module_name)
                    imported_modules.add(module)
                except ImportError:
                    # 如果子模块导入失败，尝试导入父模块（可选逻辑）
                    try:
                        parent_module = importlib.import_module(node.module)
                        imported_modules.add(parent_module)
                    except ImportError:
                        continue
    return imported_modules

优势 #

这个方法能精准捕获所有静态导入的模块，不管你用import a.b.c还是from a.b import c，甚至import a.b.c as d都能正确识别。唯一的局限是没法处理动态导入（比如用__import__()函数或者importlib.import_module()动态加载的模块）。

注意事项 #

• 递归遍历命名空间时，用集合存储模块对象可以自动避免循环引用的问题（比如模块A导入B，B又导入A）。
• 解析源代码时，如果模块是通过exec()或其他动态方式生成的，inspect.getsource()会报错，这时候可以 fallback 到方法1。

内容的提问来源于stack exchange，提问作者ezer1337