阶段 01 讲义

数学 11h：高数 · 函数与数列极限（一）
编程 9h：Python 环境与基础类型

第一部分 · 数学

1 函数：先把语言统一

什么是函数：给定一个 $x$，按某个规则 $f$，得到唯一确定的 $y$。

$$y = f(x)$$

三个要素缺一不可：定义域、对应法则、值域。

新手最常见的错：只看对应法则，忘了定义域。
比如 $f(x)=\frac{1}{x}$ 和 $g(x)=\frac{x}{x^2}$ 看起来"一样"，但定义域不同。

基本初等函数（必须认脸）

复合函数：$f(g(x))$

例：$f(u)=\sqrt{u}$，$g(x)=1-x^2$，则 $f(g(x))=\sqrt{1-x^2}$
定义域要求 $1-x^2 \ge 0$，即 $x \in [-1,1]$。

反函数：把 $x$ 和 $y$ 的角色互换。

例：$y = 2x+1$ 的反函数是 $y = \frac{x-1}{2}$。
图像上：反函数与原函数关于 $y=x$ 对称。

2 数列极限：ε-N 语言 ⭐

这是整个高数的第一道门槛，也是最重要的定义。

2.1 先看直觉

数列 $a_n = \frac{1}{n}$：

$$\frac{1}{1}, \frac{1}{2}, \frac{1}{3}, \frac{1}{4}, \dots$$

它在无限接近 0。但"无限接近"这种话不能写进数学，所以数学家发明了 ε-N 语言。

2.2 定义

数列 $\{a_n\}$ 收敛于 $A$，记作 $\lim_{n\to\infty} a_n = A$，如果：

对任意给定的 $\varepsilon > 0$，都存在一个正整数 $N$，使得当 $n > N$ 时，恒有

$$|a_n - A| < \varepsilon$$

2.3 怎么读懂它（重点）

这个定义本质上是一个挑战-应对的游戏：

关键：挑战者可以任意小，而你必须每次都能找到对应的 $N$。

• "任意 ε" = 挑战者可以多苛刻都行
• "存在 N" = 但你的回应只要"找到一个"就行，不需要最优

⚠️ 顺序不能换。
"存在 N，对任意 ε" 是完全不同的意思（那会退化成 $a_n$ 恒等于 $A$）。
ε 在前，N 在后。N 可以依赖于 ε。

2.4 用定义证明：一个完整例子

证明 $\lim_{n\to\infty}\frac{1}{n} = 0$

证明过程：

1. 任取 $\varepsilon > 0$
2. 要证 $|a_n - 0| < \varepsilon$，即 $\left|\frac{1}{n}\right| < \varepsilon$
3. 这等价于 $n > \frac{1}{\varepsilon}$
4. 所以取 $N = \left\lceil \frac{1}{\varepsilon} \right\rceil$（向上取整）
5. 则当 $n > N$ 时，有 $n > \frac{1}{\varepsilon}$，故 $\frac{1}{n} < \varepsilon$ ✓

注意第 3 步到第 4 步：从"我要求 $n$ 满足什么"反推出"$N$ 该取多少"。这是 ε-N 证明的标准套路。

2.5 另一个例子（稍难）

证明 $\lim_{n\to\infty}\frac{n+1}{n} = 1$

分析：要和 $A=1$ 比。

$$\left|\frac{n+1}{n} - 1\right| = \left|\frac{n+1-n}{n}\right| = \frac{1}{n}$$

于是退化成上题：取 $N = \lceil 1/\varepsilon \rceil$ 即可。

套路总结：先算 $|a_n - A|$，把它化简成"关于 $n$ 的简单式子"，再从中解出 $n$ 的条件。

3 极限的四则运算法则

学了 ε-N 定义，是不是以后每次求极限都要"任取 $\varepsilon$……"？不用。

ε-N 是打地基的，日常算极限靠的是下面这套法则。你 99% 的时间用的是这个，不是 ε-N。

若 $\lim a_n = A$，$\lim b_n = B$（两个极限都存在），则：

