模块的概念

模块就是一个包含 Python 代码的 .py 文件，用于将代码按功能组织成独立的单元

随着程序规模的增长，把所有代码写在一个文件里会变得难以维护。模块的出现解决了这个问题——将相关功能的代码组织在独立的文件中，通过导入机制在不同文件间共享使用。

模块的三大好处：

  • 代码复用：将常用的函数、类写好放在模块里，多处在项目中复用
  • 命名空间隔离：每个模块有自己独立的命名空间，同名的变量不会互相冲突
  • 易于维护：按功能拆分文件，结构清晰，方便团队协作

一个最简单的模块：

1
2
3
4
5
6
7
8
# 文件名为 mymodule.py
# 这个 .py 文件就是一个模块，模块名就是文件名（不含 .py）

def greet(name):
    """一个简单的问候函数"""
    print(f"你好，{name}！")

VERSION = "1.0"

模块的导入

通过 import 语句在一个 Python 文件中引入另一个模块，从而使用其定义的函数、类、变量

  1. import 模块名
1
2
3
4
5
6
7
8
"""
import 模块名
通过 模块名.函数名() 或 模块名.变量名 的方式来使用
"""
import mymodule

mymodule.greet("PyTs1n9")   # 输出 你好，PyTs1n9！
print(mymodule.VERSION)     # 输出 1.0
  1. from…import 导入
1
2
3
4
5
6
7
8
9
10
11
"""
from 模块名 import 函数名/变量名
直接使用导入的名字，不需要 模块名. 前缀
"""
from mymodule import greet, VERSION

greet("study")   # 输出 你好，study！
print(VERSION)   # 输出 1.0

# from 模块名 import *  导入模块中所有内容（不推荐，容易冲突）
from mymodule import *
  1. 使用 as 起别名
1
2
3
4
5
6
7
8
9
10
11
"""
import 模块名 as 别名
from 模块名 import 函数名 as 别名
给模块或导入的内容起一个简短的别名，方便使用
"""
import mymodule as mm

mm.greet("别名")   # 输出 你好，别名！

from mymodule import greet as hello
hello("kitty")     # 输出 你好，kitty！
  1. 导入与不导入的区别
1
2
3
4
5
6
7
8
9
10
11
12
"""
模块在被 import 时，其顶层代码会被执行一次
但再次 import 同一个模块时不会重复执行
"""

# mymodule.py 内容：
# print("mymodule 被加载了")   ← 这行在 import 时会执行
# def greet(name):
#     print(f"你好，{name}！")

import mymodule  # 输出 mymodule 被加载了
import mymodule  # 不会再次输出（Python 会缓存已导入的模块）

自定义模块

自己编写 .py 文件作为模块，在另一个 .py 文件中导入并使用

  1. 创建并使用自定义模块
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 步骤一：创建模块文件 utils.py
"""
文件：utils.py
"""

def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

PI = 3.14159

# 测试代码（只在直接运行 utils.py 时执行）
if __name__ == "__main__":
    print(add(1, 2))
    print(subtract(5, 3))
1
2
3
4
5
6
7
8
9
# 步骤二：在另一个文件中导入使用 main.py
"""
文件：main.py
"""
import utils

print(utils.add(10, 20))       # 输出 30
print(utils.subtract(10, 5))   # 输出 5
print(utils.PI)                # 输出 3.14159
  1. name 变量的作用
1
2
3
4
5
6
7
8
9
10
11
12
13
"""
__name__ 是 Python 内置的特殊变量：
- 当模块被直接运行时（python xxx.py），__name__ 的值为 "__main__"
- 当模块被导入时（import xxx），__name__ 的值为模块名 "xxx"
"""

# utils.py 中的用法：
if __name__ == "__main__":
    # 这里的代码只在直接运行 utils.py 时执行
    # 被 import 时不会执行
    print("这是测试代码，import 时不会显示")

# 作用：既能让模块被导入使用，又能保留模块自己的测试代码
1
2
3
4
5
6
7
8
# 实际演示
"""
文件：demo.py
"""
print(f"当前 __name__ 值：{__name__}")

# 直接运行 python demo.py → 输出：当前 __name__ 值：__main__
# import demo 导入        → 输出：当前 __name__ 值：demo

模块的搜索路径

当 import 一个模块时，Python 会按照特定顺序在指定位置搜索该模块

搜索顺序如下：

1. 当前目录（程序运行的目录）
2. PYTHONPATH 环境变量中指定的目录
3. Python 标准库目录
4. 第三方包安装目录（site-packages）

