Python 模块详解

## 1. 什么是模块

### 1.1 模块的定义

**模块** 是一个包含 Python 代码的 `.py` 文件，它可以包含函数、类、变量和可执行代码。通过模块，我们可以将代码组织成逻辑单元，提高代码的可重用性和可维护性。

### 1.2 模块的作用

– **代码重用**：可以在多个程序中使用同一个模块
– **命名空间管理**：避免命名冲突
– **代码组织**：将相关功能组织在一起

### 示例：创建一个简单模块

创建 `math_operations.py` 文件：

# math_operations.py
"""这是一个数学运算模块"""

PI = 3.14159

def add(a, b):
"""返回两个数的和"""
return a + b

def multiply(a, b):
"""返回两个数的乘积"""
return a * b

def circle_area(radius):
"""计算圆的面积"""
return PI * radius * radius

# 模块的测试代码
if __name__ == "__main__":
print("测试数学运算模块:")
print(f"5 + 3 = {add(5, 3)}")
print(f"4 * 7 = {multiply(4, 7)}")
print(f"半径为3的圆面积: {circle_area(3)}")

2. 模块的分类

2.1 内置模块

内置模块是直接编译到Python解释器中的模块，它们：

• 随Python解释器一起安装

• 无需import即可使用（部分需要显式导入）

• 性能最高

• 提供最基础的功能

内置模块示例：

# builtin_modules_demo.py
"""
演示内置模块的使用
"""

# 1. 不需要导入的内置函数和类型
print("=== 不需要导入的内置功能 ===")
print(f"类型检查: {type('hello')}")
print(f"长度: {len([1, 2, 3])}")
print(f"范围: {list(range(5))}")

# 2. 需要显式导入的内置模块
import sys
import os
import time

print("\\n=== 需要导入的内置模块 ===")
print(f"Python版本: {sys.version}")
print(f"当前工作目录: {os.getcwd()}")
print(f"当前时间: {time.ctime()}")

### 2.2 第三方模块

**第三方模块**是由Python社区开发并维护的模块，它们：

– 需要通过pip等包管理器安装
– 提供专业领域的功能
– 数量庞大，覆盖几乎所有应用领域
– 质量参差不齐，需要选择成熟的模块

#### 安装第三方模块示例：

# 使用pip安装第三方模块
pip install requests
pip install numpy
pip install pandas

使用第三方模块：

import requests
import numpy as np

# 使用requests发送HTTP请求
response = requests.get("https://api.github.com")
print(f"状态码: {response.status_code}")

# 使用numpy进行数值计算
arr = np.array([1, 2, 3, 4, 5])
print(f"数组平均值: {np.mean(arr)}")

### 2.3 自定义模块

**自定义模块**是用户自己编写的模块，它们：

– 解决特定问题
– 符合项目特定需求
– 可以组织成包的形式
– 便于代码重用和维护

#### 简单的自定义模块创建：

# math_operations.py
"""这是一个数学运算模块"""

PI = 3.14159

def add(a, b):
"""返回两个数的和"""
return a + b

def multiply(a, b):
"""返回两个数的乘积"""
return a * b

def circle_area(radius):
"""计算圆的面积"""
return PI * radius * radius

print("测试数学运算模块:")
print(f"5 + 3 = {add(5, 3)}")
print(f"4 * 7 = {multiply(4, 7)}")
print(f"半径为3的圆面积: {circle_area(3)}")

## 3. 模块导入

模块声明之后就能使用吗？？？

:negative_squared_cross_mark: 无法使用，必须在需要使用的py文件中导入你所要使用的模块或者模块中的方法

你可以认为模块的导入：**将外部代码加载到当前命名空间，使其可被当前程序访问和使用。**

**把别人的工具箱搬到你的工作台上，让你能够使用里面的工具**

### 模块导入的方式概述：

# import_methods_overview.py
"""
Python 模块导入方式概览
"""

print("=== Python 模块导入方式 ===")

import_methods = [
"1. import module → 导入整个模块",
"2. import module as alias → 导入整个模块并起别名",
"3. from module import name → 从模块导入特定名称",
"4. from module import name as alias → 从模块导入特定名称并起别名",
"5. from module import * → 导入模块中的所有名称",
]

