🚀 肝了三个月！超硬核Python全体系保姆级学习笔记（2026考级/考研/项目实战通用，建议收藏）

🌟 前言：为什么你必须拿下这份笔记？

大家好，我是字节跳动旗下 AI 编程工具 TRAE 的校园大使，同时也是今年"挑战杯"比赛获奖队伍的研发核心成员（在项目中主要负责 AI 模型的双层次反思模块与提示词工程）。

平时因为对编程有极其浓厚的兴趣，我经常会动手写各种自动化脚本，也踩过无数大大小小的坑。在这个过程中我发现一个致命问题：市面上的教程要么太啰嗦，要么只教语法不教底层，导致很多人一到机试或者要自己动手写脚本、接手真实项目时，就当场死机。

为了把我的实战和踩坑经验沉淀下来，我花了整整三个月时间，把 Python 从零基础到初级开发者的全体系核心内容，硬核重构成了这份可直接用于高分通关与实战开发的保姆级笔记。

这份笔记摒弃废话，直击核心，覆盖了从环境搭建、底层基础到流程控制、组合数据类型、函数、面向对象、模块化编程、常用标准库等所有必备内容。每一个知识点我都标注了🔥 考试/实战高频考点和💡 易错踩坑点。

⚠️ 预警：本文极度干货，字字珠玑，篇幅较长。强烈建议先【点赞+收藏】，无论是当做案头速查手册，还是考前/面试前突击复习，这篇绝对是你的神级辅助！

---

第一章 Python环境搭建与开发工具（入门第一步）

1.1 Python解释器安装

• 官网下载：https://www.python.org/downloads/
• 版本选择：推荐3.10+稳定版，绝对不要用Python2
• 安装注意：Windows系统务必勾选"Add Python to PATH"，否则无法在命令行使用python命令

1.2 主流开发工具对比与选择

工具	特点	适用场景
VS Code	轻量免费，插件丰富，启动快	日常脚本、小型项目
PyCharm Community	专业Python IDE，智能提示强大	中大型项目、团队开发
IDLE	Python自带，无需额外安装	临时测试、教学演示
Jupyter Notebook	交互式编程，支持Markdown	数据分析、机器学习

1.3 包管理工具pip（开发必备）

# 安装第三方库
pip install requests

# 安装指定版本
pip install requests==2.31.0

# 升级库
pip install --upgrade requests

# 卸载库
pip uninstall requests

# 查看已安装的库
pip list

# 导出已安装的库列表（项目依赖）
pip freeze > requirements.txt

# 批量安装项目依赖
pip install -r requirements.txt

1.4 虚拟环境（项目隔离神器）

为什么需要虚拟环境？ 不同项目可能需要不同版本的库，虚拟环境可以隔离项目依赖，避免版本冲突。

# 创建虚拟环境（在项目根目录执行）
python -m venv venv

# 激活虚拟环境
# Windows
venv\Scripts\activate
# Mac/Linux
source venv/bin/activate

# 激活后，命令行前面会出现(venv)标识
# 此时pip安装的库只会在这个虚拟环境中

# 退出虚拟环境
deactivate

1.5 第一个Python程序

print("Hello, Python!")

---

第二章 Python编程基础

这一章是Python的入门基石，也是各种选择题、判断题、面试基础问答的出题重灾区，绝对不能在基础细节上丢分。

2.1 程序设计语言基础

所有编程语言都可以分为三类：

1. 机器语言：直接使用二进制代码，硬件直接识别。执行效率最高，可读性极差。
2. 汇编语言：使用助记符与机器语言对应，降低了门槛，但可移植性差。
3. 高级语言：接近自然语言，屏蔽硬件底层，可移植性强（如Python、Java、C++）。

编译型 vs 解释型（高频考点）：

类型	核心执行逻辑	代表语言	核心特点
编译型	编译器将源码一次性转换为机器语言，直接执行目标代码	C、C++	执行效率高，一次编译多次执行
解释型	解释器逐条转换并执行，不生成可执行文件	Python、JS	跨平台性强，调试灵活

2.2 Python语言简介与核心特点

• 语法简洁，强制可读：通过缩进体现逻辑关系，代码如诗。
• 胶水语言：能极其轻松地对接C/C++等底层模块。
• 主流应用霸主：目前是人工智能与大模型开发的首选绝对王者，同时在数据分析、Web开发、网络爬虫自动化领域一统江湖。