1
2
3
4
5
6
7
8
9
10
# 查看 Python 的模块搜索路径
import sys
for path in sys.path:
    print(path)

# 输出示例：
# C:\Users\xxx\project        （当前目录）
# C:\Python311\python311.zip   （标准库）
# C:\Python311\Lib             （标准库）
# C:\Python311\Lib\site-packages （第三方包）
1
2
3
4
5
# 如果需要导入不在搜索路径中的模块，可以手动添加
import sys
sys.path.append("D:/my_modules")  # 添加自定义路径

# 现在可以 import D:/my_modules 下的模块了

包的概念

包是一个包含多个模块的文件夹，通过 init.py 文件将其识别为 Python 包

当模块越来越多时，需要包（Package）来进一步组织代码。包本质上是一个包含 __init__.py 的文件夹，内部可以有多级子包和模块。

包的目录结构示例：

mypackage/          ← 包（文件夹）
	__init__.py   ← 包的标识文件（可以为空）
	module_a.py   ← 包内的模块
	module_b.py   ← 包内的模块
	subpkg/       ← 子包
		__init__.py
		module_c.py
  1. 导入包中的模块
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
"""
三种方式导入包中的模块：
"""

# 方式一：import 包名.模块名
import mypackage.module_a
mypackage.module_a.some_func()

# 方式二：from 包名 import 模块名
from mypackage import module_a
module_a.some_func()

# 方式三：from 包名.模块名 import 具体的函数/类
from mypackage.module_a import some_func
some_func()
  1. init.py 的作用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
"""
__init__.py 文件有三个作用：
1. 标识该文件夹是 Python 包（必须存在，即使为空）
2. 包被导入时，__init__.py 中的代码会自动执行
3. 可以在 __init__.py 中定义包的公共接口
"""

# __init__.py 内容示例
"""
文件：mypackage/__init__.py
"""
print(f"包 mypackage 被导入了")

# 定义包的版本
__version__ = "1.0.0"

# 控制 from mypackage import * 的行为
__all__ = ["module_a", "module_b"]  # 只导出这两个模块
1
2
3
4
5
# __all__ 的作用
from mypackage import *

# 如果 __init__.py 中定义了 __all__ = ["module_a", "module_b"]
# 那么 import * 只导入 module_a 和 module_b，其他模块不会被导入
  1. 相对导入与绝对导入
1
2
3
4
5
6
7
8
9
10
11
12
13
14
"""
包内部的模块互相引用时，可以使用：
- 绝对导入：从包根目录开始写完整路径（推荐，更清晰）
- 相对导入：使用 . 表示当前包，.. 表示上级包
"""

# 文件：mypackage/module_a.py
# 绝对导入（从包的根目录开始）
from mypackage.subpkg.module_c import helper

# 相对导入（使用 . 表示同级或上级）
from .subpkg.module_c import helper   # . 代表当前 module_a 所在的包
from . import module_b                # 导入同级的 module_b
from .. import something              # .. 代表上级包

常用标准库模块

Python 自带丰富的标准库，内置了大量功能强大的模块，被称为"自带电池"

Python 安装后即可使用的内置模块：

os	操作系统相关功能（文件路径、环境变量等）
sys	Python 解释器相关功能（命令行参数、搜索路径等）
math	数学计算（三角函数、对数、常数等）
random	生成随机数
datetime	日期和时间处理
time	时间相关的函数
json	JSON 数据的编码和解码
re	正则表达式
collections	高级容器（namedtuple、defaultdict等）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
# 示例：常用标准库的使用
import os
import sys
import math
import random
import datetime
import json

# os 模块 — 操作文件路径和系统信息
print(os.getcwd())                # 输出当前工作目录
print(os.listdir("."))            # 输出当前目录下文件列表
print(os.path.join("a", "b"))     # 输出 a\b （拼接路径）

# sys 模块 — 解释器相关
print(sys.version)                # 输出 Python 版本信息
print(sys.argv)                   # 输出命令行参数列表

# math 模块 — 数学运算
print(math.pi)                    # 输出 3.141592653589793
print(math.sqrt(16))              # 输出 4.0

# random 模块 — 随机数
print(random.randint(1, 10))      # 输出 1到10的随机整数
print(random.choice(["a","b"]))   # 输出随机元素

# datetime 模块 — 日期时间
now = datetime.datetime.now()
print(now.strftime("%Y-%m-%d %H:%M:%S"))  # 输出当前时间字符串

# json 模块 — JSON数据处理
data = {"name": "PyTs1n9", "age": 18}
json_str = json.dumps(data, ensure_ascii=False)
print(json_str)                   # 输出 {"name": "PyTs1n9", "age": 18}
parsed = json.loads(json_str)
print(parsed["name"])             # 输出 PyTs1n9