for method in import_methods:
print(method)

3.1 import module – 导入整个模块

import math_operations

# 使用模块中的内容
result = math_operations.add(10, 20)
print(f"10 + 20 = {result}")
print(f"PI的值: {math_operations.PI}")

# 特点：
# – 将整个模块对象引入当前命名空间
# – 通过 模块名.名称 的方式访问
# – 不会污染当前命名空间

3.2 import module as alias – 导入并起别名

import math_operations as mo

# 使用别名访问
result = mo.multiply(8, 9)
print(f"8 * 9 = {result}")

# 特点：
# – 为模块创建简短的别名
# – 避免命名冲突
# – 提高代码可读性
# – 遵循社区约定（如 import numpy as np）

3.3 from module import name – 导入特定名称

from math_operations import add, multiply

# 直接使用导入的函数，不需要模块名前缀
result1 = add(15, 25)
result2 = multiply(6, 7)
print(f"15 + 25 = {result1}")
print(f"6 * 7 = {result2}")

# 特点：
# – 将特定名称直接引入当前命名空间
# – 可以直接使用名称，不需要模块前缀
# – 只导入需要的名称，减少内存占用
# – 可能引起命名冲突

3.4 from module import name as alias – 导入特定名称并起别名

from math_operations import circle_area as ca

area = ca(10)
print(f"半径为10的圆面积: {area}")

# 特点：
# – 结合了特定名称导入和别名的优点
# – 避免命名冲突
# – 提高代码可读性
# – 支持非ASCII字符作为别名

3.5 from module import * – 导入所有名称

from math_operations import *

# 可以直接使用所有函数和变量
print(f"PI = {PI}")
print(f"圆的面积: {circle_area(5)}")

# 特点：
# – 导入模块中所有公共名称（不在 __all__ 中的除外）
# – 方便但危险，容易引起命名冲突
# – 不推荐在生产代码中使用
# – 私有名称（以 _ 开头）不会被导入

## 4. 模块中常用的属性

### 4.1 `__name__` 属性

– 当模块被直接运行时，`__name__` 的值为 `"__main__"`
– 当模块被导入时，`__name__` 的值为模块的名称

#### 模块导入之后，顶层的代码都会被执行一次。

**如何避免？使用 `if __name__ == "__main__"`**

# demo_module.py
def main():
"""主函数"""
print("这是主函数")

def helper_function():
"""辅助函数"""
print("这是辅助函数")

# 当直接运行该脚本时执行
if __name__ == "__main__":
print("直接运行脚本")
main()
helper_function()
print(f"模块名: {__name__}")
else:
print(f"模块被导入，模块名: {__name__}")

4.3 其他常用模块属性

# module_attributes_demo.py
"""这是一个演示模块属性的示例模块"""

MODULE_CONSTANT = "这是一个常量"

def demo_function():
"""演示函数"""
return "Hello from demo_function"

class DemoClass:
"""演示类"""
pass

# 演示模块的各种内置属性
def show_module_attributes():
print("=== 模块内置属性 ===")
print(f"1. __name__: {__name__}")
print(f"2. __doc__: {__doc__}")
print(f"3. __file__: {__file__}")
print(f"4. __package__: {__package__}")

# 查看模块中定义的所有名称
print(f"5. dir(): {[name for name in dir() if not name.startswith('_')]}")

if __name__ == "__main__":
show_module_attributes()

各个属性的详细说明：

# attributes_explanation.py
"""
模块内置属性详解：
– __name__: 模块名称
– __doc__: 模块的文档字符串
– __file__: 模块文件的完整路径
– __package__: 模块所属的包名
– __dict__: 模块的命名空间字典
– __loader__: 模块的加载器信息
"""

import os
import math_operations # 导入之前创建的模块

def explore_module(module):
"""探索模块的属性"""
print(f"\\n探索模块: {module.__name__}")
print("=" * 40)

