在 Python 中，导入包是日常开发的基础操作之一。Python 通过其模块化设计，使得代码可以组织成模块和包，提升了代码的复用性和可维护性。而当开始构建复杂的Python项目时，通常会发现将代码组织在各种模块和包中是非常有帮助的。自定义包使得代码更易于管理，并且提高了代码的可维护性和复用性。在Python中，导入自定义包是一个关键的步骤，允许开发者将功能模块化并进行组合，以便更好地组织您的Python项目。

        公众号端文章：

Python导入自定义包https://mp.weixin.qq.com/s?__biz=MzkwMjc0MTE3Mw==&mid=2247484016&idx=3&sn=7420e1c9aab1fadd38ee21b5b3fb607b&chksm=c0a1afaaf7d626bc2007ccbb6ad2bddb0dc45928e67cca8b5b2125ddc9ce0d0bfe2c10fb7321#rd        欢迎各位关注我的公众号，共同学习！

一．相关概念

    在 Python 中，库、包、模块和Python 文件是一些常见的术语，它们彼此之间有一定的联系。以下是它们的定义和相互关系：

1. Python 文件

    Python 文件就是一个以 .py 为扩展名的文件，通常包含 Python 代码。它可以包含函数、类、变量、和可执行代码。    

2. 模块（Module）

    模块是 Python 中组织代码的基本单位，通常是一个 Python 文件（.py 文件）。通过将代码组织成模块，可以重用代码并保持项目的结构清晰。

• 每个.py文件本质上是一个模块。

• 模块可以包含变量、函数、类等代码。

• 模块可以被导入到其他 Python 文件中，使用 import 或 from ... import ... 进行引用。

3. 包（Package）

    包是一个包含多个模块的目录，目录下必须有一个 “__init__.py” 文件（虽然 Python 3.3 以后可以省略，但建议保留）。在 “__init__.py” 中，可以定义包的初始化行为，例如汇总常用模块或函数，通过这种方式可以简化导入的操作。

• 包是一个目录，里面包含模块文件（即 .py 文件），以及可能包含的子包。

• __init__.py 文件标识该目录是一个包，而不是普通的目录。

• 包的层次结构使得 Python 项目更容易组织和管理。

    包的目录结构示例：

mypackage/├── __init__.py      # 包的初始化文件├── module1.py       # 一个模块├── module2.py       # 另一个模块  └── subpackage/      # 一个子包      ├── __init__.py      └── module3.py

4. 库（Library）

    库是一个更宽泛的术语，通常指的是一组已经编写好的模块或包，以提供某种功能或工具，供开发者直接使用。库可以包含多个包、模块、或者仅仅是一些 Python 文件，打包后发布给用户。

• 第三方库通常通过包管理工具（如 pip）进行安装。

• 库可以是由社区或组织维护的工具集，用于处理特定任务，例如numpy、requests。

5. 概念与关系总结

• Python 文件：每个 .py文件是一个Python文件，包含Python代码，可以独立运行或被导入。

• 模块（Module）：一个.py文件就是一个模块。它可以是一个独立文件，也可以是包的一部分。

• 包（Package）：包是一个文件夹，包含多个模块，目录下有一个 __init__.py 文件。包是用于组织模块的方式。

• 库（Library）：库是一组功能相关的模块或包的集合，通常可以通过包管理工具安装。库是更大的概念，可以包含多个包和模块。

6.关系图：

7.实际关系举例

    假设安装了 requests 库，它是一个 HTTP 库，提供了许多与网络请求相关的功能。requests 库实际上是一个包含多个模块和包的库。

• 库：requests是一个库，包含多个模块和包。

• 包：requests目录是一个包，里面有多个模块和子包。

• 模块：每个 .py 文件（例如models.py, adapters.py）是一个模块。

• Python 文件：这些模块实际就是 Python 文件，包含代码逻辑。

二．相关语句

1. import 语句

    import 语句用于导入一个模块或包。

• 导入单个模块

import mymodule #mymodule是一个.py文件

    导入 mymodule 后，所有在 mymodule.py 中定义的函数、类和变量都可以通过 mymodule 命名空间访问。

• 导入整个包

import mypackage #mypackage 是一个包含多个模块的文件

    导入 mypackage 后，包中的子模块不能直接使用，必须通过完全限定的路径导入，例如 mypackage.module1。

