企业官网建设流程全解析

Python入门必学：运算符全攻略，看完这篇就够了！

作为教过无数轮Python入门课的人，我太清楚新手最容易在哪个地方栽跟头了——不是变量、不是循环、不是函数，偏偏是最不起眼的运算符。为什么？因为运算符太杂、太碎，而且很多教程把它拆得七零八落，今天讲算术、明天讲比较、后天补逻辑，学完一圈脑子里还是一团乱麻。

其实运算符这东西，本质上就是“让数据动起来”的规则。你把数字、字符串、布尔值扔进去，运算符负责告诉程序怎么处理它们：是加减乘除，还是比大小，还是判断真假。搞清楚这一层，你就掌握了Python里最底层的操作逻辑。这篇我打算一次讲透：从最基础的算术运算符、赋值运算符、比较运算符、逻辑运算符，到很多新手会忽略的成员运算符、身份运算符、位运算符，再到运算符优先级这个"隐形杀手"，全部用实际案例串起来。适合刚学完Python基础语法、准备往条件判断和循环挺进的人，也适合学了一两个月还稀里糊涂、想回头补课的人。

先声明一点：我讲的每个点都会给代码示例，示例都不长，但你最好别只看，自己在编辑器里敲一遍。运算符这种东西，眼睛会了手不会，是最高频的现状。

1. 运算符到底是个啥：先帮你在脑子里搭个框架

很多教材上来就列表格，把Python的运算符分成七八类，然后逐个给一行示例，看起来很全，实际看完就忘。这是因为缺少一个整体框架。

我的理解是这样：运算符就是函数的一种"语法糖衣"。比如2 + 3，本质上是在调用加法运算逻辑，只是Python允许你用更简洁的方式写出来。表面上看语法不同，但底层逻辑一样：接收两个操作数，按照规则处理，返回一个结果。

把Python运算符按功能分，常见的有这么几类：

如果你做过其他语言，比如C++、Java，你会发现这套体系其实很眼熟。Python在运算符这块并没有搞太多标新立异，它真正舒服的地方在于：语法更简洁，类型更灵活，而且能让你把注意力放在业务逻辑上，而不是内存细节上。

至于为什么必须有类型区分，拿算术运算符和赋值运算符举例子就明白了。+负责运算，=负责存值。但实际写代码时，你几乎不会只用一个运算符：x = x + 1这个场景太常见了，所以Python提供了x += 1这种缩写。运算符之间是有分工又有配合的，理解了整体框架再学细节，你就不会觉得这是死记硬背。

2. 算术运算符：不只是加减乘除，这些细节才是关键

2.1 加减乘除与整除取余的配合

按正常逻辑，先看加减乘除，这部分难度低，但有几个坑必须说清楚：

a = 17 b = 5 print(a + b) # 22 print(a - b) # 12 print(a * b) # 85 print(a / b) # 3.4 print(a // b) # 3 print(a % b) # 2 print(a ** b) # 1419857

第一坑：/号。在Python 3里，两个整数相除，得到的一定是浮点数，哪怕能整除，比如10 / 2结果是5.0。很多从C++或Java转过来的人在这上面翻过车：以为得到的是整数，结果类型变成float，后面做字符串拼接或类型判断时才发现不对劲。

第二坑：//是向下取整，不是向零取整。这是Python和C/C++一个明显的区别。正数时还好说，一旦遇到负数：