2.3 IPO程序编写方法

IPO是写所有代码的核心框架，不管多复杂的算法题或日常脚本，都可以用IPO思路拆解：

• I（Input）输入：键盘输入、文件读取、接口参数等。
• P（Process）处理：核心逻辑处理，得分与性能优化的关键。
• O（Output）输出：控制台打印、文件写入等，必须严格匹配格式。

2.4 核心输入输出函数（细节拉满）

2.4.1 输出函数 print()

完整语法格式：print(value, ..., sep=' ', end='\n', file=None)
🔥 参数详解与实战：

• sep：多个值之间的分隔符，默认为空格。
• end：输出结束时追加的字符，默认为换行符\n。控制不换行全靠它！
• file：输出到文件，默认是控制台

# 1. 修改分隔符
print("挑战杯", "TRAE", "Python", sep=" | ") # 输出：挑战杯 | TRAE | Python

# 2. 控制输出不换行
for i in range(3):
    print(i, end=" ") # 输出：0 1 2 

# 3. f-string格式化输出（日常写脚本最常用，墙裂推荐）
role = "AI提示词工程"
print(f"我在团队中负责：{role}") 

# 4. 输出到文件
with open("output.txt", "w") as f:
    print("Hello, Python!", file=f)

2.4.2 输入函数 input()

🔥 核心法则：无论用户输入什么，input()的返回值永远是字符串（str）类型。用于数值运算，必须强制类型转换！

age = int(input("请输入你的年龄：")) # 必须加int()
height = float(input("请输入你的身高（米）：")) # 必须加float()

2.5 注释与缩进（灵魂规范）

1. 注释：# 单行注释，''' 或 """ 多行注释（文档字符串）。
2. 代码缩进：Python语法的灵魂。行业规范：统一使用4个空格作为一个缩进量。缩进错误会导致 IndentationError 或逻辑完全错乱。

---

第三章 Python数据类型与底层运算

这一章是语法的核心，知识点细碎，是大厂笔试、学校期末考客观题的绝对出题重灾区。

3.1 标识符与保留字

• 标识符：只能由字母（含中文）、数字、下划线组成，第一个字符绝对不能是数字。严格区分大小写。
• 保留字：绝对不能做变量名。注意大小写陷阱：True、False、None是保留字，而true不是！

3.2 八大基本数据类型

数据类型	描述	示例
整数 int	支持二进制(0b)、八进制(0o)、十进制、十六进制(0x)	0b1010、0xf2
浮点数 float	带小数点的数值	3.14
复数 complex	实部.real，虚部.imag	3+4j
字符串 str	单/双/三引号包裹，不可变序列	'Prompt'
布尔 bool	True(1)和False(0)	True、False
空 NoneType	只有None一个取值	None
字节串 bytes	不可变二进制数据	b'hello'
字节数组 bytearray	可变二进制数据	bytearray(b'hello')

🔥 核心考点：到底什么才是False？
以下对象的布尔值均为False：False、None、数值0、0.0、空序列（""、[]、()、{}、set()、b''）。其余全为True。

3.3 字符串与字节串的转换

# 字符串转字节串（编码）
s = "你好"
b = s.encode("utf-8")  # b'\xe4\xbd\xa0\xe5\xa5\xbd'

# 字节串转字符串（解码）
s2 = b.decode("utf-8")  # "你好"

3.4 运算符全系精讲（带你手撕底层逻辑）

3.4.1 算术与赋值运算符

• /：除法（结果永远是浮点数，如 10/2 = 5.0）
• //：整除（向下取整）。例：10//3 = 3； -10//3 = -4
• %：取余，结果永远和除数同号
• **：幂运算。
• a, b = b, a：Python独有的神仙语法，底层通过元组解包瞬间实现变量值互换。

💡 致命踩坑：浮点数精度陷阱（判断题必考）

print(0.1 + 0.2 == 0.3)  # False！
# 原因：二进制无法精确表示0.1和0.2，实际结果是0.30000000000000004
# 正确比较方式
print(abs(0.1 + 0.2 - 0.3) < 1e-9)  # True

3.4.2 比较运算符

• ==：值相等
• !=：值不相等
• >、<、>=、<=：大小比较

🔥 链式比较（Python独有，选择题必考）
Python支持链式比较，等价于多个and连接：

