Skip to content

第 4 章:包含与导入:程序的第一行在做什么 ​

本章承接第 3 章的输入输出:你已经会用 print 了,现在弄清 import math 这一行到底在做什么。它是后续章节使用随机数、时间等标准库模块、以及把程序拆成多个文件的地基。

本章能学到什么 ​

  • 故意不写 import,从报错中读懂它的作用
  • import 的本质:运行时把模块加载为一个真实存在的对象
  • import x、from x import y、import x as z 三种写法的差异
  • 模块搜索路径:当前文件夹、标准库、第三方库
  • 亲手写一个模块再导入,验证"模块只加载一次"
  • if __name__ == "__main__" 这行常见代码的含义
  • Python 的 import 与 C++ 的 #include 全面对照

先制造一个困惑:不写会怎样 ​

想算一个数的平方根。猜一猜:直接写 sqrt(16) 行不行?试试看:

python
# forget.py —— 故意不写 import
print(sqrt(16))

运行:

text
$ python3 forget.py
Traceback (most recent call last):
  File "forget.py", line 2, in <module>
    print(sqrt(16))
NameError: name 'sqrt' is not defined

最后一行是关键:NameError: name 'sqrt' is not defined。Python 说:我不认识 sqrt 这个名字。

这个报错透露了一个重要事实:sqrt 不是 Python 自带的词汇。它住在 math 这个模块里,就像工具放在工具箱里。要用它,先做两件事:用 import math 把工具箱搬出来;说清"我要用的是 math 里的 sqrt":

python
import math

print(math.sqrt(16))
text
4.0

结果是 4.0 而不是 4,开平方返回小数。小数与整数的区别在第 2 章讲过。

import 的本质:模块是一个真实存在的对象 ​

import 做的事,是在程序运行时把模块加载成一个对象——一个摸得着、可以查看的东西。不信就看看:

python
import math

print(type(math))   # math 是什么类型?
print(math)         # math 本身是什么?
text
<class 'module'>
<module 'math' (built-in)>

math 的类型是 module(模块)。它是一个真实存在的命名空间。可以把它理解为一个贴好标签的工具箱:箱子上写着 math,里面装着 sqrt、pi 等工具。写 math.sqrt 就是从写着 math 的箱子里取出 sqrt 这件工具。

既然是对象,就能翻箱底。dir 可以列出箱子里所有的工具:

python
import math

print(dir(math))
text
['acos', 'asin', 'atan', 'ceil', 'cos', 'e', 'fabs', 'factorial', 'floor', ..., 'pi', 'sin', 'sqrt', 'tan', ...]

pi(圆周率)、factorial(阶乘)、sin(正弦)都在里面。这也是查"某个功能在哪个模块"的常用办法。

还有一个证据能说明"加载发生在运行时":模块文件里的代码,会在 import 的那一刻执行。本章后面的自定义模块实验会亲眼看到这一点。

三种写法 ​

需求不同,写法不同:

写法用法适用场景
import mathmath.sqrt(16)默认推荐。来源清晰,不会撞名
from math import sqrtsqrt(16)只用箱子里一两件工具,想少打字
import math as mm.sqrt(16)模块名太长,起个短别名
python
# 写法一:import 模块名
import math
print(math.sqrt(16))

# 写法二:from 模块 import 工具
from math import sqrt
print(sqrt(16))

# 写法三:import 模块 as 别名
import math as m
print(m.sqrt(16))
text
4.0
4.0
4.0

写法二有一个隐患:如果另一个模块里也有同名工具,后导入的会悄悄覆盖先导入的,程序就出错了,而错误还很隐蔽。比如 from math import sqrt 之后又 from cmath import sqrt,前一个就被顶掉了。所以"来源清晰"的写法一是默认推荐。

别名也有社区约定:数据处理库 numpy 几乎全世界都写成 import numpy as np,表格库 pandas 都写成 import pandas as pd。见到 np、pd 就知道是谁,这已经是行业通用语。起别名是为了沟通顺畅,不是为了标新立异。

模块从哪里来:搜索路径 ​

import 的时候,Python 按固定顺序找模块:

顺序位置装的是什么
1当前文件夹你自己写的 .py 文件
2标准库Python 自带的模块,如 math、random
3第三方库用 pip install 装的模块