$$\lim (a_n \pm b_n) = A \pm B$$

$$\lim (a_n \cdot b_n) = A \cdot B$$

$$\lim \frac{a_n}{b_n} = \frac{A}{B} \qquad (B \ne 0)$$

用法示例：求 $\lim_{n\to\infty}\dfrac{2n^2+3n}{n^2+1}$

上下同除 $n^2$：

$$= \lim_{n\to\infty}\frac{2+\frac3n}{1+\frac{1}{n^2}} = \frac{2+0}{1+0} = 2$$

关键前提：两个极限都必须存在，这是最容易忽略的地方。

⚠️ 反例：$a_n = (-1)^n$，$\lim a_n$ 不存在。
但 $a_n + (-a_n) = 0$，这个和的极限存在，等于 0。
所以"和的极限存在"推不出"每一部分的极限都存在"。
法则是单向的，别倒着用。

4 收敛数列的性质

夹逼定理很有用，例子：

求 $\lim_{n\to\infty} \frac{\sin n}{n}$

因为 $-\frac{1}{n} \le \frac{\sin n}{n} \le \frac{1}{n}$，而两边都趋于 0，所以原式趋于 0。

5 单调有界准则 ⭐：不知道极限是多少，也能证明它收敛

ε-N 定义有个难受的地方：你得先猜到 $A$ 等于多少，才能写出证明。

但很多情况下你根本不知道极限是几，只感觉到它应该收敛。

单调有界准则解决的正是这个问题：

单调递增 + 有上界 ⟹ 收敛。
单调递减 + 有下界 ⟹ 收敛。

它不需要你猜出极限值，只要证两件事：单调、有界。

⚠️ 注意：它只告诉你极限存在，不告诉你等于多少。

5.1 回头看 $(1+\frac1n)^n$

阶段开头那个例子，现在可以给它一个完整交代了。

$a_n = (1+\frac1n)^n$：

1. 单调递增，每一项都比前一项大（数值验证：前 2000 项严格递增）
2. 有上界，可以证明 $a_n < 3$（用二项式展开；数值上前 10000 项也确实都小于 3）

两条都满足 ⟹ 极限存在。这个极限就被定义为 $e$。

$e$ 不是"算"出来的，是"证"出来的。
我们先证明 $(1+\frac1n)^n$ 收敛，然后把它的极限命名为 $e$。

这顺便解释了阶段开头那个疑问，它为什么收敛那么慢（$O(1/n)$）。
因为这个式子本来就不是用来算 $e$ 的。它的价值在"证明存在"。
真要算 $e$ 的数值，得用级数：
$$\sum_{k=0}^{\infty}\frac{1}{k!} = 1+1+\frac{1}{2}+\frac{1}{6}+\cdots$$
它快得离谱，加到 $k=10$ 时误差已经小于 $3\times10^{-8}$
（数列那边要 $n=1000$ 才到 $10^{-3}$ 的量级）。

5.2 怎么用

看到"证明收敛"但极限值算不出来，第一反应就该是它。

练习思路：$a_1=\sqrt2$，$a_{n+1}=\sqrt{2+a_n}$。
极限不好直接算，但可以证：① 它递增 ② 它小于 2。于是收敛。
（然后再由 $A=\sqrt{2+A}$ 解出 $A=2$。先证存在，再求值。）

6 数学归纳法：证明"对所有 n 成立"

前面的 $\varepsilon$-$N$ 证明是"对给定的 $\varepsilon$ 找 $N$"。
但有些结论是对所有 $n$ 都成立，比如 $\frac{1}{2}+\frac{1}{4}+\cdots+\frac{1}{2^n} < 1$。
这类命题的标配工具就是数学归纳法。

多米诺骨牌比喻：
- 推倒第一张（基础情形）
- 且每一张倒下都能推倒下一张（归纳步骤）
- ⟹ 所有骨牌都会倒

框架（两步，缺一不可）：