• 模块/包命名空间

    当你使用 import 时，导入的模块或包会形成一个独立的命名空间。因此，访问模块中的内容需要通过模块名.内容 的方式。

import mymodule #mymodule 是一个.py文件
mymodule.func() #访问mymodule中的内容

2. from ... import ... 语句

    from ... import ... 是一种更为灵活的导入方式，可以从模块或包中导入特定的内容。

from x import y 的解释

• x：可以是一个包、子包或者模块（Python 文件）。

• y：可以是 x 中的一个模块（在 x 为包时），或者是x中的函数、类、变量等内容（在 x 为模块时）。

情况1：从模块中导入函数、类、变量

    当 x 是一个模块（即一个 .py 文件）时，y 可以是该模块中的函数、类、变量等。

# module1.py 文件中的代码：
def func1():
 pass

# 在其他文件中导入：
from module1 import func1# 这里 x 是 module1（模块），y 是 func1（函数）
func1()

情况 2：从包中导入子模块

    当 x 是一个包（即一个包含 __init__.py 的文件夹）时，y 可以是该包中的子模块或函数。

# mypackage/
# ├── __init__.py
# ├── module1.py
# └── module2.py
# 在其他文件中导入：
from mypackage import module1# 这里 x 是 mypackage（包），y 是 module1（子模块）
module1.some_function()

3. 总结

    import 语句：用于导入整个模块或包。可以导入一个 .py 文件作为模块，或者导入一个文件夹作为包（该文件夹必须包含__init__.py 文件）。

    from ...import ...语句：可以从一个模块（Python 文件）中导入函数、类、变量等，或者从一个包中导入子模块、子包。

语句	x是什么	y是什么
import x	模块或包	-
from x import y	包、子包或模块	模块、或其中的内容

三．导入自定义包

    在开发大型项目时，通常需要将代码拆分成多个文件和模块。Python 提供了灵活的方式来导入自定义模块或包。

1.什么是自定义包？

    自定义包是指开发者自行编写的一组相关功能模块的集合，通常来说，这些功能模块可能针对特定的需求或任务。自定义包通常包含一些函数、类、变量或其他代码，可以被其他代码文件引用和调用，从而实现代码的模块化和复用。自定义包的好处在于可以根据相关需求将相关功能进行封装，提高代码的可维护性和可扩展性。

    在 Python 中，一个包本质上是一个包含多个模块的文件夹。通过将相关的模块组织成包，可以在项目中更好地分离和管理不同的功能。

    一个典型的自定义包结构如下：

myproject/ ├──mypackage/ │   ├── __init__.py │   ├── module1.py │   └── module2.py └── main.py

    在这个结构中：

    mypackage是包，包含两个模块“module1.py” 和 “module2.py”。

    __init__.py文件是包的初始化文件，可以为空，也可以在其中定义一些包级别的函数或类。

2. 自定义包导入

• 导入整个包或模块

    在外部文件（如 main.py）中，可以通过以下方式导入 mypackage 包中的模块：

import mypackage.module1
import mypackage.module2

    这样导入后，你需要使用完整的命名空间访问模块内的函数或类：

result = mypackage.module1.func1()

• 导入包中的特定对象

    如果你只需要使用模块中的某些函数或类，可以直接导入它们：

from mypackage.module1 import func1
result = func1()

    这种方式避免了每次调用时都要写全路径，简化了代码。

    当然，也可以通过配置__init__.py文件，这样就可以直接调用包中指定的模块中的内容。

# mypackage/__init__.py
from .module1 import func1
from .module2 import func2

    在 main.py中可以直接这样导入并使用包内的函数：

from mypackage import func1,func2
result1 = func1()
result2 = func2()

• 包内模块的绝对导入

    绝对导入使用包的全路径导入其他模块。假设module2.py想要调用 module1.py中的func1函数，可以这样做：

# module2.py
from mypackage.module1 import func1
def func2():
  return func1() + " from func2"

• 包内模块的相对导入

    相对导入基于模块之间的相对位置，可以使代码更简洁。当项目包层次较深时，相对导入非常有用。

• 单点 "." 表示当前包。

• 双点 ".." 表示上一级包，依次类推。

    假设我们在module2.py中使用相对导入来引用module1.py中的 func1：