这个顺序可以直接打印出来看:

python
import sys
print(sys.path)

输出是一串文件夹路径,每台电脑不完全相同。Python 从前往后挨个文件夹找,找到第一个同名模块就停。

这也解释了一个常见怪事:给自己的文件起名叫 math.py,import math 就会找到它而不是标准库——当前文件夹排在最前面。自己的文件名不要和标准库重名。

标准库是一座宝库,先混个眼熟:

模块功能例子
math数学math.sqrt(16)、math.pi
random随机数random.randint(1, 6) 掷骰子
time时间与延时time.sleep(1) 停 1 秒
datetime日期今天的日期、星期几

第三方库需要先用 pip 安装,比如 pip install pygame。安装后它出现在搜索路径的第 3 站,用法和标准库模块一样。

亲手写一个模块 ​

实验:写一个自己的模块再导入它。它能同时验证两件事:搜索路径从当前文件夹开始;模块只在首次导入时执行。

第一步,写 mymath.py:

python
# mymath.py —— 我们自己的模块
print("mymath 模块被加载了")   # 加载那一刻会执行

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

第二步,在同一个文件夹里写 main.py:

python
import mymath
import mymath    # 故意导入两次

print(mymath.add(3, 4))

运行:

text
$ python3 main.py
mymath 模块被加载了
7

两个值得注意的现象:

  1. import mymath 不需要写 .py 后缀。Python 在当前文件夹找到了 mymath.py,加载它,并执行了里面的 print——这就是"模块是运行时加载的"的直接证据。
  2. 明明 import 了两次,"mymath 模块被加载了"只打印了一次。Python 会把加载过的模块缓存起来,第二次 import 直接拿缓存,不重复执行。所以 Python 里不需要防止重复导入的保护装置。

那行常见的 if name == "main" ​

上面的实验暴露了一个麻烦:模块里随手写的 print,在别人 import 时也会执行。可有时这些语句只是"自己测试用的",只想在直接运行这个文件时执行,被导入时别执行。

Python 给每个模块准备了一个内置变量 __name__:文件被直接运行时,它是 "__main__";被 import 时,它是模块名。于是有了这行经典写法:

python
# mymath.py —— 改进版
def add(a, b):
    return a + b

if __name__ == "__main__":
    # 只有直接运行本文件时才执行,被 import 时不执行
    print("自测:", add(3, 4))

直接运行 python3 mymath.py 会打印自测结果;被 main.py 导入时则安安静静。读别人的代码再遇到这行,就认识它了。

用模块验证数学 ​

标准库不是抽象概念,它能立刻解决数学课上的问题。开平方、幂运算、阶乘、圆周率,都在 math 里:

python
import math

print(math.sqrt(16))      # 根号 16
print(math.pow(2, 10))    # 2 的 10 次方
print(math.factorial(5))  # 5 的阶乘
print(math.pi)            # 圆周率
text
4.0
1024.0
120
3.141592653589793

对照数学式子:16=4,210=1024,5!=120,π≈3.14159。函数名和数学符号几乎一一对应。以后遇到"程序里怎么算开方",答案永远是三步:查它在哪个模块里,import,然后调用。

模块、包、库:三个词的差别 ​

日常听到的"模块""包""库"经常混用,严格说有层级:

名词含义例子
模块(module)一个 .py 文件本章的 mymath.py
包(package)一个装了若干模块的文件夹装了若干绘图模块的 matplotlib
库(library)口语说法,泛指可复用的代码"数学库""游戏库"

记忆法:模块是一本书,包是一格书架,库是整个图书角。pip install 装的通常是包。

常见报错自查表 ​

报错可能原因怎么办
NameError: name 'xxx' is not defined忘了 import,或名字拼错补上 import,检查拼写
ModuleNotFoundError: No module named 'xxx'模块名写错,或第三方库没安装检查拼写;第三方库先 pip install
ImportError: cannot import name 'yyy'模块里没有 yyy 这个工具用 dir(模块) 看看里面有什么
import 到了行为奇怪的同名文件自己的文件名和标准库重名给自己的文件换个名字

想深挖一个模块?文档是下一站 ​