⚠️ 两步缺一不可。
只做②不做①：证明"每张倒下能推倒下一张"，但第一张没倒，全都不会倒。
只做①不做②：只倒了第一张。

完整例子：证明 $1+2+\cdots+n = \dfrac{n(n+1)}{2}$

① 基础情形（$n=1$）：左边 $=1$，右边 $=\dfrac{1\cdot2}{2}=1$ ✓

② 归纳步骤：假设 $n=k$ 时成立，即 $1+2+\cdots+k=\dfrac{k(k+1)}{2}$。
那么 $n=k+1$ 时：

$$1+2+\cdots+k+(k+1) = \frac{k(k+1)}{2}+(k+1) = (k+1)\left(\frac{k}{2}+1\right) = \frac{(k+1)(k+2)}{2}$$

这正是把 $n=k+1$ 代进 $\dfrac{n(n+1)}{2}$ 的结果 ✓

两步都成立 ⟹ 对一切正整数 $n$ 成立。 ∎

💡 关键在归纳步骤的"假设"：你不是在证明 $n=k$ 成立（那是假设），
你是在证明"如果 $k$ 成立，那么 $k+1$ 也成立"这条链子不断。

它会用在哪：证明数列单调性、"有上界"这类结论。比如上面证 $a_n<3$，
就可以用归纳法做。

7 常见的坑

8 🧠 这跟认知科学有什么关系

这一节不考试，但它回答一个更根本的问题：我学这些干嘛。
（概念性内容，无法用代码验证，请对照文献）

数列极限 ↔ 技能习得曲线。

练习一项任务（打字、镜面描图、记单词），反应时/错误率会随练习次数下降，并趋于一个渐近值（asymptote），这就是一个数列极限。心理学里著名的"练习幂律"（power law of practice）描述的就是这种趋近过程。

所以"永远达不到，但要多近有多近"不是抽象的数学哲学。你在实验数据里真会看到它：练习到第 100 次和第 500 次，差别小到测不出来。

"小于任意 ε" ↔ 心理物理的测量精度。

心理物理实验测出来的所有量（阈限、反应时、判断概率）都有精度上限。所以"两个条件有没有差别"永远要问"在什么精度下"，这正是 ε 的思想。也是为什么后面统计里比较浮点数要用容差（math.isclose）而不是 ==。

一个提醒：这类"数学 ↔ 认知"的类比能帮你建立直觉，但类比不等于等价。
心理量的幂律是经验规律，不是从公理推出来的定理。真要用在论文里，必须回到文献。

9 数学作业 S1

• [ ] 1. 默写 ε-N 定义的完整表述，并用自己的话解释"任意 ε"和"存在 N"分别在说什么
• [ ] 2. 写出 $f(x)=\ln(3-x)$ 的定义域
• [ ] 3. 求复合函数：$f(u)=\frac{1}{u}$，$g(x)=x^2-4$，求 $f(g(x))$ 并写出定义域
• [ ] 4. 用 ε-N 定义证明 $\lim_{n\to\infty}\frac{1}{2n} = 0$
• [ ] 5. 用 ε-N 定义证明 $\lim_{n\to\infty}\frac{2n+1}{n} = 2$
• [ ] 6. 用夹逼定理求 $\lim_{n\to\infty}\frac{1+2+\cdots+n}{n^2}$
• [ ] 7. 用四则运算法则求 $\lim_{n\to\infty}\frac{3n^2-n+2}{2n^2+5}$
• [ ] 8. 用数学归纳法证明 $1+3+5+\cdots+(2n-1)=n^2$
• [ ] 9.（重点）设 $a_1=1$，$a_{n+1}=\sqrt{2+a_n}$。证明该数列收敛，并求极限

  提示：先用归纳法证 $a_n<2$ 且递增（单调有界准则的前提），
  再由 $A=\sqrt{2+A}$ 解出极限。先证存在，再求值。

• [ ] 10.（Python）用 numpy 画出 $a_n=(1+1/n)^n$ 的前 50 项，观察它趋近于什么数

第 10 题参考代码（numpy 用法见上面第 9 节）：