print(-17 // 5) # -4，而不是 -3 print(17 // -5) # -4

为什么？因为//的结果始终是"不大于商的最大整数"。-17 / 5数学上是-3.4，向下取整就是-4。这个规则刚接触时非常容易踩，尤其是写分页逻辑、分配任务数量这类场景时，算出来结果和你预期相差一位，可能导致循环多跑一次或少跑一次。

第三坑：%取余的符号。%的运算规则是a % b = a - (a // b) * b。既然//向下取整，那取余结果的符号就跟除数一致，而不是跟被除数一致：

print(-17 % 5) # 3，不是 -2 print(17 % -5) # -2，不是 2

这个点很多教程根本不提，但它在处理日期、环形队列、分页下标时非常关键。举个例子，你要把下标i映射到长度为n的循环队列里，如果i可能是负数，用Python的取余能天然得到合法的正下标i % n，这个特性其实是好用的，只是你得知道它存在。

2.2 幂运算和它的优先级陷阱

**代表幂运算，很多人不理解为什么Python要专门搞一个这个，明明可以用pow()函数。其实两者有区别：**是运算符，写起来方便；pow()是内置函数，支持三个参数时还能做模运算，比如pow(2, 10, 1000)直接算2**10 % 1000，性能上更好，适合大数求模的场景。

这里有一个特别容易错的优先级问题：

print(-2 ** 2) # -4，而不是 4 print((-2) ** 2) # 4

注意了：**的优先级高于一元负号，但方向是"从右往左"结合的。所以-2 ** 2实际是-(2 ** 2)。第一次写的时候很多人都被这个坑过，我当初还以为是Python的bug，后来查了文档才明白这是运算符优先级刻意设计的。严谨一点，工程代码里千万不要写-2 ** 2这种依赖上下文理解的表达式，加个括号一劳永逸。

2.3 字符串和列表里的算术运算符重载

Python里的很多运算符是"重载"的，意思是同一个符号不同类型有不同行为。+和*在字符串和列表上表现得非常直观：

print("Hello" + " " + "World") # Hello World print("ab" * 3) # ababab lst1 = [1, 2] lst2 = [3, 4] print(lst1 + lst2) # [1, 2, 3, 4] print(lst1 * 2) # [1, 2, 1, 2]

这里有个隐藏知识点：字符串的*本质是重复拼接，列表的+本质是拼接成新列表，都不是原地修改。所以如果你在一个循环里频繁做lst = lst + [x]，每次都会生成新列表，性能会越来越差。正确做法是用list.append()或先收集再一次性扩展。这是"运算符很方便，但不能滥用"的典型例子。

3. 赋值运算符：从=到:=，一个比一个讲究

3.1 复合赋值运算符的完整清单

赋值运算符的核心只有一个：=。但Python为了方便，提供了一堆"复合赋值运算符"。它们存在的理由很简单：代码写起来短，而且语义清晰。

x = 10 x += 5 # x = x + 5 x -= 3 # x = x - 3 x *= 2 # x = x * 2 x /= 4 # x = x / 4 x //= 2 # x = x // 2 x %= 3 # x = x % 3 x **= 2 # x = x ** 2

注意x /= 4之后x变成了浮点数，即使原来是整数。这个和算术运算符的规则一致。很多新手在写循环累计时，用sum = sum + item，其实完全可以用sum += item，效果一样但可读性更好，也少打几个字符。

3.2 链式赋值与多重赋值

链式赋值和多重赋值是两个很容易混淆但都很实用的写法：

a = b = c = 100 # 链式赋值：三个变量都指向100 x, y = 10, 20 # 多重赋值：x=10, y=20 x, y = y, x # 交换两个变量的值，Python特有的优雅写法

链式赋值要稍微留个心眼：a = b = []这种写法会把同一个列表对象同时赋给a和b，修改一个另一个也会变。如果你想要两个独立列表，应该分开写：a = []，b = []。

多重赋值的底层其实是"元组解包"，这个机制在Python里特别强大。比如函数返回多个值、遍历字典的键值对时经常用到。不过在解包时要注意左右元素个数必须一致，否则会抛出ValueError: too many values to unpack。

3.3 海象运算符的真面目

Python 3.8引入了海象运算符:=，学名"赋值表达式"。它的作用是"在表达式中赋值，并返回这个值"。最经典的场景是while循环里读取数据：

# 传统写法 data = input("请输入: ") while data != "quit": print(f"你输入了 {data}") data = input("请输入: ") # 海象运算符写法 while (data := input("请输入: ")) != "quit": print(f"你输入了 {data}")

看得出来，海象运算符把"赋值"和"判断"合并了，少写了一行重复代码。但它也有争议：太多人用它会让代码变得难懂。我的建议是：在"需要在循环或条件里临时取值并判断"这种场景下用，效果很好；但别为了炫技而刻意使用，代码可读性永远是第一位的。

4. 比较运算符与逻辑运算符：条件判断的两大基石

4.1 比较运算符的返回值与链式比较

比较运算符的作用是返回一个布尔值（True或False）。这个返回值非常重要，因为它是if、while以及逻辑判断的基础。

print(5 > 3) # True print(5 == 3) # False print(5 != 3) # True print(5 >= 5) # True

这里有个"坑中之坑"：==比较的是值是否相等，=是赋值。很多新手犯的经典错误是在if里写成if x = 3，Python会报语法错误，这一点比其他语言更早暴露问题，其实算好事。

Python里还有个非常优雅的语法：链式比较，这是其他很多语言没有的。

age = 25 if 18 <= age < 60: print("成年且未退休")

这个写法等价于18 <= age and age < 60，但更接近自然语言，而且只计算了一次age。强烈建议在范围判断时用这种写法，既清晰又不容易出错。

然后说一下浮点数比较的坑。由于计算机内部用二进制表示浮点数，0.1 + 0.2 == 0.3的结果是False，实际值是0.30000000000000004。解决方案是用math.isclose()：

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

如果你是做量化交易策略代码、数据分析这类任务，记住这个细节能帮你省掉不少莫名其妙的bug。

4.2 and、or、not：短路逻辑是精髓

逻辑运算符有三个：and、or、not。大部分教程讲的时候都是拿布尔值举例，看起来很简单。但真正的重点其实是"短路求值"。

def check(): print("check 被调用了") return True result = False and check() print(result) # False，check 根本没被调用

and左边是False时，整个表达式已经确定是False，右边不会执行。or左边是True时，整个表达式已经确定是True，右边也不会执行。利用这个特性，我们可以写出非常简洁的防御性代码：

# 只有当 user 不为 None 时才访问 user.name if user is not None and user.name == "admin": pass

如果user是None，user.name会抛出AttributeError。但因为有短路逻辑，user is not None为False，右边的user.name根本不会执行，所以不会报错。

再看一个经典用法：or做默认值。

name = input("请输入用户名: ") or "匿名用户" print(name)

如果输入为空字符串，空字符串在布尔上下文中是False，所以or会取右边的"匿名用户"。这是Python里很常见的"取默认值"写法，比写if name == "": name = "匿名用户"简洁很多。

还有一个重点：and和or的返回值并不一定是布尔值，而是运算对象本身。a and b如果a为假，返回a，否则返回b；a or b如果a为真，返回a，否则返回b。这个特性让Python的条件表达式非常灵活，但新手容易懵。理解时你可以把逻辑运算看作"选值"的过程，最后的结果直接参与后续计算。

4.3 not 与布尔上下文

not是一元运算符，作用是把结果取反。它还有个隐藏知识点：Python里任何对象都可以被判断真假（布尔上下文）。像0、空字符串""、空列表[]、空字典{}、None在布尔上下文中都是False，其余大部分是真。所以你会看到很多代码直接写：

if not lst: print("列表是空的")

这个写法比if len(lst) == 0更Pythonic，也更高效，因为不需要调用len()。

但注意一个细节：not的优先级比较低，比比较运算符还低。所以not a == b实际上是not (a == b)，而不是(not a) == b。这个和数学上的直觉一致，但写的时候建议还是加括号，免得自己都看晕。

5. 成员运算符、身份运算符：判断存在与同一性

5.1 in 的多种应用场景

成员运算符in和not in用来判断一个元素是否存在于一个序列或集合中。最常见的场景是列表、元组、字符串、字典。

fruits = ["apple", "banana", "cherry"] print("banana" in fruits) # True print("grape" not in fruits) # True text = "hello world" print("world" in text) # True d = {"name": "张三", "age": 20} print("name" in d) # True：字典默认判断键 print("张三" in d.values()) # True：判断值需要用 values()

这里字典是一个容易踩坑的点：in在字典上判断的是"键"，不是"值"。你要是想看某个值是否存在，必须用d.values()。很多人第一次用字典时在这里懵住，以为是Python的bug，其实是语义设计如此：字典查询最常用的就是查键。

in在字符串上的用法也很强大，它做的是子串匹配，不是单字符匹配。比如"lo" in "hello"返回True。如果你要判断文件扩展名、URL路径里的关键词，这个运算符非常顺手。

5.2 用 is 比较身份，不要用来比较数值

身份运算符is和is not判断的是两个变量是否指向同一个对象，也就是比较内存地址。这跟==有本质区别：==比较内容，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 指向同一个对象

is最常见的场景是判断None。因为None是单例对象，所有地方应该用x is None，而不是x == None。这个习惯在Python社区是被强烈推荐的。

需要特别强调一个坑：不要用is比较整数或字符串。虽然某些小数范围内的整数和短字符串Python会做缓存，让你碰巧发现a is b是True，但这种行为依赖具体实现，大整数或长字符串可能就变成False了。老老实实用==，别玩火。

那什么时候用is？比如自定义类对象、文件对象、单例模式里的实例判断，或者copy之后你想确认两个变量是否引用了同一个底层对象。判断单例时is是准确且高效的，因为不需要调用对象的__eq__方法，直接比指针地址。

6. 位运算符：从入门到进阶的跨越

6.1 位运算的基本操作

位运算符新手用得少，但它在状态标志、权限控制、图形处理和底层算法里是利器。这类运算符按二进制位操作整数。

a = 5 # 二进制 101 b = 3 # 二进制 011 print(a & b) # 1，按位与：101 & 011 = 001 print(a | b) # 7，按位或：101 | 011 = 111 print(a ^ b) # 6，按位异或：101 ^ 011 = 110 print(~a) # -6，按位取反：把每一位取反（含符号位） print(a << 1) # 10，左移一位：101 -> 1010 print(a >> 1) # 2，右移一位：101 -> 10，相当于整除2

底层原理其实不复杂。&只有两个位都是1时结果位才是1；|只要有一个位是1结果位就是1；^两个位不同则为1。你可以把整数拆成二进制，逐位运算后再合回十进制。

~a的结果是-6，很多人看到会懵。原因是Python整数是补码表示的：~a = -a - 1，所以~5 = -6。理解这一点后你就不会觉得它奇怪了。

左移<<每移一位相当于乘2，右移>>每移一位相当于整除2（向下取整）。这个特性在做性能优化时很常用，尤其是游戏开发、嵌入式、图像处理这些对速度敏感的场景。不过一般业务代码里没必要刻意用位运算代替乘除法，Python的*和//已经很快了，位运算的优势主要在于它直接操作标志位。

6.2 位运算的工程应用：权限管理与状态标志

光讲原理不够，给一个实际能用的场景：用位运算做权限组合。假设系统里有三种权限：读(1)、写(2)、执行(4)，二进制分别对应001、010、100。

READ = 1 WRITE = 2 EXEC = 4 # 用户的权限集合 user_perm = READ | WRITE # 二进制 011，代表可读可写 # 判断是否有写权限 if user_perm & WRITE: print("有写权限") else: print("没有写权限") # 增加执行权限 user_perm |= EXEC # 取消写权限 user_perm &= ~WRITE

这个方案的好处是：一个整数就能表达多种权限状态，存储和比较都极快；权限组合、增删权限、判断权限都只需要一次位运算。数据库里用一个整数字段保存权限位，比用逗号拼接字符串靠谱得多。

这种"用一个整数的不同二进制位代表不同开关"的思路，在状态机、配置项、功能开关里也经常出现。你不需要每次都用枚举或者一个布尔列表来管理大量的标志位，位域能极大地压缩存储和代码量。

6.3 Python位运算与C++/Java位运算的差异

如果你学过C++或Java的位运算符，转到Python时会发现几个小差异。一是Python的整数是任意精度的，所以位移操作不会因为溢出变成负数或异常，你可以放心1 << 100得到一个巨大的整数；二是Python的按位取反~是对有符号整数取反，结果带负号，不能直接类比Java里的~加上掩码后的行为。

不过这些差异对日常使用影响不大，核心逻辑一致。对于初学者，我的建议是先把&、|、^、<<、>>这五种掌握好，~了解即可，实际用到再深入。

7. 运算符优先级：程序执行的隐形规则

7.1 一张表看清优先级

前面讲了很多运算符，但实际写代码时它们会混在一起。这时候，优先级决定了表达式先算哪一部分。如果不清楚优先级，你会得到完全出乎意料的结果。

下面按从高到低列出常用运算符的优先级：

回忆一个经典示例：

result = 2 + 3 * 4 ** 2 # 先算 4 ** 2 = 16 # 再算 3 * 16 = 48 # 再算 2 + 48 = 50 print(result) # 50

另一个容易出错的场景是not和比较、逻辑运算符混用：

a = 5 b = 10 print(not a == b) # not (a == b) => True print(not a == b and b > 0) # 先比较，再not，再and

如果你不想费脑子记这个顺序，最简单的办法是：凡是自己不确定的表达式，一律加括号。括号的优先级永远最高，而且能直接表达你脑子里的运算顺序。Python官方也推荐用括号提升可读性，而不是依赖优先级让你代码变成脑筋急转弯。

7.2 实际开发中的优先级误区

我见过不少代码因为优先级问题产生隐蔽bug。举一个真实例子：判断一个数是否在某范围内，有人写：

if 10 < x < 20 and x % 2 == 0: pass

这段没问题。但有人为了偷懒写成：

if 10 < x < 20 & x % 2 == 0: pass

千万别这么写！&的优先级高于比较运算符，所以实际会先算20 & x，然后x % 2，再比较，结果完全错乱。这也是为什么我反复强调：拿不准就加括号。这会让你像写数学题一样，把运算意图明明白白摆出来。

还有赋值运算符在表达式里的问题：x = y = 5合法，但x = 5 + y = 3不合法。因为赋值运算符的优先级极低，并且不能嵌入表达式中。想要在表达式里赋值，只能用海象运算符:=。

7.3 如何训练优先级直觉

优先级不用死记硬背，多写几个混合表达式，错了自然就记住了。但更高效的办法是养成两个习惯：

第一，复杂表达式先拆开。比如result = a + b * c - d / e，你可以在心里拆成result = a + (b * c) - (d / e)，或者直接在代码里写成这样。

第二，凡是包含了三种及以上不同运算符的表达式，都用括号把子表达式包起来。代码不是越短越好，而是"越不容易错"越好。

我个人的经验是：等Python写熟了，优先级表你会自然记住大部分，因为每天都在用。但作为入门阶段，宁可多写括号，也别去挑战复杂表达式。

8. 各类型运算符实战组合：从零写一个完整的判断逻辑

前面把每一类运算符拆开讲了，但实际项目里它们永远是组合使用的。这一节我带你走一遍一个真实小需求的完整实现，把算术、比较、逻辑、成员甚至赋值运算符全部串起来。

假设要写一个简单的"登录校验 + 权限判断"示例：

# 用户输入用户名和年龄 username = input("请输入用户名: ") age = int(input("请输入年龄: ")) # 内置白名单用户 admin_users = ["admin", "root", "boss"] vip_level = 3 # 判断逻辑 if username in admin_users and age >= 18: print("欢迎管理员，权限等级：", vip_level | 0x10) elif username and age >= 18 and age < 60: print("普通成年用户") elif not username: print("用户名不能为空") else: print("不符合访问条件") # 利用位运算给权限加一个额外标志位 perm = 4 if username in admin_users else 1 perm |= 2 print(f"用户权限位: {perm}")

这个例子可能不严谨，但意思很明白：in做成员判断，and组合多个条件，or处理空值默认，位运算组合权限。你实际写代码时，运算符基本上都是这么嵌套使用的。

我自己带新手时经常让大家做一个练习：写一个程序，判断某一年是否为闰年。条件是"能被4整除但不能被100整除，或者能被400整除"。用运算符表达：

year = int(input("请输入年份: ")) if (year % 4 == 0 and year % 100 != 0) or year % 400 == 0: print(f"{year} 是闰年") else: print(f"{year} 不是闰年")

这个练习妙在能把算术运算符（%）、比较运算符（==、!=）、逻辑运算符（and、or）全用上，而且结果客观可验证。你也可以试试自己改写成不用括号的版本，看看优先级会产生什么变化，然后对照想一想为什么结果不同。

9. 高频踩坑与排查经验：我替你们交过的学费

9.1 浮点数比较永远不要用 ==

这是Python入门头号坑。二进制浮点数的表示方式决定了我们无法精确表达所有小数，0.1 + 0.2不等于0.3，但很多人第一反应是"Python的bug"。其实不是，这是IEEE 754浮点标准的常见现象。解决方案就是用math.isclose()，或者用Decimal处理金额等对精度要求极高的场景。

9.2 判断 None 用 is，不要用 ==

前面提过，判断None要用x is None。==在某些自定义类里可能被重载，导致行为不确定。is永远比较对象身份，None又是单例，所以is None是最稳妥的判断方式。

9.3 小心+=在可变对象上的行为

你可能没想到，+=在列表上和一个整数上的语义有微妙差别。对不可变对象如整数、字符串，x += y会创建新对象并重新绑定；对可变对象如列表，lst += [item]等价于lst.extend([item])，是原地修改。

lst1 = [1] lst2 = lst1 lst1 += [2] print(lst2) # [1, 2]，lst2 也变了 lst1 = [1] lst2 = lst1 lst1 = lst1 + [2] print(lst2) # [1]，lst1 重新绑定了新列表，lst2 不受影响

这个坑在函数传参、拷贝对象时尤其容易出问题。如果不想让原列表被修改，要用切片或者copy()先复制一份。

9.4 注意and/or优先级与返回值的配合

逻辑运算符优先级从高到低是not>and>or。所以下面这个表达式：

flag = True or False and False print(flag) # True，因为先算 and，再算 or

如果你以为or比and优先级高，就会得出错误结果(True or False) and False=False。记的时候有个口诀：not最优先，其次and，最后or，和大多数语言的惯例一致。

另外，and/or返回值是对象本身，这个特性可以用来做默认值或链式取值，但新手很容易理解为"返回布尔值"。当你要必须拿到布尔值时，可以外面套一层bool()。

9.5 检查当前代码是不是被优先级坑了

如果你怀疑表达式结果不对，最快的方法是分步执行或加括号。你可以在IDE里把表达式拆分，打印中间结果，而不是一口气盯着长表达式看。很多次我以为逻辑有问题，最后发现都是优先级惹的祸。

10. 玩转运算符的进阶技巧与学习路线

运算符看似基础，但想用好也是有进阶路线的。

第一个技巧：善用in替代复杂的多个or判断。比如要判断字符是否属于"aeiou"（元音字母），用if ch in "aeiou"远比if ch == "a" or ch == "e" or ...清晰。判断多个值是否相等时同理：if value in (1, 2, 3)。

第二个技巧：用and/or做条件赋值时，注意可读性。比如x = a or b or c可以取第一个非空值，但这段代码如果别人看不明白，建议加注释或者改用更显式的写法：x = a if a else (b if b else c)。

第三个技巧：想自己写支持运算符的类，需要实现魔法方法。比如__add__对应+，__eq__对应==。写一个分数类或向量类时，运算符重载能极大提升代码表达力。举个例子：

class Vec: def __init__(self, x, y): self.x = x self.y = y def __add__(self, other): return Vec(self.x + other.x, self.y + other.y) def __repr__(self): return f"Vec({self.x}, {self.y})" v1 = Vec(1, 2) v2 = Vec(3, 4) print(v1 + v2) # Vec(4, 6)

当你开始写自己的类和支持运算符重载后，才真正把运算符从"语法规则"变成"设计工具"。很多第三方库，比如NumPy、Pandas，都是靠运算符重载让你可以直接对数组做+、*、比较运算，而不用一个个元素循环。

学习路线上，我建议按这个顺序来：

1. 先掌握算术、赋值、比较、逻辑这四类，这是写任何逻辑都离不开的。
2. 再学成员运算符和身份运算符，它们会让你的代码更Pythonic。
3. 最后学位运算符和优先级细节，等你开始涉及状态标志、底层算法时再去深挖也不迟。

每学一类，一定要写至少三个不同场景的代码示例，并把它们组合起来用。别只看文章或视频，运算符这东西，坐在电脑前敲一遍，胜过看十遍。

写在最后的一点经验

我在实际教课和写代码过程中发现，运算符特别容易陷入"一看就会，一写就废"的尴尬。原因在于太基础、太琐碎，很多人不屑于专门练习，结果到后面写条件判断、循环、列表推导式时，频繁因为优先级、短路、类型问题卡壳。

如果你现在刚开始学Python，建议抽出一天时间，把我上面这些示例全部手敲一遍，再故意改几个条件，看看输出有什么变化。把错误当成学习工具，比直接抄正确代码收获大得多。

等到你用熟了这些运算符，写起来就会很顺。Python的魅力之一就是能用最少的符号表达清晰的操作逻辑，运算符正是这套表达系统最底层的零件。把地基打牢，后续学函数、类、装饰器、推导式，都会顺畅很多。