print(f"文档字符串: {module.__doc__}")
print(f"文件路径: {getattr(module, '__file__', '内置模块或无文件')}")
print(f"包信息: {getattr(module, '__package__', '无包信息')}")

# 显示模块中定义的非私有属性
public_attrs = [attr for attr in dir(module)
if not attr.startswith('_') or attr in ['__name__', '__doc__', '__file__']]
print(f"公共属性: {public_attrs}")

if __name__ == "__main__":
# 探索不同模块的属性
explore_module(math_operations)
explore_module(os)
explore_module(explore_module.__module__) # 探索当前模块

## 5. Python中模块的导入控制

### 5.1 `__all__` 变量

`__all__` 是一个字符串列表，用于指定当使用 `from module import *` 时应该导入哪些名称。

# 在模块中定义 __all__
__all__ = ['public_function', 'PublicClass', 'PUBLIC_CONSTANT']

# mymodule.py

__all__ = ['public_function', 'PublicClass'] # 指定通过 import * 可导入的内容

def public_function():
return "这是一个公开函数"

def _private_function():
return "这是一个私有函数"

class PublicClass:
def __init__(self):
self.name = "公开类"

class _PrivateClass:
def __init__(self):
self.name = "私有类"

# 全局变量
public_variable = "公开变量"
_private_variable = "私有变量"

现在，当我们在另一个文件中使用 from mymodule import * 时，只能导入 public_function 和 PublicClass，而不会导入以下划线开头的私有函数、类和变量。

注意：其他导入方式不受 __all__ 影响。

5.2 命名约定控制导入

Python的命名约定

Python 使用命名约定来表示成员的可见性：

• 单下划线前缀 _name：表示"内部使用"，是一种弱私有约定

• 双下划线前缀 __name：名称修饰（name mangling），主要用于避免子类中的命名冲突

• 双下划线前后 __name__：魔法方法，Python 系统使用

# 保护成员 – 表示内部使用，但技术上仍可访问
_protected_variable = "我是受保护变量（单下划线）"

# 私有成员 – 名称修饰，主要用于类中
__private_variable = "我是私有变量（双下划线）"

# 在模块级别中 __ 不会被进行名称修饰，还是可以访问的

name = "张三" # 全局的，可以访问

#### 不同导入方式对命名约定的影响

– `import module`
  – 可以访问模块中的所有公共和私有成员

– `from module import *` – 导入所有名称
  – 导入模块中所有公共名称（不在 `__all__` 中的除外）
  – 私有名称（以 `_` 开头）不会被导入

> **重要说明**：
>
> – `_name`：保护成员，是一种约定，提示程序员"这是内部实现，请不要直接访问"，但Python不强制
> – `__name`：私有成员，通过名称修饰机制，使得在类外部访问变得困难（需要知道修饰后的名称），主要用于避免子类中的命名冲突
>
> **Python中没有真正意义上的私有成员**

—

## 6. 常见的内置模块

### 6.1 math 模块

**通俗理解**：math 模块就是 Python 给你准备的一个"数学工具箱"，里面装满了各种数学计算需要的工具。

#### 为什么要用 math 模块？

虽然 Python 本身能做基础数学运算（加减乘除），但遇到复杂计算时就需要 math 模块：

# 没有 math 模块
3 + 5 # ✅ 可以直接算
2 ** 3 # ✅ 可以直接算（2的3次方）

# 需要 math 模块
√25 # ❌ 不能直接算
sin(30°) # ❌ 不能直接算
log(100) # ❌ 不能直接算

使用 math 模块：

import math

print("圆周率 π =", math.pi) # 3.141592653589793
print("自然常数 e =", math.e) # 2.718281828459045
print("正无穷大 =", math.inf) # inf
print("非数字 =", math.nan) # nan

*生活比喻**：

– `math.pi` 就像标准螺丝的尺寸，大家都用这个标准
– `math.e` 就像自然生长率，很多自然现象都遵循这个规律

##### 基本数学运算 – "基础工具"

# 幂运算和开方
print("2的3次方 =", math.pow(2, 3)) # 8.0
print("e的2次方 =", math.exp(2)) # e² ≈ 7.389
print("25的平方根 =", math.sqrt(25)) # 5.0
print("8的立方根 =", math.pow(8, 1/3)) # 2.0

