<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta name="description" content="深入讲解模块与包import自定义模块包结构的核心内容与关键技术，属于Python编程基础的函数与模块方向">
<title>模块与包：import、自定义模块、包结构 函数与模块 Python编程基础-AI全栈-AIQZ.CC</title>
<link rel="icon" type="image/svg+xml" href="/favicon.svg">
<link rel="stylesheet" href="/css/chapter.css?v=20260612e">
<link rel="stylesheet" href="/vendor/katex/katex.min.css">
<script src="/vendor/katex/katex.min.js"></script>
<script src="/vendor/katex/auto-render.min.js"></script>
</head>
<body>
<div class="app-container">
  <aside class="left-sidebar" id="leftSidebar">
    <div class="sidebar-content">
      <nav class="nav-section">
        <div class="nav-header">课程目录</div>
        <!--#include virtual="/ssi/nav/course-nav.html" -->
      </nav>
    </div>
  </aside>
  <main class="main-content">
    <article class="content-area">
      <h1>模块与包：import、自定义模块、包结构</h1><div class="divider"></div>

<h2>一句话概述</h2>
<p>模块（Module）和包（Package）是 Python 的代码组织体系——<strong>模块</strong>是一个 <code>.py</code> 文件，<strong>包</strong>是一个包含 <code>__init__.py</code> 的文件夹。通过 <code>import</code> 语句，你可以把一个模块的所有函数、类、变量引入到当前代码中，实现&quot;写一次、到处用&quot;。你可以把模块想象成一本书的<strong>章节</strong>，包是一整本<strong>书</strong>，<code>import</code> 是你翻到某一页引用内容的方式。在 AI 开发中，<code>import numpy</code>、<code>import torch</code>、<code>from sklearn.model_selection import train_test_split</code>——每一个 <code>import</code> 都在引入别人写好的模块，让你站在巨人的肩膀上。</p>
<blockquote class="highlight-box"><strong>💡 核心要点：</strong>①<code>import 模块名</code> 引入整个模块，用 <code>模块名.函数()</code> 调用 ②<code>from 模块 import 名称</code> 直接引入指定内容，无需模块名前缀 ③<code>import 模块 as 别名</code> 给模块起花名，如 <code>import numpy as np</code> ④自定义模块就是自己写的 <code>.py</code> 文件，文件名即模块名 ⑤包是含 <code>__init__.py</code> 的目录，用于组织多层模块结构</blockquote>


<h2>教学与演示</h2>
<h3>一、模块的本质——一个 .py 文件就是模块</h3>
<p><strong>是什么</strong>：模块（Module）是 Python 代码组织的基本单元——<strong>任何 <code>.py</code> 文件都是一个模块</strong>。当你 <code>import 模块名</code> 时，Python 找到对应的 <code>.py</code> 文件，执行其中的代码，然后把它变成一个&quot;模块对象&quot;，你可以通过这个对象访问文件中定义的所有函数、类和变量。文件名去掉 <code>.py</code> 后缀就是模块名。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 你写的每一个 <code>.py</code> 文件都是一个&quot;工具箱&quot;（模块）。<code>import</code> 就是&quot;把这个工具箱搬过来用&quot;。工具箱上的标签（文件名）就是模块名，工具（函数/变量）就是里面的内容。你自己写的 <code>utils.py</code> 和别人的 <code>numpy</code> 在这个层面上没有任何区别——都是模块，都用 <code>import</code> 引入。</blockquote>


<p><strong>为什么</strong>：模块解决了&quot;所有代码写一个文件&quot;的噩梦。一个万行代码的单文件 vs 一百个百行代码的模块——后者每个人都能独立理解、独立测试、独立复用。Python 标准库就是用好模块的典范——<code>math</code> 管数学、<code>os</code> 管系统、<code>json</code> 管数据格式，各司其职。在 AI 中，一个好项目至少会拆成 <code>data.py</code>（数据加载）、<code>model.py</code>（模型定义）、<code>train.py</code>（训练逻辑）、<code>utils.py</code>（工具函数）等模块。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 你搬家如果把所有东西塞进一个大箱子——到新家翻半天找不到电饭锅。合理做法是分箱：厨房用品一箱、书一箱、衣服一箱——标签贴好。代码也一样——<code>import model</code> 就是用&quot;模型箱&quot;里的东西，<code>import data</code> 就是用&quot;数据箱&quot;里的东西。分模块就是给代码&quot;贴标签装箱&quot;。</blockquote>


<p><strong>怎么做</strong>：</p>
<pre data-runnable="code-demo-1"><code class="language-python">import numpy as np

# ====== 1. import 的三种写法 ======

# 方式一：import 模块名 —— 用完整路径访问
import math                                    # 引入标准库的 math 模块

print(&quot;math.pi     =&quot;, math.pi)               # 3.1415926... — 用 模块名.属性 访问
print(&quot;math.sqrt(9)=&quot;, math.sqrt(9))           # 3.0
print(&quot;math.sin(0)=&quot;, math.sin(0))             # 0.0

# 方式二：import 模块 as 别名 —— 给长名字起花名
import numpy as np                            # 业界约定：numpy 别名为 np

data = np.array([1, 2, 3, 4, 5])
print(f&quot;\nnumpy 数组: {data}&quot;)                # [1 2 3 4 5]
print(f&quot;均值: {np.mean(data)}&quot;)               # 3.0 — np 比 numpy 打字快多了
print(f&quot;标准差: {np.std(data):.2f}&quot;)          # 1.41

# 方式三：from 模块 import 名称 —— 直接引入，不用前缀
from math import sqrt, pi, sin                # 直接导入 sqrt, pi, sin

print(f&quot;\nsqrt(16) = {sqrt(16)}&quot;)             # 4.0 — 直接用，不需要 math.
print(f&quot;pi      = {pi}&quot;)                      # 3.14159...
print(f&quot;sin(pi/2) = {sin(pi/2)}&quot;)             # 1.0

# ====== 2. import 的本质：执行模块代码 ======

# import 语句做了三件事：
# ① 找到模块文件（在 sys.path 中搜索）
# ② 执行模块文件中的代码（定义函数、赋值变量等）
# ③ 把执行结果封装成一个命名空间（模块对象）

# 你可以看到模块有哪些内容：
print(&quot;\n=== math 模块的内容 ===&quot;)
print(f&quot;math 模块中有 {len(dir(math))} 个名字&quot;)
# dir() 列出模块中所有公开的名字
math_names = [name for name in dir(math) if not name.startswith(&quot;_&quot;)]
print(f&quot;公开名字（前10个）: {math_names[:10]}&quot;)

