简介：这是一份面向Python初学者及有其他语言基础的编程学习者的系统性语法入门资料，聚焦核心语法概念与实践应用，帮助读者快速建立Python编程认知框架并夯实基础。资源为单文件PDF，共68页、1.42MB，内容覆盖变量与数据类型（int/float/str/list/dict等）、标识符命名规范（含单双下划线特殊含义）、严格缩进机制、多行语句写法、输入输出控制（如print(end='')）、流程控制（if/for/while/try-except）、函数定义与模块导入等关键模块，每部分均配原理说明与可运行示例代码。已有2053人学习下载，适合自学入门、课前预习、语法速查或转语言者快速对标Python编程范式。结构清晰、术语准确、示例精炼，68页篇幅兼顾完整性与可读性，是高效启动Python学习路径的轻量级权威导引。
1. Python基础语法到底是什么：一张68页的“编程普通话速成地图”
你有没有试过学开车，教练先不让你碰方向盘，而是花两小时讲清“离合器怎么联动”“档位怎么咬合”“雨刮器开关在哪”——不是为了让你立刻上高速，而是怕你连车门都打不开、油门当刹车踩。Python基础语法，就是编程世界的“车门、钥匙、后视镜和油门位置”。它不是某个高深算法，也不是炫酷的AI模型，而是一套让计算机听懂你话的底层表达规则：怎么起名字（标识符）、怎么分行写（缩进）、怎么存数字和文字（变量与类型）、怎么让程序做判断和重复（if/for）、怎么把一堆操作打包复用（函数）。这份《python基础语法合集68页.pdf》，就像一本68页厚的“Python普通话速查手册”——没有方言，不绕弯子，从第一行print("Hello")开始，手把手带你把“人话”翻译成机器能执行的指令。它不教你怎么造火箭，但确保你拧对每一颗螺丝；不承诺三天写出微信，但保证你第二天就能看懂别人写的脚本、改错、加功能。对零基础的人，它是防踩坑的“安全带”；对转语言的老手，它是快速切换思维的“翻译器”。搞懂它，不是为了背诵，而是为了——当你看到一段Python代码时，不再觉得是天书，而是能一眼认出哪是开关、哪是油门、哪是刹车踏板。
2. 为什么Python语法要这样设计：从“括号党”到“缩进党”的底层逻辑
2.1 缩进不是格式要求，而是语法本身：为什么Python不用大括号？
绝大多数编程语言（比如C、Java、JavaScript）用花括号{}来圈出一段代码块：“这里开始是if的真分支，这里结束”。Python偏不这么干——它用空格或Tab键的缩进来定义“谁属于谁”。这不是IDE的美化设置，而是硬性语法规则。看这个对比：
# Python：缩进即逻辑，错一格就报错 if x > 0: print("正数") y = x * 2 if y > 10: print("y很大") else: print("非正数")// JavaScript：花括号{}才是逻辑边界，缩进只是给人看的 if (x > 0) { console.log("正数"); var y = x * 2; if (y > 10) { console.log("y很大"); } } else { console.log("非正数"); }提示：Python中，同一层级的代码必须有完全相同的缩进量（推荐4个空格），混用Tab和空格会直接报
IndentationError。这不是风格问题，是语法错误，就像中文里把“的”写成“地”不会报错，但把“我”写成“找”就完全不是一句话了。
为什么这么设计？核心就一个字：可读性。Python之父Guido van Rossum曾说：“代码被阅读的次数远多于被编写的次数。” 大括号可以随意换行、缩进混乱，导致逻辑嵌套像迷宫；而强制缩进，让代码结构一目了然——缩进越深，嵌套越内层；缩进归零，说明回到顶层。这就像建筑蓝图：墙的位置（缩进）决定了房间（代码块）的归属，而不是靠墙上贴的标签（花括号）。对初学者，它逼你养成整洁习惯；对团队协作，它消灭了“这段代码到底属不属于这个if”的争论。代价是入门时多一次IndentationError的“血泪经验”，但换来的是长期维护时少十次“这行代码到底在哪个循环里”的抓狂。
2.2 标识符命名里的“暗号系统”：下划线不是装饰，是权限说明书
在Python里，给变量、函数起名不只是“叫什么顺口”，更像在贴一张权限标签。普通名字如user_name、get_data是公开的；但一旦加上下划线，规则立刻变：
name：完全公开，谁都能用、能改。_name（单下划线开头）：这是“内部使用，请勿直取”的委婉提醒。它不阻止你访问，但像同事悄悄告诉你：“这东西没对外承诺，以后可能改，别依赖它。” 比如模块里有个_helper_func()，你调用它没问题，但作者不保证下个版本还存在。__name（双下划线开头）：这是“私有成员，别碰！”的硬性声明。Python会自动把它“改名”（name mangling），变成_ClassName__name，让你直接访问变得麻烦——不是技术上做不到，而是明确告诉你：“这是类的内部实现细节，外部不该知道。”__name__（双下划线开头+结尾）：这是Python的“系统保留区”，专供特殊方法（magic methods）使用，比如__init__()是构造函数，__str__()定义打印时的样子。你绝不能自己随便造一个__my_func__，否则可能覆盖Python内置行为，引发玄学bug。
打个比方：Python的命名规则就像一栋公司大楼的门禁卡系统：
- 没标记的门（
name）：敞开，所有人自由进出； - 贴着“内部办公区”纸条的门（
_name）：没锁，但你进去前得想想值不值得； - 装着指纹锁的门（
__name）：没权限刷不开，强行撬锁会触发警报； - 标着“机房/配电室”的门（
__name__）：连门牌都是统一编号，擅自改动整栋楼可能停电。
这份68页PDF里，专门用表格列出了所有双下划线方法及其用途，不是让你死记，而是帮你理解：为什么len(my_list)能工作？因为列表类实现了__len__()；为什么print(obj)能输出自定义内容？因为obj的类写了__str__()。语法背后的逻辑，从来不是凭空而来。
2.3 变量赋值的本质：Python里没有“变量”，只有“标签”
传统编程教学常说“变量是内存中的盒子，赋值就是往盒子里放东西”。Python彻底颠覆了这个比喻。在Python中，变量不是盒子，而是贴在对象身上的便利贴（label）。看这个经典例子：
a = [1, 2, 3] # 创建列表[1,2,3]，a贴在这张纸上 b = a # 不是复制列表，而是再贴一张便利贴b在同一个列表上 b.append(4) # 通过b这张便利贴，往列表里加4 print(a) # 输出 [1, 2, 3, 4] —— a也变了！为什么？因为a和b都指向同一个列表对象，修改对象内容，所有指向它的标签都会看到变化。这解释了为什么字符串（不可变）和列表（可变）行为不同：
s1 = "hello" s2 = s1 s2 = s2 + " world" # 创建新字符串，s2贴到新纸上 print(s1) # 还是 "hello" —— s1仍贴在原纸上注意：这种“标签”机制，是理解Python内存模型、避免浅拷贝陷阱（比如
list.copy()只复制一层）的关键。68页PDF里用图示清晰画出了对象、引用、内存地址三者关系，比纯文字描述直观十倍——它不教你背概念，而是让你“看见”数据在内存里怎么流动。
3. 常见误区与易混概念：新手最常翻车的5个“语法幻觉”
3.1 误区一：==和is都是“等于”，可以互换？
为什么混：初学者看到if a == b:和if a is b:都返回True，就以为它们是一回事，尤其对小整数、短字符串时。
怎么区分：
==比较的是值是否相等（内容一样吗？）；is比较的是是否为同一个对象（内存地址一样吗？）。
a = [1, 2, 3] b = [1, 2, 3] print(a == b) # True —— 内容相同 print(a is b) # False —— 两个独立列表，地址不同 c = a print(a is c) # True —— c和a贴在同一张纸上 # 玄学时刻：小整数和短字符串有缓存 x = 100 y = 100 print(x is y) # True —— Python缓存了小整数，x,y指向同一对象 z = 100000 w = 100000 print(z is w) # False —— 大整数不缓存，各自创建对象正确用法：比较值用==；检查是否为None、单例对象（如True/False）时用is（if obj is None:比if obj == None:更快更安全）。
3.2 误区二：列表切片list[1:3]是“取第1到第3个元素”？
为什么混：受自然语言“1到3”包含3的影响，误以为切片是闭区间。
怎么区分：Python切片是左闭右开区间：start索引包含，end索引不包含。list[1:3]取的是索引1和索引2的元素，共2个。
nums = [0, 1, 2, 3, 4] print(nums[1:3]) # [1, 2] —— 索引1的1，索引2的2，索引3的3不取 print(nums[:2]) # [0, 1] —— 从开头到索引2（不包含） print(nums[2:]) # [2, 3, 4] —— 从索引2到结尾 print(nums[:]) # [0, 1, 2, 3, 4] —— 全部复制（浅拷贝）关键点：切片不会报错。nums[10:20]对长度5的列表返回空列表[]，而非IndexError。这是安全设计，也是新手调试时容易忽略的“静默失败”。
3.3 误区三：for item in list:循环中删除元素，能遍历全部？
为什么混：以为循环像数学集合遍历，删一个不影响后续。
怎么区分：Python的for循环是按索引顺序逐个取值。删除元素会改变后续元素的索引，导致跳过下一个。
fruits = ['apple', 'banana', 'cherry', 'date'] for f in fruits: if f == 'banana': fruits.remove(f) # 删除'banana'，'cherry'前移占位 print(fruits) # ['apple', 'cherry', 'date'] —— 'cherry'被跳过了！正确做法：
- 反向遍历：
for i in range(len(fruits)-1, -1, -1): - 收集待删项，循环后再删：
to_remove = [f for f in fruits if ...]; [fruits.remove(f) for f in to_remove] - 用列表推导式重建：
fruits = [f for f in fruits if f != 'banana']
68页PDF在“列表操作”章节用流程图演示了索引移动过程，一目了然。
3.4 误区四：import module和from module import *效果一样，只是写法不同？
为什么混：都实现了“用模块里的东西”，以为只是导入方式差异。
怎么区分：
import math：引入整个模块，使用需加前缀math.sqrt(4)from math import sqrt：只引入sqrt函数，直接用sqrt(4)from math import *：引入模块所有公开名称（不以下划线开头），污染当前命名空间！
# 危险示范 from math import * from numpy import * # numpy也有sin, cos, array... 会覆盖math的同名函数！ result = sin(0.5) # 到底调用math.sin还是numpy.sin？取决于导入顺序！后果：命名冲突、调试困难、代码可读性归零。大型项目严禁import *。PDF里明确标注：“此写法仅限交互式探索，禁止写入正式代码”。
3.5 误区五：字符串格式化%、.format()、f-string 只是“新旧写法”，选一个就行？
为什么混：三者都能实现"Name: %s, Age: %d" % ("Alice", 30)、"Name: {}, Age: {}".format("Alice", 30)、f"Name: {name}, Age: {age}"，以为无本质区别。
怎么区分：
| 特性 | %格式化 | .format() | f-string (Python 3.6+) |
|---|---|---|---|
| 性能 | 最慢 | 中等 | 最快（编译期解析） |
| 可读性 | 差（%s %d %f难对应） | 好（位置/关键字） | 最好（变量名即内容） |
| 功能 | 基础 | 强大（嵌套、格式控制） | 最强（支持表达式f"{x*2}"） |
| 兼容性 | 所有Python | 2.7+/3.1+ | 仅3.6+ |
name, age = "Bob", 25 # 推荐：f-string 清晰、快、支持计算 msg = f"User {name.upper()} is {age + 1} next year" # 淘汰：%格式化已标记为legacy，新项目避免 # msg = "User %s is %d next year" % (name.upper(), age + 1)PDF在“字符串”章节用对比表格总结了三者适用场景，并强调：“f-string是当前标准，除非维护老代码，否则默认用它”。
4. 数据类型实战：Numbers、Strings、Lists、Tuples 的“性格档案”
4.1 Numbers（数字）：不是冷冰冰的数值，而是有“脾气”的对象
Python的数字类型不是简单的“数”，而是具备行为和属性的对象。理解它们的“可变性”和“类型转换规则”，是避免计算错误的第一道防线。
不可变性：所有数字类型（
int,float,complex）都是不可变对象。这意味着，任何数学运算（+,-,*）都不会修改原变量，而是创建新对象：a = 5 b = a a = a + 1 # 创建新int对象6，a指向它 print(a, b) # 6 5 —— b仍指向原对象5类型隐式转换：混合运算时，Python自动升维：
result = 10 + 3.14 # int + float → float print(type(result)) # <class 'float'> result = 2 + 1j # int + complex → complexintvsfloat的精度陷阱：浮点数无法精确表示某些十进制小数（如0.1），这是二进制存储的固有缺陷：print(0.1 + 0.2 == 0.3) # False！实际是0.30000000000000004 # 正确比较浮点数用 math.isclose() import math print(math.isclose(0.1 + 0.2, 0.3)) # Truecomplex复数的实用场景：信号处理、电路仿真、图形旋转。z.real,z.imag,abs(z)（模长）是基本操作：z = 3 + 4j print(z.real, z.imag, abs(z)) # 3.0 4.0 5.0 （3²+4²=5²）
68页PDF的“数学函数”章节，不仅列出math.sqrt(),math.pow()，更强调：****运算符（如2**3）比pow(2,3)更快，且支持负数底数；而math.sqrt(-1)会报错，必须用cmath.sqrt(-1)。这些细节，正是项目里“为什么这里报错”的答案来源。
4.2 Strings（字符串）：文本不是字符数组，而是“不可变序列”
Python字符串是不可变的Unicode序列。这个定义包含三层意思：Unicode（支持中文、emoji）、序列（可索引切片）、不可变（操作必生成新串）。
索引与切片的“负数魔法”：负索引从末尾计数，
-1是最后一个字符：text = "Python" print(text[-1]) # 'n' print(text[:-1]) # 'Pytho' —— 除最后一个外全部 print(text[::-1]) # 'nohtyP' —— 步长-1，反转！转义字符的“双重身份”：
\n在字符串中是换行符，但在原始字符串（r"\n"）中就是字面的反斜杠+n：path = "C:\new\folder" # \n和\t被解释为换行和制表符！路径错误 path = r"C:\new\folder" # 原始字符串，\n就是两个字符字符串格式化的进化史：PDF用一页篇幅对比三种方式，结论直白：
%：遗留代码，仅用于兼容；.format()：需要复杂格式控制时（如对齐、填充）；f-string：日常90%场景的绝对首选，因为它把变量名直接嵌入，所见即所得：
name = "Alice" score = 95.5 # 清晰：变量名即内容，格式控制直观 report = f"{name:<10} | {score:>6.1f} | {'PASS' if score>=60 else 'FAIL'}" # 输出：Alice | 95.5 | PASS
编码解码不是“高级技巧”，而是文件读写的必经关卡：
str.encode('utf-8')将字符串转为字节流（bytes），bytes.decode('utf-8')反之。读写文件时，open(..., encoding='utf-8')自动处理，但网络请求、二进制数据必须手动：# 从网络获取的bytes数据，需decode才能当字符串用 raw_data = b'\xe4\xbd\xa0\xe5\xa5\xbd' # UTF-8编码的"你好" text = raw_data.decode('utf-8') # "你好"
PDF在“字符串”章节末尾，用一个真实案例说明：为什么爬虫抓到的中文是乱码？—— 因为没指定response.content.decode('gbk')或response.text（requests自动解码）。语法知识，直接关联到debug能力。
4.3 Lists（列表）与 Tuples（元组）：一对“孪生兄弟”的根本分歧
列表（[]）和元组（()）长得像，但性格截然相反：列表是“活文档”，元组是“合同副本”。
| 特性 | List（列表） | Tuple（元组） |
|---|---|---|
| 可变性 | ✅ 可增删改（append(),pop(),sort()） | ❌不可变（创建后内容、长度固定） |
| 用途 | 存储动态数据（用户输入、计算结果、配置项） | 存储静态数据（坐标(x,y), RGB色值(255,0,0), 函数返回多值） |
| 性能 | 略慢（需预留扩容空间） | 更快（内存紧凑，创建开销小） |
| 作为字典键 | ❌ 不可哈希（因可变） | ✅可哈希（因不可变），能当字典键或集合元素 |
元组的“无括号”隐身术：逗号
,是元组的真正标识符，括号只是可读性辅助：a = 1, 2, 3 # 等价于 a = (1, 2, 3) b = (1, 2, 3) # 显式写法 c = 1, # 单元素元组！必须加逗号，否则是int d = (1,) # 等价写法函数返回多值的真相：
return a, b实际返回一个元组，解包是语法糖：def get_name_age(): return "Tom", 25 # 下面两行等价 name, age = get_name_age() # 自动解包元组 (name, age) = get_name_age() # 显式解包 # 本质：get_name_age() 返回 (str, int) 元组列表推导式：Python的“语法糖核武器”：一行代码替代循环+条件+追加，是Python简洁性的代表：
# 传统写法 squares = [] for x in range(10): if x % 2 == 0: squares.append(x**2) # 列表推导式：清晰表达“我要什么” squares = [x**2 for x in range(10) if x % 2 == 0] # [0, 4, 16, 36, 64]
PDF在“列表与元组”章节，用一个对比表格详细列出所有方法（list.append()vstuple.count()），并特别标注：“元组没有append()方法，尝试调用会报AttributeError”。这不是废话，而是新手debug时最常搜的报错关键词。
5. 流程控制与函数：让代码从“直肠子”变成“有脑子的管家”
5.1 if/elif/else：不是“选择题”，而是“决策树”的根节点
Python的条件语句看似简单，但嵌套不当极易导致逻辑混乱。关键在于理解：elif是else if的缩写，整个if-elif-else是一个原子块，只会执行其中一个分支。
score = 85 if score >= 90: grade = "A" elif score >= 80: # 注意：这里隐含了 score < 90（因为上面没进） grade = "B" # 所以无需写 elif score >= 80 and score < 90 elif score >= 70: grade = "C" else: grade = "F"常见翻车点：用多个独立
if代替elif，导致多个条件同时满足：# 错误：分数85会同时进第一个和第二个if if score >= 80: grade = "B" if score >= 90: # 这个也会检查！ grade = "A" # 结果grade="A"，但逻辑本意是互斥 # 正确：用elif保证互斥 if score >= 90: grade = "A" elif score >= 80: # 只有前面不满足才检查 grade = "B"三元运算符：单行条件赋值，提升可读性：
# 传统 if age >= 18: status = "adult" else: status = "minor" # 三元运算符：value_if_true if condition else value_if_false status = "adult" if age >= 18 else "minor"
PDF在“流程控制”章节，用流程图展示了if-elif-else的执行路径，并强调：“else不是必须的，但加上它能捕获所有未预见情况，是防御性编程的第一步”。
5.2 for/while 循环：for是“遍历”，while是“守株待兔”
for循环的本质：它遍历可迭代对象（list, tuple, string, dict, range等），不是“重复N次”，而是“对每个元素做某事”：# 遍历列表 for item in [1, 2, 3]: print(item) # 遍历字符串（每个字符） for char in "abc": print(char) # 遍历字典（默认是key） d = {"a":1, "b":2} for key in d: print(key, d[key])while循环的核心：基于条件持续执行，直到条件变为False。它不关心“有多少次”，只关心“是否还该继续”：# 用户输入验证：不停问，直到输入有效数字 user_input = "" while not user_input.isdigit(): user_input = input("请输入一个数字：") print(f"你输入了：{user_input}")break和continue的精准控制：break：立即跳出整个循环，执行循环后的代码；continue：跳过本次循环剩余部分，直接进入下一次迭代。
for i in range(1, 11): if i == 5: break # 遇到5就停止，输出1,2,3,4 print(i) for i in range(1, 11): if i % 2 == 0: continue # 跳过偶数，只输出奇数1,3,5,7,9 print(i)
PDF在“循环”章节，用一个“猜数字游戏”的完整代码示例，融合了while、if、break、input()，让语法点落地到具体任务，而不是孤立概念。
5.3 函数：不是“代码块”，而是“可复用的工具箱”
Python函数用def定义，但它的强大在于参数传递、作用域和返回值的设计哲学。
参数传递：Python是“对象引用传递”。对于可变对象（list, dict），函数内修改会影响外部；对于不可变对象（int, str），重新赋值不影响外部：
def modify_list(lst): lst.append(4) # 修改对象内容 → 外部可见 lst = [99] # 重新赋值 → 只改变lst局部引用，外部不变 my_list = [1, 2, 3] modify_list(my_list) print(my_list) # [1, 2, 3, 4] —— append生效，赋值无效默认参数的“陷阱”：可变对象（如list）不能作默认参数，因为默认值在函数定义时创建一次，多次调用会共享：
# 危险！ def bad_append(item, lst=[]): # []在定义时创建，每次调用用同一个list lst.append(item) return lst print(bad_append(1)) # [1] print(bad_append(2)) # [1, 2] —— 糟糕！累积了上次的1 # 正确：用None作哨兵 def good_append(item, lst=None): if lst is None: lst = [] lst.append(item) return lst*args和**kwargs：函数的“万能接口”，让函数能接收任意数量参数：def flexible_func(*args, **kwargs): print("位置参数:", args) # 元组 print("关键字参数:", kwargs) # 字典 flexible_func(1, 2, 3, name="Alice", age=25) # 输出： # 位置参数: (1, 2, 3) # 关键字参数: {'name': 'Alice', 'age': 25}
PDF在“函数”章节，用一个“日志记录函数”的例子，演示如何用*args接收任意消息，用**kwargs接收level="INFO"、module="main"等配置，让函数既灵活又专业。
6. 什么时候该打开这份68页PDF：一份来自真实项目的“后悔药”清单
去年，某高校实验室开发一个学生考勤分析系统。核心逻辑是：读取Excel签到表（含姓名、时间、教室），统计每人每周出勤率。代码写完测试通过，上线第一天就崩了——所有出勤率显示为0.0。团队排查两小时，从数据库查到Excel读取，再到算法公式，一无所获。最后，一位实习生盯着pandas.read_excel()返回的DataFrame，突然想起PDF里“字符串与数字”的警告栏：“从Excel读取的数字，有时会被pandas识别为字符串（如'95'），参与计算前务必用pd.to_numeric()转换”。果然，df['score']列类型是object，里面混着字符串和数字。一行df['score'] = pd.to_numeric(df['score'], errors='coerce')，问题解决。那晚，整个团队把那份68页PDF从头翻到尾，标满了荧光笔。
这件事让我彻底明白：基础语法不是“学完就扔”的教材，而是你代码出问题时，第一本能翻找的“故障诊断手册”。它不教你造火箭，但确保你拧紧每一颗螺丝；不承诺写出惊艳算法，但防止你在最基础的环节翻车。那么，这份资料到底该在什么时候打开？我的血泪经验是——当遇到以下任一场景，请立刻放下手头代码，打开它：
6.1 场景一：你的代码报错信息里，出现了这些词
| 报错关键词 | PDF对应章节 | 为什么翻它 |
|---|---|---|
IndentationError | 第4章：Python的缩进与多行语句 | 90%的缩进错误源于Tab/空格混用或缩进量不一致，PDF用图示标出“正确缩进”的视觉标准 |
NameError: name 'xxx' is not defined | 第2章：Python标识符 / 第5章：作用域 | 可能是拼写错误、变量未声明、或作用域混淆（如函数内用全局变量没加global），PDF的标识符命名规则表能快速定位 |
TypeError: 'str' object is not callable | 第2章：字符串 / 第5章：函数 | 经典“变量名覆盖函数名”错误（如str = "hello"后，再调用str(123)就报错），PDF在“标识符”章节用加粗警示 |
UnboundLocalError: local variable 'x' referenced before assignment | 第5章：函数作用域 | 变量在函数内既有读取又有赋值，Python默认其为局部变量，但读取发生在赋值前。PDF用流程图解释“变量声明提升”机制 |
KeyError: 'xxx' | 第4章：字典（虽未在摘要明写，但PDF全文涵盖） | 访问字典不存在的键，PDF提供dict.get(key, default)和in操作符的对比用法 |
提示：不要试图靠记忆解决这些错误。把PDF当作“词典”，遇到报错就查——就像查字典不认识的字，而不是背下所有字。
6.2 场景二：你需要快速确认一个语法细节，但不确定
这时候，PDF的价值是“秒级响应”。比如：
- 想确认
with open()的正确写法：PDF第X页有标准模板，包括encoding参数默认值（locale.getpreferredencoding(False)，通常是UTF-8）、errors参数选项（'ignore','replace'）。 - 纠结
list.sort()和sorted()的区别：PDF用对比表格明确：前者就地排序，返回None；后者返回新列表，原列表不变。附带警告：“对sorted()结果调用.sort()是无效操作”。 - 拿不准
lambda函数能写多复杂：PDF指出：“lambda只允许单个表达式，不能有语句（如if、for、return）。复杂逻辑请用def函数”，并给出重构示例。
这些细节，Stack Overflow也能回答，但PDF的优势在于：上下文集中、无广告干扰、术语统一、示例可直接复制。它不是百科全书，而是为你量身定制的“语法急救包”。
6.3 场景三：你正在教别人，或准备技术面试
我曾辅导一位转行的同学准备Python面试。他自信满满，直到被问：“a = [1,2,3]; b = a; b += [4]和b = b + [4]，a的值分别是什么？”他愣住了。这个问题直指Python可变/不可变、+=（
本文还有配套的精品资源，点击获取