print(3 > 2 > 1)  # True 等价于 3>2 and 2>1
print(5 > 3 < 4)  # True 等价于 5>3 and 3<4

易错点：3 > 2 > 1 不等于 (3>2) > 1！

3.4.3 身份运算符（is vs ==）

• == 判断两个对象的值(value)是否相等。
• is 判断两个对象的内存地址(id)是否相同（是不是同一个对象）。

💡 必考：小整数池机制
Python会缓存[-5, 256]之间的整数，这些整数在内存中只有一份：

print(100 == 100)  # True
print(100 is 100)  # True（小整数池，同一个对象）

print(257 == 257)  # True
print(257 is 257)  # False（超出小整数池，两个不同对象）

3.4.4 成员运算符

• in：判断元素是否在序列中
• not in：判断元素是否不在序列中

3.4.5 位运算符（大厂笔试必考）

运算符	描述说明	核心速记技巧
&	按位与	对应位都为1，结果才为1。
`	`	按位或
^	按位异或	对应位不同结果为1，相同为0。
~	按位取反	终极公式：~x = -(x + 1)。（例：~5 = -6）
<<	左移位	左移 n 位，等价于乘以 2的n次方。（例：3 << 2 = 12）
>>	右移位	右移 n 位，等价于向下整除 2的n次方。（例：11 >> 1 = 5）

👑 【压箱底绝活】Python逻辑运算符返回值 终极总结

这是极易混淆的重灾区！逻辑运算符不仅能判断布尔值，还会返回具体的数据对象。

运算符	纯布尔值场景（if条件中）	通用场景（直接打印/赋值时）	终极口诀
and	全真才真，一假全假	遇假返假，全真返最后一个	从左到右找假，找不到返最后
or	一真全真，全假才假	遇真返真，全假返最后一个	从左到右找真，找不到返最后
not	真变假，假变真	永远只返回 True 或 False	强制返回布尔值

🔥 必背真题速记：

print(1 and 2)   # 2 （全真，返回最后一个）
print(0 and 3)   # 0 （遇假，返回这个假值）
print(1 or 2)    # 1 （遇真，返回这个真值）
print(0 or "")   # "" （全假，返回最后一个假值）

---

第四章 Python程序的流程控制

4.1 三大基本结构

1. 顺序结构：从上到下依次执行。
2. 分支结构：if - elif - else。（注意：elif可多个，else最多1个且放最后）
3. 循环结构：for（已知范围遍历）、while（未知次数条件循环）。

🔥 布尔值隐式转换（判断题必考）
在if、while等条件语句中，Python会自动将任何值转换为布尔值：

if []:
    print("执行")  # 不会执行，空列表是False
if "0":
    print("执行")  # 会执行，非空字符串是True

4.2 循环的进阶神技

• for-else / while-else 结构：Python特有语法。else代码块仅在循环正常结束（未被break中断）时才会执行。常用于搜索算法中"遍历完未找到"的处理。
• break：跳出当前所在的一层整个循环。
• continue：跳过本次循环剩余代码，直接进入下一次循环。
• pass：合法占位符，保证代码结构完整不报错。

---

第五章 Python组合数据类型（数据结构的灵魂）

5.1 序列基础与切片大法

切片语法：序列[start:end:step]
🔥 核心规则：左闭右开（包含start，不包含end）。

💡 必考边界情况

• 当start超过序列长度时，返回空序列："abc"[10:] = ""
• 当end为0且步长为负时，包含索引0："abc"[2:0:-1] = "cb"
• s[::-1]：步长为-1，瞬间实现序列反转，回文判断神器。

5.2 字符串高频操作（爬虫脚本/数据清洗必会）

字符串是不可变序列，所有修改操作都会生成新字符串：

• s.split(' ')：按指定字符切割，返回列表。
• '-'.join(lst)：用指定字符将列表元素（必须都是字符串）连接成字符串。
• s.replace(old, new)：替换子串。
• s.strip()：去除首尾的空白字符（包括空格、\n、\t）。
• s.startswith("prefix")：判断是否以指定前缀开头
• s.endswith("suffix")：判断是否以指定后缀结尾
• s.count("sub")：统计子串出现的次数
• s.find("sub")：查找子串第一次出现的索引，找不到返回-1
• s.upper() / s.lower()：转大写/小写
• s.title()：每个单词首字母大写

5.3 列表（List）与 元组（Tuple）