# module2.py
from .module1 import func1
def func2():
  return func1() + " from func2"

    如果项目的层级更深，例如：

myproject/ ├──mypackage/ │   ├── subpackage/ │   │   ├── module3.py │   └── module1.py

    在module3.py中可以这样相对导入module1.py中的函数：

# subpackage/module3.py
from ..module1 import func1
def func3():
  return func1() + " from func3"

    相对导入具有一定限制，相对导入只能在包内部使用，且在运行顶层脚本时（如main.py），相对导入可能会出现问题，因为 Python 会把运行脚本所在的目录作为顶层模块。因此，在顶层脚本中使用绝对导入会更加稳定。

四．复杂项目中的路径管理

    在复杂的项目中，可能会涉及到多个包和模块的跨包导入，管理导入路径成为一项关键任务。

1. 使用“sys.path”管理路径

    Python 的模块导入是基于“sys.path”中定义的路径列表。默认情况下，“sys.path”包含了当前脚本目录、标准库路径和安装的第三方包路径。

    如果你需要导入一个不在当前路径中的模块，可以通过修改“sys.path”来实现。例如，你想从一个特定的目录加载模块：

import sys
sys.path.append('/path/to/your/module')

    导入自定义模块时，Python 会根据 “sys.path” 列表中的路径依次查找模块。默认情况下，“sys.path” 包含当前脚本的目录、Python 标准库路径以及已安装包的路径。

    可以通过手动修改 “sys.path” 来添加自定义路径：

import sys
sys.path.append('/path/to/your/module')

    这种方式在动态加载模块或临时测试时较为常用，但通常推荐使用 Python 虚拟环境和包管理工具来处理项目依赖和模块路径。

    通过这种方式，你可以动态地扩展 Python 查找模块的范围。不过，手动修改路径不是最佳实践，通常只在某些特殊场景下使用。

2. 推荐使用的项目结构

    在开发复杂项目时，推荐使用以下结构来简化模块导入和路径管理：

• 虚拟环境：为项目创建虚拟环境，隔离不同项目的依赖。

• 包管理工具：使用 “pipenv”、“poetry” 等工具来管理依赖和包的安装路径。

• 清晰的目录结构：将项目按照功能分解为不同的包和子包，每个包有明确的功能划分。

    一个推荐的项目结构可能如下：

myproject/ ├──mypackage/ │   ├── __init__.py │   ├── module1.py │   └── subpackage/ │       ├── __init__.py │       └── module3.py ├── tests/ │   ├── __init__.py │   └── test_module1.py └── main.py

五．导入失败的处理

    当在Python中导入自定义包失败时，通常会收到 ImportError 或ModuleNotFoundError 的错误消息。这种情况可能由多种原因引起，以下是一些可能的处理方法：

• 检查包名是否正确：注意导入的包名是否正确。

• 检查包路径：确保包的路径在Python解释器的搜索路径中。可以通过以下方式打印Python解释器的搜索路径：

import sys
print(sys.path)

    如果包所在路径未包含在搜索路径中，可以考虑将包路径添加到搜索路径中。

• 检查包结构：确保包结构正确，包含__init__.py 文件以使其被识别为包。也需要确保包内的模块文件名正确，并且在包的层次结构中有正确的引用关系。

• 相对导入：在包内部模块的相互引用中，可以使用相对导入以避免循环导入的问题。例如，可以使用 from .import module_name 进行相对导入。

• 重载缓存：有时候导入失败可能是由于缓存问题引起的，可以尝试清除Python的模块导入缓存：

import importlib
importlib.invalidate_caches()

• 检查环境：确保在使用虚拟环境的情况下，已经激活了正确的环境。另外，也要确保Python解释器的版本和所使用的包的兼容性。

• 检查错误消息：查看错误消息中提供的详细信息，有时会指示具体哪一步导致导入失败。

    通过以上方法进行逐步排查，可以解决大多数导入自定义包失败的问题。如果以上方法仍无法解决问题，可能需要进一步深入分析具体情况。

    通过合理组织代码和使用包机制，Python 项目可以保持良好的扩展性和可维护性。这也是 Python 在大型项目中得以广泛应用的原因之一。掌握 Python 中包和模块的导入机制，能帮助我们编写更清晰、可维护的代码，同时提高开发效率。

     如果本文对您有所帮助，欢迎关注、点赞、转发，共同学习！