Python 包、模块和 import 笔记

码农终结者

已于 2024-01-27 21:41:26 修改

阅读量1.1k

点赞数 25

分类专栏：知识系列 Python 文章标签： python 笔记开发语言

于 2024-01-26 09:21:26 首次发布

本文链接：https://blog.csdn.net/weixin_43839586/article/details/135844707

版权

知识系列同时被 2 个专栏收录

20 篇文章 1 订阅

订阅专栏

Python

3 篇文章 0 订阅

订阅专栏

这一篇主要记录包、模块和 import 相关的一些概念以及流程，需要一丢丢的Python基础

Python 包与模块

模块（Module）

在 Python 中，一个模块是一个包含 Python 代码的文件，其扩展名为 .py。（Python脚本）

每个模块都可以定义变量、函数、类和其他 Python 对象。

这些对象可以通过导入模块进行访问。要使用模块，可以使用 import 语句将其导入到代码中。

包（Package）

一个包是一个包含多个模块的目录。包可以是任意层次结构，并且可以包含其他包（子包）。

包通常包含一个名为 __init__.py 的特殊模块文件，该文件用于初始化包并定义其公共接口。

要使用包，可以像导入模块一样使用 import 语句。

目录结构

如下是一个简单的项目目录结构，里面包含两个包以及6个模块

project/
   ├── package1/
   │   ├── __init__.py
   │   ├── module1.py
   │   └── module2.py
   ├── package2/
   │   ├── __init__.py
   │   ├── module3.py
   │   └── module4.py
   ├── module5.py
   └── main.py

__init__.py 文件：这个文件是包的初始化文件。它用于定义包的公共接口，并在导入包时执行一些初始化代码，内容可以为空。如果没有 __init__.py 文件，Python 将不会将目录视为包。
moudle5 不属于任何一个包

模块的导入

平时会导入包、模块，那有没有想过动态的加载包和模块呢？这里用上述的目录结果演示

简单导入

# 导入包
import package1
# 导入包是不能用如下方式调用模块的，模块不是包的属性
# package1.module1
------------------------------------------------
# 导入包中的所有模块
from package1 import *
# 调用
module1
------------------------------------------------
# 导入指定的模块
import package1.module1
# 调用
package1.module1

from package1 import moudle1
# 调用
moudle1
------------------------------------------------
# 调用指定包，定义别名
import package1.module1 as moudle_a
# 调用
moudle_a

注意：因为from package import module 是需要获取package的__all__属性来加载模块的，所以如果报错没有这个模块，建议在__init__.py 中添加__all__这个包含module名字符串的数组

重新导入

因为模块和包导入以后会保存在内存里面，所以当我们更新了某个文件未释放解释器时，变更不会生效，当我们碰到需要长时间运行的脚本就需要重启解释器。可以考虑代码中触发重新导入

1）重启解释器

这是最简单的方法，通过重启解释器，所有的模块都会重新加载

2）使用 `reload` 函数

from importlib import reload

import module5

# 修改了 module5.py 文件后，使用 reload 函数重新加载模块
reload(module5)

注意：

即使使用了 reload 函数，某些更改可能仍然不会生效，特别是如果它们涉及到全局变量或类的定义。
因为这些更改可能不会影响已经创建的对象或已经执行的代码。
在某些情况下，你可能需要手动重新初始化变量或对象以反映更改。

3）开发环境中的自动重载

一些开发环境（如 Jupyter Notebook）或代码编辑器（如 PyCharm）提供了自动重载模块的功能，当你保存文件时，它们可以自动重新执行模块代码。

4）自定义重载逻辑

在一些复杂的场景中，你可以编写自定义逻辑来监控模块文件的更改，并在检测到更改时手动重新加载模块

动态导入

1）使用路径导入

如果你有一个包结构，你可以将包的路径添加到 sys.path 中，然后使用正常的导入语句

import sys

# 将包的路径添加到 sys.path
sys.path.insert(0, '/path/to/your/package')

# 现在你可以正常导入包下的模块
my_module = import module

注意：如果可能存在多个同名的模块，请以 package.module 的方式或者用from 导入

2）使用 `importlib` 模块

importlib 是 Python 的一个内置库，它提供了用于导入模块的功能。你可以使用 importlib.util 中的 spec_from_file_location 和 module_from_spec 来动态加载模块。

spec_from_file_location 函数创建一个 ModuleSpec 对象，它包含了指定文件的位置和名称。ModuleSpec 对象用于描述模块的属性，如名称、文件路径等。使用 spec_from_file_location 可以创建一个模块规范，以便稍后使用 module_from_spec 加载它。

module_from_spec 函数根据给定的 ModuleSpec 对象创建和加载一个模块。module_from_spec 会读取模块文件，执行其中的代码，并返回一个已加载的模块对象。对象包含了 模块的所有属性和引用，但是模块代码本身并没有执行。这意味着，如果 模块中有任何初始化代码或全局变量的定义，这些代码将不会执行，全局变量也不会被初始化。使用 module_from_spec 可以动态加载模块，而不必使用 import 语句。