• 列表：可变序列，支持增删改查。
• append(x)：整体加入末尾。
• extend(iterable)：打散后追加末尾。
• insert(index, x)：在指定索引插入元素。
• 删除方法三兄弟（选择题必考）：
  • lst.pop(index)：按索引删除，返回被删除的元素
  • lst.remove(value)：按值删除第一个匹配项，返回None
  • del lst[index]：按索引删除，无返回值
• 排序双雄：lst.sort()（原地排序，返回None）；sorted(lst)（生成新列表，有返回值）。
• lst.reverse()：原地反转列表。
• lst.index(value)：查找元素第一次出现的索引。
• lst.count(value)：统计元素出现的次数。

💡 列表推导式（Pythonic写法，开发必备）

# 生成1-10的平方列表
squares = [x**2 for x in range(1, 11)]
# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# 带条件的列表推导式
even_squares = [x**2 for x in range(1, 11) if x % 2 == 0]
# [4, 16, 36, 64, 100]

# 嵌套列表推导式（矩阵转置）
matrix = [[1,2,3], [4,5,6], [7,8,9]]
transpose = [[row[i] for row in matrix] for i in range(3)]
# [[1,4,7], [2,5,8], [3,6,9]]

💡 致命踩坑：列表乘法创建二维数组

# 错误写法：创建3个指向同一个空列表的引用
a = [[]] * 3
a[0].append(1)
print(a)  # 输出：[[1], [1], [1]]（所有子列表都变了）

# 正确写法：创建3个独立的空列表
a = [[] for _ in range(3)]
a[0].append(1)
print(a)  # 输出：[[1], [], []]

• 元组：不可变序列，线程安全。

💡 必考：元组不可变性的本质
元组不可变的是元素的引用，而不是元素本身的值：

t = (1, [2, 3])
t[0] = 100  # 报错：不能修改元组的引用
t[1][0] = 200  # 可以：修改列表本身的值，列表的引用没变

防坑警告：单元素元组必须加逗号！ (10,)是元组，(10)是整型。

5.4 字典（Dict）与 集合（Set）

• 字典：哈希表结构，查找O(1)。键必须是不可变类型（列表不能当键）。
• 安全取值：永远推荐使用 d.get(key, default)，找不到不报错返回默认值。
• 遍历：for k, v in d.items():
• d.keys()：获取所有键
• d.values()：获取所有值
• d.update(new_dict)：批量更新字典
• d.pop(key)：删除指定键并返回值
• d.popitem()：删除最后一个插入的键值对

💡 字典推导式

# 生成键为数字，值为平方的字典
square_dict = {x: x**2 for x in range(1, 6)}
# {1:1, 2:4, 3:9, 4:16, 5:25}

💡 必考：in运算符的字典行为
in 作用于字典时，只判断键是否存在，不判断值：

d = {"name": "张三", "age": 18}
print("name" in d)  # True（键存在）
print("张三" in d)  # False（值不存在）

• 集合：无序不可重复。核心用途：数据去重。
• s.add(x)：添加元素
• s.remove(x)：删除元素，不存在报错
• s.discard(x)：删除元素，不存在不报错
• s.pop()：随机删除一个元素
• 支持 & (交集)、| (并集)、- (差集)、^ (对称差集)

s1 = {1,2,3,4}
s2 = {3,4,5,6}

print(s1 & s2)  # 交集：{3,4}
print(s1 | s2)  # 并集：{1,2,3,4,5,6}
print(s1 - s2)  # 差集：{1,2}
print(s1 ^ s2)  # 对称差集：{1,2,5,6}

5.5 👑 核心原理：深浅拷贝 (大厂面试/复杂逻辑绝对高频)

当数据结构嵌套时（比如多层级的 JSON 解析），直接赋值会引发灾难。

import copy
a = [1, [2, 3]]

# 1. 赋值（引用）
b = a  # 内存地址完全一致，改a的任何层，b都会跟着变。

# 2. 浅拷贝 (Shallow Copy)
c = a.copy() # 或者 copy.copy(a)
# 第一层互相独立，但嵌套的内层（如[2,3]）依然共享内存地址！
c[0] = 100  # a不变
c[1][0] = 200  # a也变成[1, [200, 3]]

# 3. 深拷贝 (Deep Copy)
d = copy.deepcopy(a) 
# 递归拷贝所有层级，a和d在内存中完全独立，互不影响！

---

第六章 Python函数与模块化编程