安装第三方包

通过 pip 工具安装社区贡献的第三方包，极大扩展 Python 的功能边界

pip 是 Python 的官方包管理工具（Python 3.4+ 自带），用于安装、升级、卸载第三方包。

  1. pip 常用命令

    pip install 包名 安装指定的第三方包
    pip install 包名==版本号 安装指定版本的包
    pip uninstall 包名 卸载包
    pip list 列出已安装的所有包
    pip show 包名 查看某个包的详细信息
    pip install --upgrade 包名 升级包到最新版本

1
2
3
4
5
6
# 终端 / 命令行中使用（不是在 .py 文件中）：
# pip install requests        # 安装 requests 库
# pip install numpy==1.24.0   # 安装指定版本
# pip list                    # 查看已安装的包
# pip uninstall requests      # 卸载
# pip install --upgrade pip   # 升级 pip 自身
  1. 使用第三方包
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
"""
安装第三方包后，就可以像导入标准库一样导入使用
以 requests 库为例：
"""
import requests

# 发送一个 GET 请求
response = requests.get("https://www.baidu.com")
print(response.status_code)    # 输出 200（HTTP状态码）
print(len(response.text))      # 输出页面内容的长度

# 常用的第三方包一览：
# requests   — 发送 HTTP 请求（比标准库 urllib 更简洁）
# numpy      — 科学计算、多维数组
# pandas     — 数据分析
# matplotlib — 数据可视化绘图
# flask      — 轻量级 Web 框架
# pillow     — 图像处理
  1. 使用虚拟环境（推荐）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
"""
为什么需要虚拟环境？
- 不同项目可能依赖同一个包的不同版本
- 虚拟环境可以隔离每个项目的依赖，互不影响

基本用法（终端中）：
# python -m venv venv       创建虚拟环境（生成 venv 文件夹）
# venv\Scripts\activate     激活虚拟环境（Windows）
# source venv/bin/activate  激活虚拟环境（Linux/Mac）
# deactivate                退出虚拟环境
"""

# 创建虚拟环境后，pip install 的包只安装在当前虚拟环境
# 不会影响系统全局的 Python 环境

综合练习

将模块与包的知识融会贯通，通过实际案例巩固使用方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
"""
练习一：创建一个简单的计算器包 mycalc
目录结构：
mycalc/
    __init__.py
    basic.py     基本运算
    advanced.py  高级运算
"""

# mycalc/__init__.py
from .basic import add, subtract, multiply, divide
from .advanced import power, square_root

# mycalc/basic.py
def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

def multiply(a, b):
    return a * b

def divide(a, b):
    if b == 0:
        raise ValueError("除数不能为 0")
    return a / b

# mycalc/advanced.py
def power(a, b):
    return a ** b

def square_root(a):
    if a < 0:
        raise ValueError("不能对负数开平方")
    return a ** 0.5

# 使用计算器包
"""
import mycalc

print(mycalc.add(5, 3))           # 输出 8
print(mycalc.power(2, 10))        # 输出 1024
print(mycalc.square_root(25))     # 输出 5.0
"""
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
"""
练习二：项目文件结构组织
一个典型的 Python 项目的目录结构：
"""
# myproject/              ← 项目根目录
#     main.py             ← 程序入口
#     utils/              ← 工具模块包
#         __init__.py
#         file_utils.py   ← 文件操作工具
#         str_utils.py    ← 字符串处理工具
#     models/             ← 数据模型包
#         __init__.py
#         user.py         ← 用户模型
#         product.py      ← 产品模型
#     config.py           ← 配置文件
#     requirements.txt    ← 依赖清单

# 通过合理的模块和包的划分，项目结构清晰，便于维护和协作

模块与包是 Python 项目组织代码的核心方式。掌握 import 的多种导入方式、理解 name 与 init.py 的作用、熟悉标准库与 pip 的使用，你就能从"写脚本"迈向"写项目"。合理划分模块是一项重要的工程能力，良好的代码组织能让项目随着规模增长仍然保持清晰可控。

Python Study Note 系列文章

  1. Python Study Note
  2. Python 函数使用（四）
  3. Python 判断语句（二）
  4. Python 基础语法（一）
  5. Python 异常处理（七）
  6. Python 循环语句（三）
  7. Python 数据容器（五）
  8. Python 文件基础操作（六）
  9. Python 模块与包（八）
  10. Python 类型注解（十）
  11. Python 面向对象（九）重点
  12. Python 高阶技巧（十一）