ModuleSpec 对象的 spec.loader.exec_module(module) 是在动态加载模块时执行模块代码的关键步骤。虽然 module_from_spec 返回了一个已加载的模块对象，但该对象在创建时并没有立即执行模块代码。执行 spec.loader.exec_module(module) 可以确保模块代码在加载后立即执行，从而初始化模块中的变量、函数和类。

import importlib.util

def import_module_dynamic(module_name, module_path):
    # 创建一个 ModuleSpec 对象，它包含了指定文件的位置和名称
    spec = importlib.util.spec_from_file_location(module_name, module_path)
    # 读取模块文件，执行其中的代码，并返回一个已加载的模块对象
    module = importlib.util.module_from_spec(spec)
    # 模块代码在加载后立即执行，从而初始化模块中的变量、函数和类
    spec.loader.exec_module(module)
    return module

my_module = import_module_dynamic('module1', '/path/to/module1.py')

模块名字符串导入

1）使用 `importlib.import_module()`

importlib.import_module() 函数是动态导入模块的标准方式

import importlib

# 通过字符串动态导入模块
module_name = "json"
my_module1 = importlib.import_module(module_name)

# 使用模块
data = my_module1.dumps({"key": "value"})

# 导入包内的模块
my_module2 = importlib.import_module(package1.moudle1)

2）使用 `import()`

Python 的内置函数 __import__() 也可以用于动态导入模块，但它的使用稍微复杂一些。

# 使用 __import__ 动态导入模块
module_name = "json"
my_module = __import__(module_name)
 
# 使用模块
data = my_module.dumps({"key": "value"})

嵌套导入

module_name = "package1.module1"
my_module = __import__("package1.module1", fromlist=[""])
 
# 访问 submodule
module1 = getattr(my_module, "module1")

注意：使用 __import__() 时，你应该尽量避免直接导入顶级模块，因为这可能会导致命名空间的不明确。通常建议在导入嵌套模块时使用它。就是详细一些的意思。

3）使用 `exec()`

虽然不推荐，但也可以使用 exec() 函数执行导入语句。这种方法不安全，因为它执行了字符串形式的代码，可能会引入安全风险。

# 使用 exec() 导入模块（不推荐）
module_name = "json"
exec(f"import {module_name}")
my_module = locals()[module_name]

# f"import {module_name}" 这个是一种字符串的格式化，f 开头的字符串，可以用{}取变量
module_name = "json"
print(f"import {module_name}")
import json

导入注意事项

动态导入模块时要确保字符串来源是可信的，避免执行恶意代码。
使用 importlib 是最推荐的方式，因为它提供了更多的控制和安全保障。
如果在循环或多次调用中动态导入模块，确保使用缓存机制来避免不必要的重复导入。
导入模块的成本还是比较高的，特别是某些模块内有些耗时的代码

获取包的子模块

有些情况需要获取包的子模块，进行选择性的加载

1）使用 `pkgutil` 模块

pkgutil 模块提供了一个 walk_packages 函数，它可以遍历包中的所有子模块，可以递归子包

import pkgutil
 
def get_submodules(package):
    submodules = []
    for loader, name, ispkg in pkgutil.walk_packages(package.__path__):
        full_name = package.__name__ + '.' + name
        submodules.append(full_name)
        if ispkg:
            submodules.extend(get_submodules(__import__(full_name, fromlist=[''])))
    return submodules
 
# 假设你想要获取当前包的子模块列表
current_package = __import__(__name__)
submodules_list = get_submodules(current_package)
print(submodules_list)

2）使用 `importlib` 模块

importlib 模块提供了更底层的导入机制。你可以使用 importlib.util.find_spec 来检查子模块是否存在。也可以递归子包

import importlib.util
 
def get_submodules(package_name):
    submodules = []
    package_path = importlib.util.find_spec(package_name).submodule_search_locations
    for entry in package_path:
        for item in os.listdir(entry):
            if item.endswith('.py') and item != '__init__.py':
                submodule_name = item[:-3]
                submodule_full_name = f"{package_name}.{submodule_name}"
                if importlib.util.find_spec(submodule_full_name) is not None:
                    submodules.append(submodule_full_name)
    return submodules
 
# 获取当前包的子模块列表
package_name = __name__
submodules_list = get_submodules(package_name)
print(submodules_list)

3）使用 `os` 模块直接检查文件

如果你确信子模块都在文件系统中以 .py 文件的形式存在，你可以直接使用 os 模块来遍历目录。这个不会递归子包，当然这种递归的逻辑写起来也简单，判断子目录是否存在__init__.py文件，然后递归就是了

import os
 
def get_submodules(package_dir):
    submodules = []
    for item in os.listdir(package_dir):
        if item.endswith('.py') and item != '__init__.py':
            submodule_name = item[:-3]
            submodules.append(submodule_name)
    return submodules
 
# 假设你知道当前包的目录路径
package_dir = os.path.dirname(__file__)
submodules_list = get_submodules(package_dir)
print(submodules_list)