函数是代码复用、写出"高可维护性"项目代码的核心载体。在构建大模型双层反思模块时，合理的函数划分至关重要。

6.1 函数基础

函数定义语法：

def 函数名(参数列表):
    """文档字符串：描述函数的功能、参数和返回值"""
    函数体
    return 返回值

💡 必考：return语句细节

• 函数如果没有写return语句，默认返回None
• return会立即终止函数，后面的代码不会执行
• 可以返回多个值，底层会打包成元组

def func():
    print("hello")
print(func())  # 输出：hello None

def add_and_multiply(a, b):
    return a + b, a * b

sum_result, product_result = add_and_multiply(2, 3)
print(sum_result, product_result)  # 5 6

6.2 函数参数的四大天王（顺序不可乱）

1. 位置参数：按顺序一一对应。
2. 默认值参数：定义时赋默认值。必须放在位置参数后面！

致命陷阱：默认参数绝对不能是可变类型（如lst=[]），否则多次调用会发生内存复用导致数据污染，必须用 lst=None 替代。

🔥 必考：函数参数传递的本质
Python中所有函数参数传递都是传对象引用：

• 传递不可变对象（int、str、tuple）：函数内修改不会影响原对象
• 传递可变对象（list、dict、set）：函数内修改会影响原对象

def func1(x):
    x = 100  # 不可变对象，重新赋值，不影响原变量

def func2(lst):
    lst.append(100)  # 可变对象，原地修改，影响原列表

a = 10
func1(a)
print(a)  # 10（不变）

b = [1,2,3]
func2(b)
print(b)  # [1,2,3,100]（变了）

3. 可变位置参数（*args）：打包成元组，接收任意多个位置参数。
4. 可变关键字参数（**kwargs）：打包成字典，接收任意多个关键字参数。

def func(*args, **kwargs):
    print("位置参数：", args)
    print("关键字参数：", kwargs)

func(1, 2, 3, name="张三", age=18)
# 输出：
# 位置参数： (1, 2, 3)
# 关键字参数： {'name': '张三', 'age': 18}

6.3 作用域与 global

• 局部变量仅在函数内有效。
• 修改全局变量：如果要在函数内部重新赋值全局变量，必须先用 global 变量名 声明！

💡 必考：全局变量与局部变量同名
如果函数内部定义了和全局变量同名的局部变量，会屏蔽全局变量：

x = 10
def func():
    x = 20  # 局部变量，屏蔽全局变量
    print(x)
func()  # 输出20
print(x)  # 输出10

6.4 lambda匿名函数（排序题必考）

语法：lambda 参数: 表达式
最常用场景：作为sorted()、map()、filter()的key参数

students = [{"name": "张三", "score": 90}, {"name": "李四", "score": 85}]
# 按分数从高到低排序
students_sorted = sorted(students, key=lambda x: x["score"], reverse=True)

# map：对每个元素应用函数
nums = [1,2,3,4,5]
squares = list(map(lambda x: x**2, nums))  # [1,4,9,16,25]

# filter：过滤元素
evens = list(filter(lambda x: x%2==0, nums))  # [2,4]

6.5 函数进阶

6.5.1 闭包

内部函数引用了外部函数的变量，并且外部函数返回了内部函数，这个内部函数就是闭包。

def outer(x):
    def inner(y):
        return x + y
    return inner

add5 = outer(5)
print(add5(3))  # 8

6.5.2 装饰器基础

在不修改原函数代码的情况下，给函数添加额外功能。

def timer(func):
    def wrapper(*args, **kwargs):
        import time
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"{func.__name__}执行时间：{end - start:.2f}秒")
        return result
    return wrapper

@timer
def sleep_2_seconds():
    import time
    time.sleep(2)

sleep_2_seconds()

6.6 模块与包（代码复用的核心）

6.6.1 导入模块的方式

# 1. 导入整个模块
import math
print(math.pi)

# 2. 导入模块中的特定函数/变量
from math import sqrt, pi
print(sqrt(4))

# 3. 导入模块并起别名
import numpy as np

# 4. 导入模块中的所有内容（不推荐）
from math import *

6.6.2 自定义模块

创建一个utils.py文件：

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

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

在另一个文件中导入：

from utils import add
print(add(1, 2))

6.6.3 包的结构

包是包含多个模块的文件夹，必须包含__init__.py文件：

my_package/
    __init__.py
    module1.py
    module2.py