# ====== 3. 模块只执行一次——重复 import 不重复执行 ======

# Python 会缓存已导入的模块（在 sys.modules 字典中）
import sys                                    # sys 模块可以查看已导入的模块
print(f&quot;\n已导入模块数量: {len(sys.modules)}&quot;)
print(f&quot;math 是否已导入: {'math' in sys.modules}&quot;)  # True

# 重复 import 不会重新执行模块代码，直接返回缓存的模块对象
import math  # 这次 import 不执行 math.py 的代码，直接用缓存

# ====== 4. AI 场景：典型的 import 语句 ======

# AI 项目的标准 import 模式
# 注意：这些 import 不会真正执行（环境中可能没装这些库）
# 这里演示的是 import 的组织结构

# 核心数值计算库
# import numpy as np

# 数据分析和可视化
# import pandas as pd
# import matplotlib.pyplot as plt

# 深度学习框架
# import torch
# import torch.nn as nn
# import torch.nn.functional as F

# 从子模块导入特定函数的常见模式
# from sklearn.model_selection import train_test_split
# from torch.utils.data import DataLoader, Dataset

print(&quot;\n=== AI 项目的典型 import 结构 ===&quot;)
print(&quot;# 数据 → import numpy as np, import pandas as pd&quot;)
print(&quot;# 模型 → import torch, import tensorflow as tf&quot;)  
print(&quot;# 评估 → from sklearn.metrics import accuracy_score&quot;)
print(&quot;# 可视化 → import matplotlib.pyplot as plt&quot;)
print(&quot;# 工具 → from utils import set_seed, Timer&quot;) 

# ====== 5. 用 numpy 演示模块功能的组合使用 ======

# 模拟：用不同的模块功能完成 AI 数据预处理流水线
# 生成模拟的输入特征和目标值
np.random.seed(42)
X = np.random.randn(100, 3)                   # 100 个样本，3 个特征
y = X[:, 0] * 0.5 + X[:, 1] * 0.3 + np.random.randn(100) * 0.1  # 线性关系+噪声

# 使用 numpy 的各种功能
mean_X = np.mean(X, axis=0)                    # 每列均值
std_X = np.std(X, axis=0)                      # 每列标准差
X_norm = (X - mean_X) / std_X                  # Z-score 标准化

# 计算相关系数（模拟）
corr = np.corrcoef(X.T)                        # 特征间的相关系数矩阵

print(f&quot;\n=== 数据预处理演示 ===&quot;)
print(f&quot;原始数据形状: {X.shape}&quot;)              # (100, 3)
print(f&quot;特征均值: {np.round(mean_X, 3)}&quot;)
print(f&quot;特征标准差: {np.round(std_X, 3)}&quot;)
print(f&quot;标准化后均值: {np.round(np.mean(X_norm, axis=0), 3)}&quot;)  # 应该接近 [0,0,0]
print(f&quot;相关系数矩阵:\n{np.round(corr, 3)}&quot;)</code></pre><p><strong>什么用</strong>：<code>import</code> 是你在 AI 学习中每天都会打几十次的词。<code>import numpy</code> 让你拥有高性能数组运算，<code>import torch</code> 让你构建神经网络，<code>import transformers</code> 让你用 BERT/GPT——这些&quot;魔法&quot;的背后都是模块机制。理解 import 的三种写法和各自适用场景：<code>import module</code> 用于大型库避免命名冲突，<code>from module import name</code> 用于频繁使用的小功能（如 <code>from math import sqrt</code>），<code>import module as alias</code> 用于统一社区约定（<code>np</code>、<code>pd</code>、<code>plt</code>、<code>tf</code>）。</p>
<h3>二、自定义模块——写自己的工具箱</h3>
<p><strong>是什么</strong>：自定义模块就是你自己写的 <code>.py</code> 文件。不需要任何特殊语法——创建一个 <code>utils.py</code>，在里面定义函数和变量，然后在另一个 <code>.py</code> 文件中 <code>import utils</code>，就能使用 <code>utils</code> 中定义的所有内容。文件名就是模块名，Python 自动帮你完成一切。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 创建一个 <code>mytools.py</code>，写上你常用的函数——清洗数据、画图、发邮件……然后 <code>import mytools</code> 就能在任何脚本中用。这和 <code>import numpy</code> 一模一样——只不过 numpy 是别人写的（几万行），<code>mytools</code> 是你自己写的（几十行）。Python 不区分&quot;官方模块&quot;和&quot;你的模块&quot;——都是模块，统一用 <code>import</code>。</blockquote>


<p><strong>为什么</strong>：自定义模块是你从&quot;写脚本&quot;到&quot;做项目&quot;的质变标志。当你在三个不同脚本里复制粘贴了同样的 <code>normalize()</code> 函数三次时，就该把它提取成一个模块了。在 AI 项目中，自定义模块让团队协作成为可能——张三写 <code>data_loader.py</code>，李四写 <code>model.py</code>，王五写 <code>train.py</code>，三人并行开发，用一个 <code>main.py</code> 把所有模块串起来。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 没有自定义模块——5000 行代码堆在一个文件里，每次找函数要 Ctrl+F 搜索。有了自定义模块——<code>import data_loader</code> 就知道数据加载逻辑在哪，<code>import model</code> 就知道模型定义在哪。这就像你家的收纳——袜子抽屉、T恤抽屉、裤子抽屉——而不是把所有衣服全塞衣柜。</blockquote>


<p><strong>怎么做</strong>：</p>
<pre data-runnable="code-demo-2"><code class="language-python">import numpy as np

# 由于我们是在交互环境中演示，无法真的创建多个 .py 文件
# 所以我们用「模拟」的方式来理解自定义模块的工作机制

# ====== 1. 模拟：假设有一个 utils.py 文件 ======

# === 以下是 utils.py 的内容（想象它在另一个文件里） ===
# utils.py:
#   def normalize(data):
#       d_min, d_max = min(data), max(data)
#       return [(x - d_min) / (d_max - d_min) for x in data]
#
#   def train_val_split(data, ratio=0.8):
#       split = int(len(data) * ratio)
#       return data[:split], data[split:]
#
#   PI = 3.1415926
#
#   def _private_helper():          # 下划线开头 = 约定私有
#       pass
# ========================================================

# 在另一个文件中这样使用：
# import utils
# train, val = utils.train_val_split(my_data)
# 或
# from utils import normalize, PI
# result = normalize(my_data)

# ====== 2. 模拟自定义模块的行为 ======

# 创建一个&quot;模拟&quot;的模块对象（dict 模拟模块的命名空间）
utils_module = {                               # 模拟 utils 模块
    &quot;normalize&quot;: lambda data: [(x - min(data)) / (max(data) - min(data)) for x in data],
    &quot;train_val_split&quot;: lambda data, ratio=0.8: (
        data[:int(len(data) * ratio)],
        data[int(len(data) * ratio):]
    ),
    &quot;PI&quot;: 3.1415926,
    &quot;_private_helper&quot;: lambda: &quot;This is private&quot;
}

# 模拟 import utils
utils = type(&quot;utils&quot;, (), utils_module)()     # 动态创建模块对象

# 使用模块中的函数
data = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
normalized = utils.normalize(data)
train, val = utils.train_val_split(data, 0.7)

print(f&quot;原始数据: {data}&quot;)
print(f&quot;标准化:   {[round(x, 2) for x in normalized]}&quot;)
print(f&quot;训练集:   {train}&quot;)
print(f&quot;验证集:   {val}&quot;)
print(f&quot;PI 常量:  {utils.PI}&quot;)

# ====== 3. 模块的&quot;私有&quot;约定 ======

# Python 没有真正的 private，但用下划线约定私有
# _single_leading_underscore: &quot;我建议你不要从外部使用&quot;
# __double_leading_underscore: Python 会自动做名称改编（name mangling）

# dir() 可以看到私有名字
all_names = [n for n in dir(utils) if not n.startswith(&quot;__&quot;)]
print(f&quot;\n模块中的名字: {all_names}&quot;)

# ====== 4. 模块的 __name__ 变量 ======

# 每个模块都有一个特殊的 __name__ 变量
# 当模块被直接运行（python xxx.py）时，__name__ = &quot;__main__&quot;
# 当模块被 import 时，__name__ = 模块名（文件名）

def simulate_module_execution():
    &quot;&quot;&quot;模拟一个模块文件的执行&quot;&quot;&quot;
    module_name = &quot;utils&quot;                      # 模拟被 import 时的 __name__
    is_main = False                            # 模拟被 import，所以不是 main

    print(f&quot;\n=== 模拟模块执行 ===&quot;)
    print(f&quot;__name__ = '{module_name}'&quot;)
    if is_main:
        print(&quot;（直接运行模式——执行测试代码）&quot;)
    else:
        print(&quot;（被 import 模式——不执行测试代码）&quot;)

simulate_module_execution()

# 实际中，模块文件末尾常常有：
# if __name__ == &quot;__main__&quot;:
#     print(&quot;这段代码只在直接运行这个文件时执行&quot;)
#     test_normalize()  # 测试函数
#     test_split()      # 测试函数

# ====== 5. AI 场景：组织一个 AI 项目的模块结构 ======

# 项目结构示意：
# my_ml_project/
#   ├── main.py          # 入口：串起所有模块
#   ├── data_loader.py   # 数据加载和预处理
#   ├── model.py         # 模型定义
#   ├── train.py         # 训练逻辑
#   └── utils.py         # 通用工具函数

# 模拟：main.py 的内容
print(&quot;\n=== 模拟 main.py ===&quot;)
print(&quot;# main.py:&quot;)
print(&quot;# from data_loader import load_data&quot;)
print(&quot;# from model import build_model&quot;) 
print(&quot;# from train import train_one_epoch&quot;)
print(&quot;#&quot;)
print(&quot;# data = load_data('dataset.csv')&quot;)
print(&quot;# model = build_model(input_dim=10)&quot;)  
print(&quot;# train_one_epoch(model, data)&quot;)

# 模拟 data_loader.py 的功能
def load_data(source=&quot;dataset.csv&quot;, n_samples=100):
    &quot;&quot;&quot;模拟数据加载函数&quot;&quot;&quot;
    X = np.random.randn(n_samples, 5)          # 100 个样本，5 个特征
    y = (X[:, 0] + X[:, 1] &gt; 0).astype(int)   # 简单的二分类标签
    print(f&quot;  ✅ 从 {source} 加载 {n_samples} 条数据&quot;)
    return X, y

# 模拟 model.py 的功能
def build_model(input_dim=5):
    &quot;&quot;&quot;模拟模型构建函数&quot;&quot;&quot;
    print(f&quot;  ✅ 构建模型：输入维度={input_dim}&quot;)
    # 返回一个&quot;模型&quot;（用字典模拟）
    return {
        &quot;weights&quot;: np.random.randn(input_dim),
        &quot;bias&quot;: np.random.randn(),
        &quot;input_dim&quot;: input_dim
    }

# 模拟 train.py 的功能
def train_one_epoch(model, data):
    &quot;&quot;&quot;模拟训练一个 epoch&quot;&quot;&quot;
    X, y = data
    predictions = X @ model[&quot;weights&quot;] + model[&quot;bias&quot;]
    loss = np.mean((predictions - y) ** 2)
    print(f&quot;  ✅ 训练完成，损失: {loss:.4f}&quot;)
    return loss

# ====== 用 import 逻辑串联各模块 ======
print(f&quot;\n=== 执行训练流水线 ===&quot;)
X, y = load_data(&quot;customers.csv&quot;, 100)         # 模拟 data_loader.load_data()
model = build_model(input_dim=5)               # 模拟 model.build_model()
loss = train_one_epoch(model, (X, y))          # 模拟 train.train_one_epoch()
print(f&quot;最终损失: {loss:.4f}&quot;)</code></pre><p><strong>什么用</strong>：在 AI 实战中，自定义模块是项目组织的基础。PyTorch 项目中常见的 <code>dataset.py</code>（自定义数据集类）、<code>model.py</code>（定义网络结构）、<code>engine.py</code>（训练和评估循环）、<code>utils.py</code>（损失函数、指标计算）都是自定义模块。好的模块划分让你能快速定位代码：想改数据加载找 <code>dataset.py</code>，想改网络结构找 <code>model.py</code>，想添加新的评估指标找 <code>utils.py</code>。从写单文件脚本到拆分为多模块项目，这是从新手到合格开发者的关键一步。</p>
<h3>三、包——模块的文件夹组织形式</h3>
<p><strong>是什么</strong>：包（Package）是一个包含 <code>__init__.py</code> 文件的<strong>文件夹</strong>。包把多个相关模块组织在一起，形成层次化的命名空间。大型库（如 numpy、torch、transformers）都是包（甚至是嵌套包）。包中的模块用点号 <code>.</code> 访问：<code>包名.子包名.模块名</code>。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 如果说模块是一个工具箱，包就是工具柜。一个工具箱放不下的工具，分成多个工具箱，放在一个柜子里（包）。<code>__init__.py</code> 就像柜子上的标签——它告诉 Python &quot;这个不是普通文件夹，这是一个装模块的包&quot;。然后你可以 <code>from 工具柜.螺丝刀工具箱 import 十字螺丝刀</code>，不用把所有工具摊在地上找。</blockquote>


<p><strong>为什么</strong>：当项目规模增长到几十个模块时，平铺所有 <code>.py</code> 文件会变得混乱。包提供了层次化组织——<code>torch.nn</code> 是所有神经网络模块，<code>torch.optim</code> 是所有优化器，<code>torch.utils.data</code> 是数据加载工具。这种层次结构让开发者能通过模块路径直观理解代码的归属。<code>__init__.py</code> 还可以控制 <code>from 包 import *</code> 的行为，隐藏内部实现细节。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 一个项目如果只有一个文件夹、50 个 <code>.py</code> 文件混在一起——找文件像大海捞针。有了包，<code>models/cnn.py</code> 告诉你这是 CNN 模型，<code>models/rnn.py</code> 告诉你这是 RNN 模型，<code>data/dataloader.py</code> 告诉你这是数据加载——每个模块的路径就是它的身份信息。</blockquote>


<p><strong>怎么做</strong>：</p>
<pre data-runnable="code-demo-3"><code class="language-python">import numpy as np

# 由于无法创建真实的文件系统结构，我们用代码模拟包的组织和使用

# ====== 1. 包的目录结构示意 ======

# my_ai_lib/                          # 这个文件夹是一个包（因为有 __init__.py）
#   ├── __init__.py                   # 包的标识文件（可以为空）
#   ├── models/                       # 子包：模型相关
#   │   ├── __init__.py
#   │   ├── cnn.py                    # CNN 模型模块
#   │   └── rnn.py                    # RNN 模型模块
#   ├── data/                         # 子包：数据处理
#   │   ├── __init__.py
#   │   └── loader.py                 # 数据加载模块
#   └── utils.py                      # 工具模块

# ====== 2. 模拟包的导入方式 ======

# 方式一：import 包.子包.模块 —— 完整路径
# import my_ai_lib.models.cnn
# model = my_ai_lib.models.cnn.ConvNet()

# 方式二：from 包.子包 import 模块 —— 简洁路径
# from my_ai_lib.models import cnn
# model = cnn.ConvNet()

# 方式三：from 包.子包.模块 import 具体名称 —— 最直接
# from my_ai_lib.models.cnn import ConvNet
# model = ConvNet()

# ====== 3. __init__.py 的作用 ======

# __init__.py 有四个核心作用：
# ① 标识这是一个包（Python 3.3+ 隐式命名空间包不需要，但仍建议保留）
# ② 初始化包——import 包时自动执行 __init__.py 的代码
# ③ 控制 from 包 import * 的行为（通过 __all__ 列表）
# ④ 简化导入路径——在 __init__.py 中提前导入常用的子模块

# 模拟：__init__.py 的典型内容
print(&quot;=== 模拟 __init__.py 的内容 ===&quot;)
print(&quot;&quot;&quot;
# my_ai_lib/__init__.py
__version__ = &quot;0.1.0&quot;                # 包的版本号
__author__ = &quot;你的名字&quot;              # 包的作者

# 定义 from my_ai_lib import * 时导入的名字
__all__ = [&quot;models&quot;, &quot;data&quot;, &quot;utils&quot;]

# 预先导入常用模块，方便用户使用
# from .models import cnn, rnn      # 用户可以直接 from my_ai_lib import cnn
# from .data import loader           # 用户可以直接 from my_ai_lib import loader
&quot;&quot;&quot;)

# ====== 4. 相对导入：包内部的互相引用 ======

# 在包内部，模块之间引用用相对导入（点号表示层级）
# .         → 当前包
# ..        → 上级包
# ...       → 上上级包

# 例如在 models/cnn.py 中：
# from ..data.loader import DataLoader    # .. = 上级包(my_ai_lib)
# from ..utils import normalize           # 引用同级的 utils 模块
# from .rnn import LSTMModel              # .   = 当前包(my_ai_lib.models)

print(&quot;\n=== 模拟包内相对导入 ===&quot;)
print(&quot;# 在 my_ai_lib/models/cnn.py 中：&quot;)
print(&quot;# from ..utils import normalize       ← 相对导入上级包的 utils&quot;)
print(&quot;# from .rnn import RNNModel            ← 相对导入同级的 rnn 模块&quot;)
print(&quot;#&quot;)
print(&quot;# 在 my_ai_lib/data/loader.py 中：&quot;)
print(&quot;# from ..utils import set_seed         ← 相对导入上级包的 utils&quot;)

# ====== 5. AI 场景：模拟 tensorflow/pytorch 的包结构 ======

# 真实 AI 库的包结构极其复杂，但 import 逻辑一致：
# import torch                           # 导入 PyTorch 主包
# import torch.nn                        # 导入神经网络子包
# import torch.nn.functional as F        # 导入函数式子包并起别名
# from torch.optim import Adam           # 从 optimizer 包导入 Adam

# 模拟：构建一个简化版 AI 库的包结构
print(&quot;\n=== AI 库的典型 import 模式 ===&quot;)
print(&quot;# 数值计算&quot;)
print(&quot;# import numpy as np                   ← 核心数值库&quot;)
print(&quot;# from numpy.linalg import inv         ← 线性代数子模块&quot;)
print(&quot;&quot;)
print(&quot;# 深度学习&quot;)
print(&quot;# import torch                         ← 主包&quot;)
print(&quot;# import torch.nn as nn                ← 神经网络子包（起别名）&quot;)
print(&quot;# import torch.nn.functional as F      ← 函数式子包（起别名）&quot;)
print(&quot;# from torch.optim import Adam         ← 优化器子包中的类&quot;)
print(&quot;&quot;)
print(&quot;# 数据处理&quot;)
print(&quot;# from torch.utils.data import DataLoader ← 数据工具子包&quot;)
print(&quot;# import torchvision.transforms as T   ← 视觉数据增强子包&quot;)

# ====== 6. 用 numpy 演示包的层次结构 ======

# numpy 是一个典型的包——可以查看其结构
print(&quot;\n=== numpy 包的层次结构示例 ===&quot;)
print(&quot;import numpy           → 主包，提供核心功能&quot;)
print(&quot;from numpy import linalg → 线性代数子模块：inv(), det(), norm()&quot;)
print(&quot;from numpy import random → 随机数生成子模块：randn(), seed()&quot;)

# 演示：访问 numpy 子模块的功能
A = np.array([[1, 2], [3, 4]])                 # 主包功能
det = np.linalg.det(A)                         # 子模块功能
eigenvalues = np.linalg.eigvals(A)             # 子模块功能
random_nums = np.random.randn(5)               # 子模块功能

print(f&quot;\n矩阵 A:\n{A}&quot;)
print(f&quot;行列式: {det}&quot;)
print(f&quot;特征值: {np.round(eigenvalues, 3)}&quot;)
print(f&quot;随机数: {np.round(random_nums, 3)}&quot;)</code></pre><p><strong>什么用</strong>：理解包结构让你能看懂任何 AI 库的 import 语句。<code>from transformers import BertModel</code> 为什么能工作？因为 <code>transformers</code> 包的 <code>__init__.py</code> 中导入了 <code>BertModel</code>。<code>torch.nn</code> 为什么不需要 <code>import torch.nn</code> 就能用？因为导入 <code>torch</code> 时，<code>torch/__init__.py</code> 已经导入了 <code>nn</code> 子模块。当你自己开发 AI 工具库或开源项目时，合理的包结构是专业性的体现——让用户用几行 import 就能用上你的库。</p>
<h3>四、模块搜索路径与常见陷阱</h3>
<p><strong>是什么</strong>：当你 <code>import 模块名</code> 时，Python 在 <code>sys.path</code> 列表中依次搜索模块文件。<code>sys.path</code> 是一个字符串列表，包含了当前目录、<code>PYTHONPATH</code> 环境变量中的路径、Python 标准库路径和第三方库安装路径。搜索是顺序的——找到第一个匹配的就停止。如果都找不到，报 <code>ModuleNotFoundError</code>。</p>
<blockquote class="plain-explain"><strong>大白话</strong> Python 找模块就像你在书架找书——先在当前抽屉（当前目录）找，没找到去图书馆特定的几个书架（标准库和 site-packages）找，还没找到就去你指定的储藏室（PYTHONPATH）找。如果所有地方都没有，Python 两手一摊：&quot;ModuleNotFoundError: No module named &#39;xxx&#39;——你说的那本书不存在&quot;。</blockquote>


<p><strong>为什么</strong>：理解搜索路径能解决最常见的 <code>ModuleNotFoundError</code> 问题：&quot;我明明写了 utils.py，为什么 import utils 报错？&quot;——因为你的 <code>utils.py</code> 不在 Python 的搜索路径中。或者&quot;我装了两个版本的 numpy，import 到的是哪个？&quot;——是 <code>sys.path</code> 中最先匹配到的那个。在 AI 开发中，CUDA 版本冲突、多个 conda 环境等问题本质上都是模块搜索路径出了错。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 新人最常见的困惑：我在桌面创建了 <code>mymodule.py</code>，然后在 Jupyter 里 <code>import mymodule</code>，结果报错找不到。原因是 Jupyter 的当前工作目录可能不在桌面。解决方法：①把 <code>.py</code> 文件放在 Jupyter 的工作目录下；②或者 <code>import sys; sys.path.append(&quot;/Users/xxx/Desktop&quot;)</code>；③更好的是创建正规的项目结构。</blockquote>


<p><strong>怎么做</strong>：</p>
<pre data-runnable="code-demo-4"><code class="language-python">import numpy as np
import sys                                      # sys 模块可以查看和修改搜索路径

# ====== 1. 查看 Python 的模块搜索路径 ======

print(&quot;=== sys.path（模块搜索路径） ===&quot;)
for i, path in enumerate(sys.path[:5]):        # 只显示前 5 个
    print(f&quot;  [{i}] {path}&quot;)
print(f&quot;  ... 总共有 {len(sys.path)} 个搜索路径&quot;)

# 搜索顺序（简化）：
# ① 当前脚本所在目录
# ② PYTHONPATH 环境变量
# ③ Python 标准库目录
# ④ site-packages（第三方库安装位置）

# ====== 2. 已导入模块的缓存——sys.modules ======

# Python 会把已导入的模块存在 sys.modules 字典中
# 重复 import 不会重新加载——直接返回缓存

module_count = len(sys.modules)
print(f&quot;\n=== sys.modules 已缓存的模块 ===&quot;)
print(f&quot;共 {module_count} 个模块已被导入&quot;)
# 显示几个常见的已导入模块
common_modules = [&quot;os&quot;, &quot;sys&quot;, &quot;math&quot;, &quot;numpy&quot;]
for mod_name in common_modules:
    if mod_name in sys.modules:
        print(f&quot;  {mod_name}: 已缓存 ✅&quot;)
    else:
        print(f&quot;  {mod_name}: 未导入&quot;)

# ====== 3. 常见陷阱：命名冲突 ======

# ⚠️ 如果你创建的模块名和标准库/第三方库同名，你的模块会被优先导入（当前目录优先）

# 比如你在项目中创建了一个 math.py → import math 会导入你的 math.py
# 而不是标准库的 math！这是个巨大的坑。

# 模拟：用字典模拟模块命名空间
print(&quot;\n=== 命名冲突示例 ===&quot;)
print(&quot;# ❌ 不要创建这些文件名的模块：&quot;)
print(&quot;#    math.py, random.py, json.py, email.py&quot;)
print(&quot;#    它们会和标准库同名，导致标准库无法使用！&quot;)
print(&quot;# ✅ 用更具体的名字：&quot;)
print(&quot;#    my_math_utils.py, data_random.py, config_parser.py&quot;)

# ====== 4. 模块的动态导入 ======

# 有时需要根据条件决定导入哪个模块
# 使用 importlib 模块（生产中更推荐）
# import importlib
# module = importlib.import_module(&quot;numpy&quot;)

# 简单场景也可以用 __import__
module_name = &quot;math&quot; if True else &quot;numpy&quot;
mod = __import__(module_name)
print(f&quot;\n动态导入 {module_name}:&quot;)
print(f&quot;  {module_name}.pi = {mod.pi}&quot;)        # 3.1415926...

# ====== 5. AI 场景：模块导入的最佳实践 ======

print(&quot;\n=== AI 项目 import 最佳实践 ===&quot;)
print(&quot;&quot;&quot;
1. 所有 import 放文件顶部（PEP 8 规范）
   ✅ import numpy as np
   ✅ from utils import normalize
   ✅ import torch.nn as nn

2. import 分组：标准库 → 第三方库 → 本地模块
   import os, sys                          # 标准库
   
   import numpy as np                      # 第三方库
   import torch
   
   from my_project.utils import normalize  # 本地模块

3. 不要用 from module import *（污染命名空间）
   ❌ from numpy import *                 # 导入了 600+ 个名字！
   ✅ import numpy as np                  # 只有一个 np

4. 避免循环导入（A import B，B import A）
   这会导致 ImportError 或部分初始化错误
   
5. 使用 try/except 做可选依赖导入
   try:
       import torch
       HAS_TORCH = True
   except ImportError:
       HAS_TORCH = False
&quot;&quot;&quot;)

# ====== 6. 实际演示：可选依赖导入 ======

def check_ai_libraries():
    &quot;&quot;&quot;检测常用 AI 库是否可用&quot;&quot;&quot;
    libs = {
        &quot;numpy&quot;: &quot;数值计算&quot;,
        &quot;pandas&quot;: &quot;数据分析&quot;,
        &quot;matplotlib&quot;: &quot;数据可视化&quot;,
        &quot;scipy&quot;: &quot;科学计算&quot;,
        &quot;sklearn&quot;: &quot;机器学习&quot;,
        &quot;torch&quot;: &quot;PyTorch 深度学习&quot;,
        &quot;tensorflow&quot;: &quot;TensorFlow 深度学习&quot;,
    }

    print(&quot;=== AI 库可用性检测 ===&quot;)
    for lib_name, description in libs.items():
        try:
            __import__(lib_name)
            print(f&quot;  ✅ {lib_name:12} ({description})&quot;)
        except ImportError:
            print(f&quot;  ❌ {lib_name:12} ({description}) — 未安装&quot;)

check_ai_libraries()</code></pre><p><strong>什么用</strong>：理解模块搜索路径能帮你搞定几乎所有 <code>ImportError</code>。当你在公司集群上跑训练脚本时 <code>ModuleNotFoundError: No module named &#39;my_project&#39;</code>——怎么办？三种解决方案：① <code>pip install -e .</code> 把项目以开发模式安装；② 在脚本开头加 <code>sys.path.insert(0, &quot;/path/to/project&quot;)</code>；③ 设置 <code>PYTHONPATH</code> 环境变量。理解 <code>sys.modules</code> 缓存机制能解释为什么改了模块代码但 <code>import</code> 还是旧版本——需要 <code>importlib.reload(module)</code> 强制重新加载。</p>
<div class="demo-embed" data-demo-src="/demos/modules-package-demo1.html"><a href="/demos/modules-package-demo1.html">模块工坊——组织你的 Python 工具箱（动画演示）</a></div>


<h2>概念关系图谱</h2>
<div class="table-wrapper"><table class="concept-map-table"><thead><tr><th>概念</th><th>核心含义</th><th>与AI的关系</th><th>关联概念</th></tr></thead><tbody><tr><td>模块</td><td>一个 .py 文件，代码的基本组织单元</td><td>每个 AI 库都是一个或多个模块</td><td>import、包</td></tr><tr><td>import</td><td>引入模块的关键字</td><td>import torch/numpy/sklearn</td><td>from、as、别名</td></tr><tr><td>包</td><td>含 <strong>init</strong>.py 的文件夹</td><td>torch.nn、transformers.models</td><td>子包、层次结构</td></tr><tr><td><strong>init</strong>.py</td><td>包的标识和初始化文件</td><td>控制包的公开接口和子模块导入</td><td><strong>all</strong>、命名空间</td></tr><tr><td>sys.path</td><td>模块搜索路径列表</td><td>解决 ModuleNotFoundError 的根本</td><td>PYTHONPATH、site-packages</td></tr><tr><td>相对导入</td><td>包内部用 . 和 .. 引用同级/上级模块</td><td>大型 AI 库的内部模块互相引用</td><td>绝对导入、包结构</td></tr><tr><td><strong>name</strong></td><td>模块的名字变量</td><td>if <strong>name</strong> == &quot;<strong>main</strong>&quot; 判断运行模式</td><td><strong>main</strong>、脚本</td></tr><tr><td>命名冲突</td><td>自定义模块名和标准库同名</td><td>避免创建 math.py、json.py 等</td><td>搜索顺序、缓存</td></tr></tbody></table></div>
<h2>重点答疑</h2>
<h3>Q1: <code>import module</code> 和 <code>from module import name</code> 有什么区别？什么时候用哪个？</h3>
<p>两者的区别在于<strong>命名空间管理</strong>。<code>import module</code>：你把整个模块作为一个对象引入，访问内容用 <code>module.name</code>——命名空间干净，不会和当前代码中的变量冲突。适用于大型库和多模块项目。<code>from module import name</code>：你把特定名字直接引入当前命名空间——使用方便（不需要前缀），但可能和已有变量冲突。适用于：频繁使用的小工具（<code>from math import sqrt</code>）、特定类（<code>from collections import defaultdict</code>）、或者模块中有很多你不关心的东西。<strong>基本原则：不确定就用 <code>import module</code>，干净安全。</strong></p>
<h3>Q2: <code>__init__.py</code> 可以为空吗？它到底做了什么？</h3>
<p><strong>完全可以为空</strong>——一个空的 <code>__init__.py</code> 就能让文件夹变成包。但有内容的 <code>__init__.py</code> 可以做更多：①执行包的初始化代码（如设置日志配置）；②定义 <code>__all__</code> 列表控制 <code>from package import *</code> 的行为；③通过 <code>from .子模块 import 类名</code> 让用户可以直接 <code>from 包 import 类名</code>（不用写完整的模块路径）；④定义包级别的常量和工具函数。在 AI 库中，<code>torch/__init__.py</code> 非常复杂——它动态检测 CUDA 版本、导入核心模块、设置 Tensor 类型等。</p>
<h3>Q3: 什么是循环导入？如何解决？</h3>
<p>循环导入指 A 模块 <code>import B</code>，B 模块又 <code>import A</code>——形成依赖环。Python 处理不了这种情况，会报 <code>ImportError</code>（部分导入）。解决方案：①<strong>重构代码</strong>——把共同依赖的逻辑抽取到第三个模块 C（A 和 B 都 import C）；②<strong>延迟导入</strong>——把 <code>import</code> 语句放到函数内部，只在需要时才导入（<code>def func(): import B</code>）；③<strong>换用 <code>import</code>（不 <code>from</code>）</strong>——<code>import A</code> 而非 <code>from A import func</code>，可以减少对完整初始化的需求。最佳方案永远是重构——循环导入通常是设计有问题的信号。</p>
<h3>Q4: <code>__name__ == &quot;__main__&quot;</code> 是做什么的？为什么每个脚本都要写？</h3>
<p>这是 Python 用来区分&quot;脚本是被直接运行还是被 import&quot;的机制。当 <code>python script.py</code> 直接运行时，<code>__name__</code> 被设为 <code>&quot;__main__&quot;</code>——条件成立，执行测试代码。当 <code>import script</code> 时，<code>__name__</code> 被设为 <code>&quot;script&quot;</code>（模块名）——条件不成立，跳过测试代码。这让同一个文件既能作为模块被 import（只提供函数/类），又能作为脚本直接运行（还能自我测试）。建议每个模块都写这个守卫——有了它，别人 import 你的模块时不会意外执行测试代码。</p>
<h3>Q5: 如何在项目中组织 AI 代码的模块结构？有最佳实践吗？</h3>
<p>推荐结构（基于 PyTorch 和业界惯例）：</p>
<pre><code>project/
├── config.py          # 所有配置常量和超参数
├── data/
│   ├── __init__.py
│   ├── dataset.py     # 自定义 Dataset 类
│   └── transforms.py  # 数据增强变换
├── models/
│   ├── __init__.py
│   └── network.py     # 模型定义
├── utils/
│   ├── __init__.py
│   ├── metrics.py     # 评估指标
│   └── logger.py      # 日志工具
├── train.py           # 训练入口
└── eval.py            # 评估入口</code></pre><p>核心原则：按功能分模块（数据/模型/工具），不是按人分（张三/李四模块）。顶层脚本（train.py）负责 <code>import</code> 和调用，不包含复杂逻辑。</p>

<h2>章节单词汇总</h2>
<div class="vocab-table-wrapper"><table class="vocab-table"><thead><tr><th>英文</th><th>音标</th><th>术语/释义</th></tr></thead><tbody><tr><td>module</td><td>/ˈmɒdjuːl/</td><td>模块；一个 .py 文件</td></tr><tr><td>import</td><td>/ɪmˈpɔːrt/</td><td>导入；引入模块或包</td></tr><tr><td>package</td><td>/ˈpækɪdʒ/</td><td>包；含 <strong>init</strong>.py 的文件夹</td></tr><tr><td>namespace</td><td>/ˈneɪmspeɪs/</td><td>命名空间；名字到对象的映射</td></tr><tr><td>alias</td><td>/ˈeɪliəs/</td><td>别名；<code>import numpy as np</code> 中的 as</td></tr><tr><td>path</td><td>/pæθ/</td><td>路径；sys.path 模块搜索路径</td></tr><tr><td>init</td><td>/ɪˈnɪt/</td><td><strong>init</strong>.py；包的初始化文件</td></tr><tr><td>dependency</td><td>/dɪˈpendənsi/</td><td>依赖；模块之间的引用关系</td></tr></tbody></table></div>
<div class="quiz-raw"><h2>面试练习</h2>
<h3>Q1 [单选] 以下 import 方式中，哪个需要加模块名前缀访问函数？</h3>
<ul>
<li>A. <code>import math</code></li><li>B. <code>from math import sqrt</code></li><li>C. <code>from math import *</code></li><li>D. <code>from math import sqrt as square_root</code></li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A 正确。<code>import math</code> 后需要用 <code>math.sqrt()</code> 访问。B 和 D 可以直接用 <code>sqrt()</code> 或 <code>square_root()</code>，C 可以不加前缀直接用所有公开名字（不推荐）。</blockquote>


<h3>Q2 [单选] 一个文件夹成为 Python 包的必要条件是？</h3>
<ul>
<li>A. 包含 <code>__init__.py</code> 文件</li><li>B. 文件夹名必须以 <code>pkg_</code> 开头</li><li>C. 文件夹内至少有一个 <code>.py</code> 文件</li><li>D. 需要通过 <code>pip install</code> 安装</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A 正确。<code>__init__.py</code> 是包的标识（Python 3.3+ 有隐式命名空间包，但最佳实践仍然包含）。B 错误（没有命名约束），C 错误（空包也可以），D 错误（pip 不是必须的）。</blockquote>


<h3>Q3 [单选] <code>import numpy as np</code> 中的 <code>as np</code> 的作用是？</h3>
<ul>
<li>A. 只导入 numpy 中名为 np 的函数</li><li>B. 让 numpy 运行更快</li><li>C. 给 numpy 模块起一个别名，之后用 np 代替 numpy</li><li>D. 导入 numpy 的 np 子模块</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>C 正确。<code>as</code> 是别名——给模块起一个短名方便使用。<code>np.array()</code> 等价于 <code>numpy.array()</code>。这是社区约定俗成的惯例（<code>np</code>、<code>pd</code>、<code>plt</code>、<code>tf</code>）。</blockquote>


<h3>Q4 [多选] 以下哪些是 <code>__init__.py</code> 的作用？</h3>
<ul>
<li>A. 标识一个文件夹是 Python 包</li><li>B. 执行包的初始化代码</li><li>C. 通过 <code>__all__</code> 控制 <code>from 包 import *</code> 的行为</li><li>D. 必须包含包的所有模块代码</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A、B、C 正确。D 错误——<code>__init__.py</code> 可以为空，也可以在内部 <code>from .module import XXX</code> 来简化用户导入路径，但不是必须包含模块代码。</blockquote>


<h3>Q5 [单选] 如果在项目的当前目录有一个 <code>math.py</code> 文件，<code>import math</code> 导入的是？</h3>
<ul>
<li>A. 当前目录的 <code>math.py</code></li><li>B. 标准库的 <code>math</code></li><li>C. 两者都导入</li><li>D. 报错</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A 正确。<code>sys.path</code> 的第一个条目是当前目录（或脚本目录），标准库在列表后面。所以当前目录的 <code>math.py</code> 会最先被找到，标准库的 <code>math</code> 被&quot;遮蔽&quot;了。这就是为什么不要和标准库同名。</blockquote>


<h3>Q6 [多选] 关于模块导入，以下说法正确的是？</h3>
<ul>
<li>A. 每个模块只会被导入一次（有缓存）</li><li>B. <code>import 模块</code> 后可以用 <code>模块.函数()</code> 访问</li><li>C. <code>from 模块 import *</code> 是推荐的做法</li><li>D. 模块的 <code>__name__</code> 属性在直接运行时为 <code>&quot;__main__&quot;</code></li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A、B、D 正确。C 错误——<code>from module import *</code> 会污染命名空间（导入所有公开名字），PEP 8 明确不推荐。除非模块专门设计了 <code>__all__</code> 列表。</blockquote>


<h3>Q7 [单选] <code>from package.submodule import func</code> 中，哪个是包、哪个是模块？</h3>
<ul>
<li>A. package 是模块，submodule 是包</li><li>B. package 是包，submodule 是模块（或子包）</li><li>C. 两者都是包</li><li>D. func 是包</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>B 正确。<code>package</code> 是包（文件夹），<code>submodule</code> 是这个包内的一个模块（<code>.py</code> 文件，或进一步是子包），<code>func</code> 是模块中定义的函数。点号 <code>.</code> 表示层次结构。</blockquote>


<h3>Q8 [多选] 解决 <code>ModuleNotFoundError</code> 的方法包括？</h3>
<ul>
<li>A. 确保模块文件在当前目录或 <code>sys.path</code> 中</li><li>B. 使用 <code>sys.path.append(&quot;/path/to/module&quot;)</code> 添加搜索路径</li><li>C. 用 <code>pip install</code> 安装缺失的第三方库</li><li>D. 把模块名改成大写</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A、B、C 正确。D 错误——模块名大小写不影响导入（但建议遵循全小写+下划线的 snake_case 命名规范）。A 是针对本地模块，B 是临时解决方案，C 是针对第三方库。</blockquote>


<h3>Q9 [单选] 以下哪种情况会导致循环导入错误？</h3>
<ul>
<li>A. <code>a.py</code> 中 <code>import math</code></li><li>B. <code>a.py</code> 中 <code>import b</code>，<code>c.py</code> 中 <code>import b</code></li><li>C. <code>a.py</code> 中 <code>import b</code>，<code>b.py</code> 中 <code>import a</code></li><li>D. <code>a.py</code> 中 <code>import b, c, d</code></li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>C 正确。A import B，B import A——形成循环依赖。Python 无法处理（因为 A 需要 B 先初始化完，B 又需要 A 先初始化完——死锁）。解决方案是重构把共享逻辑抽到第三个模块。</blockquote>


<h3>Q10 [多选] 以下哪些是合理的 Python 模块命名？</h3>
<ul>
<li>A. <code>utils.py</code></li><li>B. <code>data_loader.py</code></li><li>C. <code>math.py</code></li><li>D. <code>my_helpers.py</code></li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A、B、D 合理。C 不合理——<code>math.py</code> 和标准库的 <code>math</code> 模块同名，会导致标准库 <code>math</code> 无法使用。模块命名规则：①小写字母+下划线；②不和标准库/常用第三方库重名；③名称要有意义。</blockquote>


</div>

      <div class="content-actions">
        <button class="action-btn" onclick="sharePage()" title="分享">
          <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M4 12v8a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-8"/><polyline points="16 6 12 2 8 6"/><line x1="12" y1="2" x2="12" y2="15"/></svg><span>分享</span>
        </button>
        <button class="action-btn" onclick="printPage()" title="打印">
          <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><polyline points="6 9 6 2 18 2 18 9"/><path d="M6 18H4a2 2 0 0 1-2-2v-5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v5a2 2 0 0 1-2 2h-2"/><rect x="6" y="14" width="12" height="8"/></svg><span>打印</span>
        </button>
        <button class="action-btn" onclick="showFeedback()" title="反馈">
          <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z"/></svg><span>反馈</span>
        </button>
      </div>
    </article>
  </main>
</div>

<script type="application/json" id="formula-data">{}</script>
<script type="application/json" id="quiz-data">[
  {
    "type": "single",
    "answer": 0,
    "explanation": "A 正确。`import math` 后需要用 `math.sqrt()` 访问。B 和 D 可以直接用 `sqrt()` 或 `square_root()`，C 可以不加前缀直接用所有公开名字（不推荐）。"
  },
  {
    "type": "single",
    "answer": 0,
    "explanation": "A 正确。`__init__.py` 是包的标识（Python 3.3+ 有隐式命名空间包，但最佳实践仍然包含）。B 错误（没有命名约束），C 错误（空包也可以），D 错误（pip 不是必须的）。"
  },
  {
    "type": "single",
    "answer": 2,
    "explanation": "C 正确。`as` 是别名——给模块起一个短名方便使用。`np.array()` 等价于 `numpy.array()`。这是社区约定俗成的惯例（`np`、`pd`、`plt`、`tf`）。"
  },
  {
    "type": "multi",
    "answer": [
      0,
      1,
      2
    ],
    "explanation": "A、B、C 正确。D 错误——`__init__.py` 可以为空，也可以在内部 `from .module import XXX` 来简化用户导入路径，但不是必须包含模块代码。"
  },
  {
    "type": "single",
    "answer": 0,
    "explanation": "A 正确。`sys.path` 的第一个条目是当前目录（或脚本目录），标准库在列表后面。所以当前目录的 `math.py` 会最先被找到，标准库的 `math` 被\"遮蔽\"了。这就是为什么不要和标准库同名。"
  },
  {
    "type": "multi",
    "answer": [
      0,
      1,
      3
    ],
    "explanation": "A、B、D 正确。C 错误——`from module import *` 会污染命名空间（导入所有公开名字），PEP 8 明确不推荐。除非模块专门设计了 `__all__` 列表。"
  },
  {
    "type": "single",
    "answer": 1,
    "explanation": "B 正确。`package` 是包（文件夹），`submodule` 是这个包内的一个模块（`.py` 文件，或进一步是子包），`func` 是模块中定义的函数。点号 `.` 表示层次结构。"
  },
  {
    "type": "multi",
    "answer": [
      0,
      1,
      2
    ],
    "explanation": "A、B、C 正确。D 错误——模块名大小写不影响导入（但建议遵循全小写+下划线的 snake_case 命名规范）。A 是针对本地模块，B 是临时解决方案，C 是针对第三方库。"
  },
  {
    "type": "single",
    "answer": 2,
    "explanation": "C 正确。A import B，B import A——形成循环依赖。Python 无法处理（因为 A 需要 B 先初始化完，B 又需要 A 先初始化完——死锁）。解决方案是重构把共享逻辑抽到第三个模块。"
  },
  {
    "type": "multi",
    "answer": [
      0,
      1,
      3
    ],
    "explanation": "A、B、D 合理。C 不合理——`math.py` 和标准库的 `math` 模块同名，会导致标准库 `math` 无法使用。模块命名规则：①小写字母+下划线；②不和标准库/常用第三方库重名；③名称要有意义。"
  }
]</script>

<script src="/js/chapter-enhance.js"></script>
<script src="/js/pay-modal.js?v=20260606e"></script>
<script src="/js/chapter-common.js"></script>
<script src="/js/chapter-learn.js"></script>
<script src="/js/chapter-nav.js"></script>
<script src="/js/chapter-voice.js"></script>
<script src="/js/chapter-quiz.js"></script>
<script src="/js/chapter-presence.js"></script>
<script src="/js/chapter-auth.js"></script>
<script src="/js/chapter-code.js"></script>
<script src="/js/chapter-annotation.js"></script>
<script src="/js/chapter-comments.js"></script>
<script src="/js/chapter-social.js"></script>
<script src="/js/chapter-ui.js?v=20260612c"></script>
<script src="/js/chapter-init.js?v=20260612b"></script>
</body>
</html>