dir() 列出工具的名字,官方文档讲清每个工具的用法。在命令行运行 python3 -c "help(math)",或搜索"Python 官方文档 math",就能看到每个函数的说明和例子。遇到没用过的模块,先 dir 再查文档,是标准动作。查文档是程序员的基本功,比靠背可靠得多。

C++ 那边怎么做 ​

C++ 里对应的语句是 #include,但机制完全不同:它发生在编译之前,只是把文件内容原样复制粘贴进来。粘贴两次,内容就出现两份,编译器直接报错,程序员还得写"头文件保护符"防止重复粘贴。

完整的对比实验(包括用 g++ -E 亲眼看到几万行的粘贴结果、编译与链接两道工序)在姊妹册 《C++ 从入门到精通》第 4 章,建议对照着读。

【跨语言对照】 ​

本质问题:程序不可能什么功能都自己写。打印文字、开平方、生成随机数……这些通用功能由语言随附的代码库提供。两门语言要回答同一个问题:怎么把库里的代码"接"进自己的程序?

各自做法:

对照项C++Python
写法#include <iostream>import math
发生时机编译之前(预处理期)程序运行时
本质文本复制粘贴加载模块为对象
重复包含后果编译错误,需头文件保护无妨,模块只加载一次(缓存)
自带代码库叫什么标准库 + 头文件标准库 + 模块/包
第三方库怎么来手动编译/包管理器pip install

同一个需求"算 16 的平方根",两边的等价代码:

cpp
#include <iostream>
#include <cmath>      // 数学函数库
using namespace std;

int main() {
    cout << sqrt(16) << endl;
    return 0;
}
python
import math          # 数学模块

print(math.sqrt(16))

两边输出一致:

text
4

(Python 实际打印的是 4.0,开平方的结果是小数;小数与整数的区别在第 2 章讲过。)

为什么设计不一样:这要从两门语言的"性格"说起,见下一节。

设计哲学:灵活但有代价 vs 简陋但可控 ​

Python 的模块系统是语言的一等公民。模块是真实存在的对象,可以查看它的类型,可以翻出它所有的工具,可以在程序运行中途动态加载。这一切的代价是:启动时要花时间去查找、加载、执行模块代码。Python 选择牺牲一点启动速度,换取灵活和开发效率——这也是它写起来快的原因。

Python 比 C 晚出生近二十年,起点就站在更充裕的硬件上,有本钱把模块做成运行时的对象。再加上 pip 一键安装几十万个第三方库,"找模块、装模块、用模块"成了 Python 开发者的日常。这套体验是设计出来的,也是时代允许的。

C++ 的 #include 机制可以说是"简陋"的:它不理解代码含义,只会复制粘贴,这套方案继承自 1970 年代的 C 语言。但预处理在编译前完成,程序运行时完全感觉不到它的存在,机器码里没有一丝多余开销。粘贴了什么、粘贴了几次,用 g++ -E 一看便知,没有任何隐藏行为。这正是 C++ 的核心哲学——零开销:没用到的功能不花一分钱,写下的每一行都可以预测。

两种选择没有高下之分,只有目标不同:Python 追求让人写得痛快,C++ 追求让机器跑得极致。

动手实验 ​

  1. 用三种 import 写法分别打印圆周率 pi(它住在 math 模块里),预期都输出 3.141592653589793。
💡 查看答案
python
import math
print(math.pi)

from math import pi
print(pi)

import math as m
print(m.pi)
text
3.141592653589793
3.141592653589793
3.141592653589793
  1. 写一个模块 greeter.py,里面定义函数 hello(name),功能是打印"你好,"加上名字。再写 main.py 导入并调用 greeter.hello("小明")。
💡 查看答案
python
# greeter.py
def hello(name):
    print("你好," + name)
python
# main.py
import greeter

greeter.hello("小明")
text
你好,小明
  1. 在 greeter.py 的第一行加一句 print("greeter 模块被加载了"),然后在 main.py 里连续 import 它三次。运行前猜一猜会打印几次,再运行验证。想想如果要让这句只在"直接运行 greeter.py"时打印,该怎么改。
💡 查看答案

只打印一次:

text
greeter 模块被加载了
你好,小明

原因:Python 会缓存加载过的模块,第二次、第三次 import 直接使用缓存,不再执行模块里的代码。

要让它只在直接运行时打印,把它放进 if __name__ == "__main__": 下面即可。