导入包中的模块：

from my_package import module1

6.7 必备标准库速记

• random.randint(a, b)：生成 [a, b] 之间的整数。注意包含b，这是Python少有的双闭区间！
• random.choice(seq)：从序列中随机选一个元素。
• random.shuffle(seq)：随机打乱序列
• math.ceil() / math.floor()：向上/向下取整。
• math.sqrt()：平方根

---

第七章 常用标准库详解（开发必备）

7.1 os模块（操作系统接口）

import os

print(os.getcwd())  # 获取当前工作目录
os.chdir("..")  # 切换工作目录
print(os.listdir())  # 列出目录下的所有文件和文件夹
os.mkdir("new_dir")  # 创建单级目录
os.makedirs("a/b/c")  # 创建多级目录
os.rmdir("new_dir")  # 删除空目录
os.remove("test.txt")  # 删除文件
os.rename("old.txt", "new.txt")  # 重命名文件
print(os.path.exists("test.txt"))  # 判断文件/目录是否存在
print(os.path.isfile("test.txt"))  # 判断是否是文件
print(os.path.isdir("test_dir"))  # 判断是否是目录
print(os.path.join("a", "b", "c.txt"))  # 拼接路径：a/b/c.txt
print(os.path.basename("a/b/c.txt"))  # 获取文件名：c.txt
print(os.path.dirname("a/b/c.txt"))  # 获取目录名：a/b
print(os.path.splitext("c.txt"))  # 分离文件名和扩展名：('c', '.txt')

7.2 sys模块（系统相关）

import sys

print(sys.version)  # 获取Python版本
print(sys.platform)  # 获取操作系统平台
print(sys.argv)  # 获取命令行参数（列表，第一个元素是脚本名）
sys.exit(0)  # 退出程序，0表示正常退出

7.3 datetime模块（日期时间处理）

from datetime import datetime, date, time, timedelta

# 获取当前时间
now = datetime.now()
print(now)  # 2026-05-15 15:30:00.123456

# 格式化时间
print(now.strftime("%Y-%m-%d %H:%M:%S"))  # 2026-05-15 15:30:00

# 字符串转时间
dt = datetime.strptime("2026-05-15", "%Y-%m-%d")

# 日期计算
tomorrow = now + timedelta(days=1)
one_hour_ago = now - timedelta(hours=1)

# 获取日期的各个部分
print(now.year)  # 2026
print(now.month)  # 5
print(now.day)  # 15
print(now.hour)  # 15
print(now.minute)  # 30
print(now.second)  # 0

7.4 json模块（JSON数据处理）

import json

# Python对象转JSON字符串
data = {"name": "张三", "age": 18, "hobbies": ["读书", "跑步"]}
json_str = json.dumps(data, ensure_ascii=False, indent=4)
print(json_str)

# JSON字符串转Python对象
data2 = json.loads(json_str)
print(data2["name"])  # 张三

# 写入JSON文件
with open("data.json", "w", encoding="utf-8") as f:
    json.dump(data, f, ensure_ascii=False, indent=4)

# 读取JSON文件
with open("data.json", "r", encoding="utf-8") as f:
    data3 = json.load(f)

7.5 re模块（正则表达式）

import re

# 匹配手机号
pattern = r"^1[3-9]\d{9}$"
phone = "13812345678"
if re.match(pattern, phone):
    print("手机号格式正确")
else:
    print("手机号格式错误")

# 查找所有匹配的子串
text = "我的邮箱是zhangsan@example.com，李四的邮箱是lisi@test.com"
emails = re.findall(r"\w+@\w+\.\w+", text)
print(emails)  # ['zhangsan@example.com', 'lisi@test.com']

# 替换子串
new_text = re.sub(r"\d+", "*", "我的手机号是13812345678")
print(new_text)  # 我的手机号是*

---

第八章 文件操作与异常处理

8.1 文件操作基础

8.1.1 文件打开模式

模式	作用	特点
‘r’	只读	文件不存在报错
‘w’	只写	清空原有内容，文件不存在自动创建
‘a’	追加	在末尾添加，文件不存在自动创建
‘r+’	读写	文件不存在报错
‘w+’	读写	清空原有内容，文件不存在自动创建
‘a+’	读写	在末尾添加，文件不存在自动创建
‘rb’	二进制只读	用于读取图片、视频等二进制文件
‘wb’	二进制只写	用于写入图片、视频等二进制文件