# 对数和指数
print("100的常用对数 =", math.log10(100)) # 2.0 (因为10²=100)
print("e³的自然对数 =", math.log(20.085)) # 3.0 (因为e³≈20.085)
print("8的以2为底对数 =", math.log2(8)) # 3.0 (因为2³=8)

**通俗理解**：

– **对数**：知道结果和底数，求指数
  – `log₁₀100 = 2` 意思是"10的几次方等于100？答案是2次方"
– **指数**：知道底数和指数，求结果
  – `10² = 100` 意思是"10的2次方等于100"

##### 取整和绝对值 – "修整工具"

**通俗理解**：

– **对数**：知道结果和底数，求指数
– `log₁₀100 = 2` 意思是"10的几次方等于100？答案是2次方"
– **指数**：知道底数和指数，求结果
– `10² = 100` 意思是"10的2次方等于100"

##### 取整和绝对值 – "修整工具"

生活比喻：

• ceil(3.2) 就像"3.2个人需要4张票"

• floor(3.8) 就像"3.8米布料只能做3件衣服"

• fabs(-5) 就像"距离不在乎方向，只在乎大小"

三角函数 – "角度测量工具"

重要提醒：math 模块中的三角函数使用弧度制，不是角度制！

# 角度转弧度
角度 = 30
弧度 = math.radians(角度) # 30° = π/6 弧度
print(f"{角度}度 = {弧度}弧度")

# 三角函数
print("sin(30°) =", math.sin(弧度)) # 0.5
print("cos(60°) =", math.cos(math.radians(60))) # 0.5
print("tan(45°) =", math.tan(math.radians(45))) # 1.0

# 反三角函数（返回弧度）
print("arcsin(0.5) =", math.degrees(math.asin(0.5)), "度") # 30°

**弧度制理解**：

– 180° = π 弧度
– 90° = π/2 弧度  
– 360° = 2π 弧度

**记忆技巧**：

– **sin**：对边/斜边
– **cos**：邻边/斜边
– **tan**：对边/邻边

##### 排列组合 – "计数工具"

# 阶乘
print("5! =", math.factorial(5)) # 5×4×3×2×1 = 120

# 组合数
def 组合数(n, k):
return math.factorial(n) // (math.factorial(k) * math.factorial(n – k))

print("从5个选2个的组合数 =", 组合数(5, 2)) # 10

实际应用：

• 阶乘：排列问题（5个人排队有几种排法）

• 组合：选择问题（5个选2个有几种选法）

6.2 random 模块

应用场景举例：

• 游戏开发：掷骰子、抽卡、怪物掉落

• 抽奖程序：随机抽取幸运用户

• 测试数据：生成随机姓名、年龄、成绩

• 模拟实验：抛硬币、概率统计

• 安全加密：生成随机密码、验证码

基本使用方法

import random # 导入随机数工具箱

# 就像你有了一个魔法骰子，想扔就扔

常用函数

import random

# random.random() – 生成 0-1 之间的小数
print("0-1随机小数:", random.random())

# random.randint(a, b) – 生成整数范围内的随机数[a,b]
print("1-10随机整数:", random.randint(1, 10))

# random.uniform(a, b) – 生成小数范围内的随机数
print("1.5-5.5随机小数:", random.uniform(1.5, 5.5)) # 在 1.5米 到 5.5米 之间随机选一个高度

# random.choice(列表) – 从列表中随机选一个
水果 = ["苹果", "香蕉", "橙子", "葡萄"]
print("随机水果:", random.choice(水果))

# random.choices(列表, k=数量) – 随机选择多个（可重复）
print("随机选3个水果（可重复）:", random.choices(水果, k=3))

# random.sample(列表, k=数量) – 随机选择多个（不重复）
print("随机选2个水果（不重复）:", random.sample(水果, k=2))

# random.shuffle(列表) – 打乱列表顺序
牌组 = ["红桃A", "红桃2", "红桃3", "红桃4"]
random.shuffle(牌组)
print("洗牌后:", 牌组) # 洗牌的功能