import numpy as np
import matplotlib.pyplot as plt

n = np.arange(1, 51)
a = (1 + 1/n) ** n

plt.plot(n, a, marker="o", markersize=3)
plt.axhline(np.e, color="red", linestyle="--", label=f"e ≈ {np.e:.6f}")
plt.xlabel("n"); plt.ylabel("a_n"); plt.legend()
plt.title("(1+1/n)^n 趋近于 e")
plt.show()

print("n=50 时:", a[-1])
print("e     :", np.e)

你应该看到它从下方趋近 e ≈ 2.71828，但收敛很慢：
- $n=50$ 时约为 2.6916（还差 0.026）
- $n=1000$ 时约为 2.7169
- $n=10000$ 时才到 2.71815

它确实趋近 e，但速度是 $O(1/n)$，要看出来"正在趋近"，图得画到几千项才明显。
这正是"极限"这个概念的意义：永远达不到，但要多近有多近。

💡 修正的代码：把上面第 2 行的 50 改成 5000 再看一次，对比就明显了。

结合第 5 节。现在你知道它为什么收敛了，单调 + 有界。
而这个极限的值之所以是 $e$，是因为 $e$ 就是这么定义的，不是"算"出来的。

第二部分 · 编程

10 先跑通环境

打开方式：双击桌面 数学工具/ 里的 「启动 Jupyter.command」，浏览器会自动打开。

如果提示"来自身份不明的开发者"：右键点文件 → 选「打开」→ 再点「打开」。

第一次测试：在 Jupyter 里新建一个 Notebook，输入下面这行，按 Shift + Enter：

print("hello, 认知科学")

看到输出就成功了。

11 变量：是"标签"，不是"盒子"

这是理解 Python 的第一个关键。

在其他语言里，变量像一个盒子，你把值放进去。在 Python 里：

变量是一个标签，贴在某个对象上。

x = 5
y = x        # y 和 x 贴在同一个对象上
x = 10       # 这不是"改变 5"，而是让 x 贴到新对象 10 上
print(x)     # 10
print(y)     # 5  ← y 还贴着原来的 5

数字是不可变的，所以这里不产生问题。但列表是可变对象，同样的写法就会出事（阶段 7 会专门讲）。

= 的意思是“贴标签”，不是“赋值”。

12 基本类型

# 整数
a = 42
# 浮点数
b = 3.14
# 字符串
c = "hello"
# 布尔值
d = True

print(type(a))   # <class 'int'>
print(type(b))   # <class 'float'>
print(type(c))   # <class 'str'>
print(type(d))   # <class 'bool'>

关键区别：1 和 1.0 和 "1" 是三个不同的东西

print(1)        # 1        整数
print(1.0)      # 1.0      浮点数
print("1")      # 1        字符串（带引号！）
print(type(1), type(1.0), type("1"))

print(1 + 1)      # 2     数字加法
print("1" + "1")  # 11    字符串拼接！

⚠️ 这是初学者第一个大坑："1" + "1" 得到的是 "11"（拼接），不是 2。
看到引号，它就不是数字。

13 字符串基础

name = "张三"
greeting = "你好，" + name      # 拼接
print(greeting)                 # 你好，张三

print(len(name))                # 2  长度
print(name[0])                  # 张  第一个字符（索引从 0 开始！）
print(name[-1])                 # 三  最后一个字符

⚠️ 索引从 0 开始：name[0] 是第一个，不是 name[1]。这是所有编程语言的惯例。

14 输入与输出

name = input("请输入你的名字：")
age = input("请输入你的年龄：")

print(name, age)
print(type(age))     # <class 'str'>  ⚠️ input 返回的永远是字符串！

⚠️ 第二个大坑：input() 返回的永远是字符串，哪怕你输入的是数字。
要当数字用，必须转换：

age = int(input("请输入你的年龄："))     # 转成整数
next_age = age + 1
print(f"明年你 {next_age} 岁")

类型转换函数：int() float() str()

