这是一个非常强大但也容易引起混淆的内置函数，理解它对于深入学习 Python 的模块系统非常有帮助。

__import__ 是什么？

__import__ 是 Python 的一个内置函数，它的主要作用是动态地导入一个模块。

“动态导入”意味着你可以在程序的运行时（而不是在编译时或启动时）决定要导入哪个模块，这通常用于实现插件系统、延迟加载或根据配置来加载不同的功能模块。

__import__ 的基本语法

__import__(name, globals=None, locals=None, fromlist=(), level=0)

虽然它看起来有很多参数，但在大多数情况下，你只需要关心第一个参数 name。

参数详解：

1. name (字符串):

   
   （图片来源网络，侵删）
   • 这是要导入的模块的名称，'os', 'json', 'my_package.my_module'。
   • 这是唯一一个必需的参数。

2. globals (字典):

   • 调用该函数的模块的全局命名空间，它通常用于解析相对导入。
   • 如果不提供，默认为 None,这通常表示当前的全局命名空间。
   • 对于初学者来说,通常可以忽略这个参数。

3. locals (字典):

   • 调用该函数的模块的局部命名空间。
   • 和 globals 一样,初学者通常可以忽略它。

4. fromlist (列表):

   • 这是一个非常重要的参数，它决定了 __import__ 的行为。
   • fromlist 是一个空列表（默认情况），__import__ 会返回顶层模块。
   • fromlist 不为空，__import__ 会返回name 指定的模块路径中的最后一个模块（即最底层的模块）。
   • 这就是它与 import 语句在行为上的最大区别。

5. level (整数):

   
   （图片来源网络，侵删）
   • 用于控制相对导入的级别。
   • 0 (默认值): 表示绝对导入。
   • 1: 表示从当前目录开始进行相对导入。
   • n: 表示从上 n 级父目录开始进行相对导入。
   • 在 Python 3 中，推荐使用显式的 或 语法进行相对导入,而不是依赖这个参数。

__import__ 的工作原理与示例

为了更好地理解,我们通过几个例子来说明。

场景设置

假设我们有如下的项目结构：

my_project/
├── main.py
└── my_package/
    ├── __init__.py
    └── my_module.py

my_package/my_module.py 的内容：

# my_package/my_module.py
def hello():
    print("Hello from my_module!")
VERSION = "1.0"

my_package/__init__.py 的内容（可以为空）：

# my_package/__init__.py
print("my_package is being imported.")

示例 1：基本导入 (与 import 类似)

# main.py
# 情况一：fromlist 为空 (默认行为)
# 导入 'my_package'，并返回顶层模块 'my_package'
package = __import__('my_package')
print(f"返回的对象: {package}")
print(f"对象类型: {type(package)}")
print(f"对象名称: {package.__name__}")
# 尝试访问模块中的函数
# package.hello()  # 这会报错！因为返回的是 'my_package' 模块，
                  # 它本身没有 'hello' 函数，'hello' 在 'my_package.my_module' 中。

输出:

my_package is being imported.
返回的对象: <module 'my_package' from '/path/to/my_project/my_package/__init__.py'>
对象类型: <class 'module'>
对象名称: my_package

分析: __import__('my_package') 就像 import my_package 一样，它执行了 my_package 包的 __init__.py 文件，并返回了代表 my_package 这个包的模块对象。

示例 2：from ... import ... 的行为 (关键区别)

我们想实现类似 from my_package.my_module import hello 的效果。

# main.py
# 情况二：fromlist 不为空
# 我们想从 'my_package.my_module' 中导入东西
# fromlist=['hello'] 告诉 __import__ 我们需要的是 'my_module'，而不仅仅是 'my_package'
module = __import__('my_package.my_module', fromlist=['hello'])
print(f"\n返回的对象: {module}")
print(f"对象类型: {type(module)}")
print(f"对象名称: {module.__name__}")
# 现在我们可以成功调用函数了
module.hello()

输出:

my_package is being imported.
返回的对象: <module 'my_module' from '/path/to/my_project/my_package/my_module.py'>
对象类型: <class 'module'>
对象名称: my_module
Hello from my_module!

分析: 这是 __import__ 最关键的地方！

• name 是 'my_package.my_module'。
• fromlist 是 ['hello']（非空）。
• 因为 fromlist 不为空，__import__ 没有返回路径的顶层模块 my_package，而是返回了路径的最后一个模块 my_module。
• 这正是 from ... import ... 语句所期望的行为。

示例 3：为什么 __import__ 会让人困惑？

让我们再看一个例子,加深理解。

# main.py
# 想要实现 from my_package import my_module 的效果
# 错误的方式：
# 如果我们只写 __import__('my_package.my_module')，fromlist默认为空
# 它会返回 'my_package'
wrong_module = __import__('my_package.my_module')
print(f"\n错误方式返回的对象: {wrong_module}")
print(f"wrong_module.my_module: {wrong_module.my_module}") # 这样才能访问到真正的模块
# 正确的方式：
# fromlist=['my_module'] 告诉我们，我们想要的是 'my_package' 下的 'my_module'
correct_module = __import__('my_package.my_module', fromlist=['my_module'])
print(f"\n正确方式返回的对象: {correct_module}")
print(f"correct_module.__name__: {correct_module.__name__}")

输出:

my_package is being imported.
错误方式返回的对象: <module 'my_package' from '/path/to/my_project/my_package/__init__.py'>
wrong_module.my_module: <module 'my_module' from '/path/to/my_project/my_package/my_module.py'>
正确方式返回的对象: <module 'my_module' from '/path/to/my_project/my_package/my_module.py'>
correct_module.__name__: my_module

分析:

• 错误方式：__import__('my_package.my_module') 因为 fromlist 为空，返回了 my_package，要访问 my_module，你需要通过 my_package.my_module。
• 正确方式：__import__('my_package.my_module', fromlist=['my_module']) 因为 fromlist 不为空，直接返回了我们想要的 my_module 模块对象。

__import__ vs. importlib.import_module()

在现代 Python 编程中，强烈推荐使用 importlib.import_module() 而不是直接使用 __import__。

importlib.import_module() 是 __import__ 的一个更清晰、更易于使用的封装。

importlib.import_module() 的优点：

1. 行为直观: 它的行为总是与 from ... import ... 语句一致，你导入什么路径，它就返回那个路径对应的模块对象，没有 fromlist 的歧义。
2. API 清晰: 函数签名更简单，import_module(name, package=None),更容易理解和使用。
3. 推荐用法: 它是 Python 官方文档和社区推荐的用于动态导入的标准方法。

使用 importlib 的示例：

# main.py
import importlib
# 导入顶层包
package = importlib.import_module('my_package')
print(f"import_module 返回: {package.__name__}") # 输出: my_package
# 导入子模块 (行为与 from my_package.my_module import * 一致)
module = importlib.import_module('my_package.my_module')
print(f"import_module 返回: {module.__name__}") # 输出: my_module
module.hello() # 直接调用
# 动态导入示例
module_name = 'json' # 这个名字可以来自配置文件、用户输入等
dynamic_module = importlib.import_module(module_name)
data = '{"name": "Alice", "age": 30}'
parsed_data = dynamic_module.loads(data)
print(f"\n使用动态导入的 json 模块解析数据: {parsed_data}")

总结与最佳实践

何时使用动态导入？

• 插件系统: 你的应用程序可以加载位于特定目录下的插件模块,而无需在主程序中硬编码它们。
• 延迟加载: 只有在第一次需要某个功能时，才导入对应的模块,以减少程序的启动时间和内存占用。
• 配置驱动: 根据配置文件或环境变量来决定加载哪个模块,实现灵活的功能切换。

除非你正在编写底层的 Python 解释器或非常特殊的导入钩子，否则请始终使用 importlib.import_module()，它能让你更安全、更清晰地实现动态导入功能，避免 __import__ 带来的陷阱和困惑。