加权随机选择

import random

# 不同奖品的中奖概率不同
奖品和权重 = [
("特等奖", 1), # 权重1 – 很难中
("一等奖", 5), # 权重5
("二等奖", 15), # 权重15
("三等奖", 30), # 权重30
("谢谢参与", 49) # 权重49 – 很容易中
]

奖品列表 = [奖品 for 奖品, 权重 in 奖品和权重]
权重列表 = [权重 for 奖品, 权重 in 奖品和权重]

中奖结果 = random.choices(奖品列表, weights=权重列表, k=10)
print("10次抽奖结果:", 中奖结果)

### 6.3 os 模块

**通俗理解**：os 模块就是 Python 给你的一个"操作系统遥控器"，让你能在代码里直接操作电脑的各种功能。

**就像**：

– 🗂️ **文件管理器** – 创建、删除、移动文件和文件夹
– 📁 **路径导航** – 告诉你文件在哪里，怎么找到它们
– ⚙️ **系统设置** – 获取电脑信息、环境变量
– 🖥️ **命令执行** – 在代码里运行系统命令

#### 为什么使用 os 模块

– 文件管理：批量重命名、整理文件
– 路径处理：跨平台的文件路径操作
– 系统信息：获取当前用户、工作目录
– 进程管理：启动其他程序
– 环境配置：读取系统环境变量

#### 基本使用方法

import os

# os.getcwd() – 获取当前工作目录
print("我现在在哪个文件夹:", os.getcwd())

# os.chdir(path) – 改变当前目录
os.chdir("C:\\\\Users") # 跳到 Users 文件夹
print("跳转后我在:", os.getcwd())

# os.path.join() – 智能拼接路径
文件夹 = "C:\\\\Users"
文件名 = "document.txt"
完整路径 = os.path.join(文件夹, 文件名)
print("完整路径:", 完整路径) # C:\\Users\\document.txt

# os.path.exists() – 检查路径是否存在
if os.path.exists("C:\\\\Windows"):
print("Windows文件夹存在")
else:
print("找不到Windows文件夹")

# os.path.isfile() 和 os.path.isdir() – 检查是否是文件、是否是文件夹
路径 = "C:\\\\Windows\\\\System32"
print("是文件吗?", os.path.isfile(路径)) # False
print("是文件夹吗?", os.path.isdir(路径)) # True

# os.listdir() – 列出目录内容
当前目录内容 = os.listdir(".") # . 表示当前目录
print("当前目录有什么:")
for 项目 in 当前目录内容:
print(" -", 项目)

# os.mkdir() – 创建目录
os.mkdir("我的新文件夹") # 创建文件夹
os.makedirs("一级/二级/三级") # 创建多级文件夹

# os.rename() – 重命名文件
os.rename("旧名字.txt", "新名字.txt")

# os.remove() – 删除文件
os.remove("要删除的文件.txt")

# os.rmdir() – 删除空目录
os.rmdir("空的文件夹")

# os.name – 操作系统类型
print("操作系统类型:", os.name)
# 'nt' = Windows, 'posix' = Linux/macOS

# os.environ – 环境变量
print("系统路径:", os.environ.get('PATH'))
print("用户名:", os.environ.get('USERNAME'))

# os.getlogin() – 当前用户名
print("当前登录用户:", os.getlogin())

# os.path.getsize() – 获取文件大小
大小 = os.path.getsize("某个文件.txt")
print(f"文件大小: {大小} 字节")

#os.basename() os.filename()

 os.walk()

 什么是 os.walk？

os.walk()` 是一个强大的目录遍历函数，它可以递归地遍历指定目录及其所有子目录，生成目录树中每个目录的信息。

for root, dirs, files in os.walk(top_path):
# root: 当前正在遍历的目录路径

# dirs: 当前目录下的子目录列表

# files: 当前目录下的文件列表

import os
遍历当前目录及其所有子目录
for root, dirs, files in os.walk("."):
print(f"当前目录: {root}")
print(f"子目录: {dirs}")
print(f"文件: {files}")
print("-" * 40)