8.1.2 文件读写方法

# 打开文件
f = open("test.txt", "r", encoding="utf-8")

# 读取全部内容
content = f.read()

# 读取一行
line = f.readline()

# 读取所有行，返回列表
lines = f.readlines()

# 写入字符串
f.write("Hello, Python!\n")

# 写入多行
f.writelines(["第一行\n", "第二行\n"])

# 关闭文件
f.close()

8.2 文件优雅操作 (with上下文管理)

不用手动写 .close()，底层自动释放资源，即使代码块中发生异常也会执行。这是Python文件操作的标准写法。

with open("test.txt", "r", encoding="utf-8") as f:
    content = f.read()
# 代码块结束后，文件自动关闭

8.3 异常处理终极结构

🔥 常见异常类型（选择题必考）

• ValueError：值错误（如int("abc")）
• TypeError：类型错误（如1 + "2"）
• IndexError：索引越界（如列表只有3个元素，访问lst[10]）
• KeyError：字典键不存在（如d["xxx"]）
• ZeroDivisionError：除数为0
• FileNotFoundError：文件不存在
• PermissionError：权限不足

try:
    # 可能发生异常的代码
    num = 10 / 0
except ZeroDivisionError:
    # 捕获特定异常
    print("除数不能为0")
except Exception as e:
    # 兜底捕获所有异常
    print(f"发生了错误：{e}")
else:
    # 只有try未发生任何异常时才执行
    print("没有发生异常")
finally:
    # 无论是否异常、无论是否return，必须执行的收尾清理代码
    print("无论如何都会执行")

---

第九章 面向对象编程(OOP)进阶

面向对象的三大特征：封装、继承、多态。写复杂模型或者封装 API Client 必备。

9.1 类与实例

class Person:
    # 类属性
    species = "人类"
    
    # 构造方法，实例化时自动调用
    def __init__(self, name, age):
        # 实例属性
        self.name = name
        self.age = age
    
    # 实例方法
    def say_hello(self):
        print(f"大家好，我是{self.name}，今年{self.age}岁")
    
    # 类方法
    @classmethod
    def get_species(cls):
        return cls.species
    
    # 静态方法
    @staticmethod
    def is_adult(age):
        return age >= 18

# 创建实例
p1 = Person("张三", 18)
p1.say_hello()  # 大家好，我是张三，今年18岁

print(Person.get_species())  # 人类
print(Person.is_adult(20))  # True

9.2 访问控制

• 公有属性/方法：直接定义，外部可以访问
• 私有属性/方法：变量名前加双下划线 __name，底层会触发名称改写机制（变为 _类名__name），外部无法直接访问
• 保护属性/方法：变量名前加单下划线 _name，约定俗成表示不应该被外部访问，但实际上可以访问

class Person:
    def __init__(self, name, age):
        self.name = name  # 公有属性
        self._age = age  # 保护属性
        self.__id_card = "123456789012345678"  # 私有属性
    
    def get_id_card(self):
        # 提供公有方法访问私有属性
        return self.__id_card[:6] + "********"

p = Person("张三", 18)
print(p.name)  # 张三
print(p._age)  # 18（可以访问，但不推荐）
# print(p.__id_card)  # 报错，无法直接访问
print(p.get_id_card())  # 123456********

9.3 继承

class Animal:
    def __init__(self, name):
        self.name = name
    
    def speak(self):
        print(f"{self.name}发出声音")

class Dog(Animal):
    def __init__(self, name, breed):
        # 调用父类的构造方法
        super().__init__(name)
        self.breed = breed
    
    # 重写父类方法
    def speak(self):
        print(f"{self.name}汪汪叫")

dog = Dog("旺财", "金毛")
dog.speak()  # 旺财汪汪叫

9.4 多态

def make_speak(animal):
    animal.speak()

make_speak(Animal("动物"))  # 动物发出声音
make_speak(Dog("旺财", "金毛"))  # 旺财汪汪叫

9.5 👑 类的魔术方法 (进阶提分项)

让你的自定义类能像Python原生数据类型一样被优雅操作。