print(int("42") + 1)      # 43
print(float("3.14") + 1)  # 4.14
print(str(42) + "1")      # 421

15 f-string：格式化输出（最常用）

name = "张三"
age = 18
print(f"{name} 今年 {age} 岁")
# 张三 今年 18 岁

为什么用 f-string：简洁、可读。Python 里这个用得最多，务必掌握。

可以控制小数位数：

pi = 3.14159265
print(f"圆周率约等于 {pi:.2f}")    # 圆周率约等于 3.14

16 注释与缩进

# 这是单行注释，Python 会忽略

"""
这是多行字符串
常被当作多行注释用
"""

缩进是语法的一部分（不像 C 语言只是好看）：

if True:
    print("这一行有缩进")    # 属于 if 内部
print("这一行没有缩进")       # 不属于 if

⚠️ 缩进不一致会直接报错（IndentationError）。
统一用 4 个空格（不要混用 Tab 和空格）。

17 浮点数的精度问题 ⚠️

print(0.1 + 0.2)          # 0.30000000000000004
print(0.1 + 0.2 == 0.3)   # False  !!

为什么会这样：计算机用二进制存小数，而 0.1 和 0.2 在二进制里是无限循环小数，存的时候被截断了。加起来的误差就露出来了。

这不是 Python 的 bug，所有语言都这样（因为都遵循 IEEE 754 标准）。

正确做法：

import math
print(math.isclose(0.1 + 0.2, 0.3))    # True

认知科学里做统计时会实际碰到这个。永远不要用 == 比较浮点数，用 math.isclose。

18 第一次用 numpy 和 matplotlib

下面这段是数学作业第 7 题要用的。你现在还不用懂全部，先能跑起来、看懂在干什么就行。

18.1 为什么需要 numpy

普通 Python 里想算"1 到 50 每个数的 $f(x)$"，得写循环。但如果目的是一次算一整批数，用 numpy 更直接：

import numpy as np          # 惯例：numpy 起名叫 np

n = np.arange(1, 51)        # 1, 2, 3, ..., 50（和 range 一样，不含终点）
a = (1 + 1/n) ** n          # 一次算完 50 个值
print(a[:5])                # 前 5 个
print(a.shape)              # (50,)   → 长度 50 的数组

核心思想叫「向量化」：1/n 不是"一个数除以一个数"。它说的是
"1 分别除以数组里的每一个数"，得到一个同样长度的新数组。

import numpy as np
n = np.arange(1, 6)         # [1 2 3 4 5]
print(1 + 1/n)              # [2.   1.5   1.333  1.25  1.2 ]
print((1 + 1/n) ** n)       # [2.   2.25  2.370  2.441 2.488]

⚠️ 和 range 的区别：np.arange 的结果是一个数组，可以直接参与运算；
而普通 range 只是"一串数"的生成器（阶段 3 会讲），不能这样直接算。
这里先认识 arange 就行。

💡 为什么这个思想重要：numpy 的向量化运算底层是 C 语言，比 Python 的 for 循环快几十倍。
后面学数据处理时，你有没有用向量化，直接决定程序是秒级还是分钟级。

18.2 画图：matplotlib

import numpy as np
import matplotlib.pyplot as plt

n = np.arange(1, 51)
a = (1 + 1/n) ** n

plt.plot(n, a, marker="o", markersize=3)     # 折线 + 圆点
plt.axhline(np.e, color="red", linestyle="--", label=f"e ≈ {np.e:.6f}")
plt.xlabel("n")
plt.ylabel("$a_n$")
plt.title("$(1+1/n)^n$ 趋近于 e")
plt.legend()
plt.show()

骨架记牢这四行：plot（画）→ xlabel/ylabel（标轴）→ title（标题）→ show（显示）。

中文字体：如果图里的中文变成方框，在开头加这两行：

import matplotlib
matplotlib.rcParams["font.sans-serif"] = ["PingFang SC", "Arial Unicode MS"]
matplotlib.rcParams["axes.unicode_minus"] = False

19 🔧 技能卡 1：读懂报错信息

你写错代码的概率是 100%。关键在犯错之后能不能自己定位。

19.1 报错长这样

Traceback (most recent call last):
  File "<ipython-input-3-a1b2c3>", line 2, in <module>
    print(name[5])
          ~~~~^^^
IndexError: string index out of range

19.2 读法：从最后一行往上读

💡 新手最常犯的错：看到一大串就慌了、直接关掉。
其实只要看最后一行，90% 的情况立刻就明白了。

19.3 常见报错速查

19.4 ⚠️ 中文标点：中文输入法下写代码的头号杀手

if True：              # ❌ 这是中文冒号 ：
    print("x")

if True:               # ✅ 英文冒号 :
    print("x")

报错会说：SyntaxError: invalid character '：' (U+FF1A)。

容易混的几对：：vs: ｜ ，vs, ｜ （）vs() ｜ “”vs""
写代码时请把输入法切到英文。

19.5 最实用的调试法：print 大法

在可疑的地方打印中间结果，看它到哪一步开始不对。

def 算面积(w, h):
    print("w =", w, "h =", h)      # ← 先看看传进来的到底是什么
    area = w * h
    print("area =", area)          # ← 再看算出来是什么
    return area

💡 这招看着笨，但专业程序员每天都在用。
尤其当你"以为"某个变量是 3、实际是 "3"（字符串）的时候，一 print 就现原形。

20 编程作业 S1

• [ ] 1. 写一个程序：询问姓名和年龄，输出"张三，你 18 岁，明年 19 岁"

  注意：年龄是数字，要转换类型才能加 1

• [ ] 2. 用 type() 打印出 1、1.0、"1"、True 的类型，观察区别
• [ ] 3. 算 0.1 + 0.2，看结果是不是 0.3；再用 math.isclose 验证
• [ ] 4. 输入两个数（用户用 input 输入），输出它们的和、差、积、商

  提示：要 float(input(...))

• [ ] 5. 输入一个三位数（如 365），输出它的百位、十位、个位数字

  提示：365 // 100 得 3，365 % 10 得 5。
  //（整除）和 %（取余）这两个运算符，阶段 2 第 1 节会正式讲。
  这里先照着提示用，能跑通就行。

• [ ] 6.（技能）故意写错代码，练习读报错：

  ① 把 print("hi" 的右括号删掉 → 看 SyntaxError
  ② 用中文冒号写 if True： → 看那个 invalid character 的报错
  ③ 打印一个没赋值的变量 → 看 NameError
  ④ 算 "1" + 1 → 看 TypeError

  目标：看到报错时，能立刻说出"哪一行、什么类型、大概为什么"。

第 1 题参考框架（先自己写，卡住了再看）：

name = input("请输入姓名：")
age = int(input("请输入年龄："))     # ← 关键：转成整数

print(f"{name}，你 {age} 岁，明年 {age + 1} 岁")

第 5 题提示：

num = int(input("输入三位数："))
bai = num // 100
shi = (num // 10) % 10
ge = num % 10
print(f"百位{bai} 十位{shi} 个位{ge}")

本阶段自评

做完作业后，回答这几个问题：

1. 数学：你能不看笔记，把 ε-N 定义默写出来并解释清楚吗？
2. 数学：极限的四则运算法则有什么前提？为什么法则是单向的？
3. 数学：单调有界准则需要你猜出极限值吗？它到底保证了什么？
4. 数学：数学归纳法的两步是什么？为什么缺一不可？
5. 数学：$(1+1/n)^n$ 的极限是 $e$，这是算出来的还是定义出来的？
6. 编程：你能解释为什么 "1" + "1" 不等于 2 吗？
7. 编程：1/n（n 是 numpy 数组）是什么意思？为什么它比 for 循环快？
8. 技能：报错信息应该从哪一行读起？TypeError 和 ValueError 有什么区别？
9. 动手：第 10 题（画图）跑出来了吗？

全都能答"是" → 进阶段 2。
有任何一个答不上 → 把对应的作业重做一遍。别跳。