• __str__(self)：定义打印对象时的字符串表现形式（给用户看的）。
• __repr__(self)：定义对象的官方字符串表现形式（给开发者看的）。
• __len__(self)：定义 len(obj) 时的行为。
• __eq__(self, other)：定义 obj1 == obj2 时的比较逻辑。
• __add__(self, other)：定义 obj1 + obj2 时的行为。
• __getitem__(self, key)：定义 obj[key] 时的行为。
• __setitem__(self, key, value)：定义 obj[key] = value 时的行为。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def __str__(self):
        return f"Person(name={self.name}, age={self.age})"
    
    def __eq__(self, other):
        return self.name == other.name and self.age == other.age

p1 = Person("张三", 18)
p2 = Person("张三", 18)
print(p1)  # Person(name=张三, age=18)
print(p1 == p2)  # True

---

第十章 Python高级特性

10.1 迭代器

迭代器是一个可以记住遍历位置的对象，实现了__iter__()和__next__()方法。

lst = [1,2,3]
it = iter(lst)  # 获取迭代器
print(next(it))  # 1
print(next(it))  # 2
print(next(it))  # 3
# next(it)  # 抛出StopIteration异常

10.2 生成器

生成器是一种特殊的迭代器，使用yield关键字，节省内存。

# 生成器函数
def fib(n):
    a, b = 0, 1
    for _ in range(n):
        yield b
        a, b = b, a + b

for num in fib(5):
    print(num)  # 1 1 2 3 5

# 生成器表达式
gen = (x**2 for x in range(5))
print(next(gen))  # 0
print(next(gen))  # 1

---

第十一章 Python编码规范（PEP 8）

良好的编码规范是团队协作的基础，也是面试的加分项。

1. 缩进：使用4个空格，不使用制表符
2. 行长度：每行不超过79个字符
3. 空行：函数和类之间空两行，函数内的逻辑块之间空一行
4. 命名规范：
   • 变量名、函数名、模块名：小写字母加下划线（snake_case）
   • 类名：大驼峰命名法（CamelCase）
   • 常量：全大写加下划线（UPPER_CASE）
5. 导入：导入语句放在文件顶部，按标准库、第三方库、本地库顺序排列
6. 注释：使用#进行单行注释，文档字符串使用三引号
7. 空格：运算符两边加空格，逗号后面加空格

---

☢️ 第十二章 避坑指南：核心代码错误终极总结

（为什么你的机试题死活跑不通？脚本总报错？大概率踩了这12个坑！）

1. 类型丢失（最致命）：max_stu = [] 后接 max_stu = s["name"]，列表直接变成了字符串，随后调用 .append() 直接崩溃。必须写成 max_stu = [s["name"]]。
2. 逻辑运算符返回值：以为1 and 2返回True，实际返回2
3. 负数整除：10//-3不是-3，是-4
4. for-else结构：以为else永远执行，实际只有循环正常结束才执行
5. 默认参数是可变类型：多次调用函数数据污染
6. 深浅拷贝：嵌套列表浅拷贝导致原数据被修改
7. input()返回字符串：忘记转类型导致运算错误
8. 字典键是列表：直接报错，键必须是不可变类型
9. write()不写换行：所有内容连在一起，格式错误
10. break跳出多层循环：break只能跳出当前一层循环
11. 列表乘法创建二维数组：所有子列表指向同一个引用
12. 浮点数直接比较：0.1 + 0.2 == 0.3结果是False

---

🎁 结语与彩蛋（求一键三连！）

在准备"挑战杯"竞赛和担任 TRAE 校园大使的这段时间里，我深知"底层基础决定上层建筑"。这份笔记不仅是为了应付期末考或计算机等级考试，更是为了大家在日后手撕脚本、甚至像我一样去负责 AI 核心模块开发时，不用再去疯狂百度最基础的语法。

编程是一门手艺，看懂永远不等于会写，建议把文中的踩坑代码亲自在 IDE 里敲一遍，绝对受益匪浅！

👇 如果这篇万字硬核长文对你有哪怕一点点帮助，求求大家动动发财的小手给个【一键三连】（点赞、收藏、关注）！你的支持是我持续产出硬核技术干货的唯一动力！

💡 互动时间：
你在学Python或者日常写脚本时，踩过最崩溃的一个坑是什么？欢迎在评论区交流吐槽！

关注我，后续我将持续更新《AI提示词工程进阶指南》、《TRAE高效编程实战》以及日常实用自动化脚本分享，带你把技术转化为实实在在的竞争力！🚀

需要我把这份笔记整理成可直接复制到CSDN的精简版（保留核心知识点与代码，去掉冗余互动内容）吗？