企业官网建设流程全解析

经常有学员跑来问我：“老师，Python入门语法我都看完了，怎么一写作业就卡壳？”我问他们卡在哪，十有八九都出在操作符上。不是不知道+是加、-是减，而是一道题里混着算术、比较、逻辑运算时，整个人就懵了。所以我干脆整理了一套以操作符为主线的测验题，一边做题一边查漏补缺，比干看书管用得多。

这份测验面向刚学完Python基础语法、正准备往流程控制或函数方向进阶的初学者，也适合用来做教学后的随堂检测。我的目标很直接：把Python里最常用的几类操作符全部过一遍，用题目逼着你暴露问题，再逐题拆解背后的原理。如果你能不看答案把这套题做对八成以上，说明操作符这一关你真的过了；如果做错不少，那正好，这篇文章就是给你准备的。

1. 为什么专门把“操作符”拎出来做测验

很多人觉得操作符不就是加减乘除吗，有什么好测的？这种想法害人不浅。我见过太多人在变量赋值、函数调用上都挺顺，一写条件判断就翻车，归根结底是对操作符的理解停留在“认识符号”的层面，而不是“理解运算规则”的层面。

1.1 操作符是Python里最容易被“想当然”的部分

Python的操作符看着简单，实际规则相当多。比如/和//的区别，=和==的区别，and和&的区别，这些如果没搞清楚，写代码就是凭感觉。更麻烦的是，Python有一些看似违背直觉的规则，比如链式比较1 < 2 < 3居然可以直接这么写，比如not的优先级其实比and和or都低，比如2 ** 3 ** 2算出来是 512 而不是 64。

这些规则不是靠背能记住的，必须通过做题、出错、纠正才能形成条件反射。我设计这套测验的初衷，就是让学习者在一个安全的环境里先把错犯个遍，免得日后在真实项目里踩雷。

1.2 一份测验题应该怎么设计才对得起读者

既然叫“测验”，就不能随便堆几道题了事。我设计这套题目时给自己定了三个标准：

• 覆盖全面：算术、比较、逻辑、赋值、成员、身份、位运算这几大类都得有，不能只盯着算术运算符。
• 有梯度：从直接考察运算结果的简单题，到混合运算的进阶题，再到需要理解底层机制的拔高题，逐步加码。
• 每道题都有“坑”：所谓“坑”不是故意刁难人，而是真实编程中确实容易出错的地方。比如把==写成=、忽略了短路求值、误以为is和==等价——这些都是我实际看到学员犯过的错。

这套题的适用场景不限于自学自测。你要是老师，可以把它当作课堂小测；你要是团队里带新人的，也可以拿它当面试前的热身题。做完一遍，基本就能看出一个人对Python操作符的掌握程度了。

2. 先过一遍核心规则：Python操作符的分类与优先级

如果你对操作符还只是混个脸熟，建议先把这一章过一遍再去做题。这里我不会把官方文档搬过来，而是挑最实用、最容易出问题的点讲清楚。这相当于先给你一张地图，再做测验就不会两眼一抹黑。

2.1 Python里到底有哪些操作符，分别管什么

为了方便对照，我把Python里最常用的操作符按类别整理成了表格。这个表格的特点是按“干的事”来分，而不是按符号长相来分，这样更贴近实际使用场景。

这里我想多说一句：最容易被人忽略的是海象操作符:=。它是Python 3.8才引入的，很多人学过但没实际用过。它的作用是在表达式内部给变量赋值，比如：

# 普通写法 data = input("请输入：") if len(data) > 3: print(f"长度是{len(data)}") # 海象写法 if (data := input("请输入：")) and len(data) > 3: print(f"长度是{len(data)}")

你的代码里不一定非得用它，但看别人的代码时至少要认识它。

2.2 优先级和结合性：决定表达式怎么算的关键

操作符优先级是个老生常谈的话题，但每次考倒一片人。Python的优先级从高到低大致是：

1. 幂运算**
2. 正负号+x-x（一元运算符）
3. 算术运算*///%
4. 算术运算+-
5. 比较运算==!=<><=>=
6. not逻辑非
7. and逻辑与
8. or逻辑或
9. 赋值运算=+=等

这里有两个特别容易搞错的点。

第一，**的结合性是右结合。也就是说2 ** 3 ** 2的运算顺序是从右往左的，先算3 ** 2 = 9，再算2 ** 9 = 512。很多人想当然地以为从左往右算，结果得到 64。这就是典型的“认识符号但不认识规则”。

第二，not的优先级比and和or低。这意味着not a == b实际上先算a == b，再对结果取反，等价于not (a == b)。而not a and b等价于(not a) and b。有些初学者看到not就以为它优先管住后面所有东西，这是一个隐蔽的坑。

遇到复杂的表达式，我的建议很简单：拿不准就加括号。显式括号不会降低性能，却能极大提升可读性，也能避免自己和别人理解偏差。测验里我会特意出几道不写括号的题，就是要看你有没有这个意识。

2.3 短路求值：逻辑操作符最容易被忽略的特性

and和or在Python里不只是返回布尔值这么简单，它们还有一个关键特性——短路求值。

• a and b：如果a为假，直接返回a，不再计算b。
• a or b：如果a为真，直接返回a，不再计算b。
• 如果没触发短路，则返回最后一个被计算的值。

这个特性在实战中特别有用。比如你想安全地获取一个可能为空的对象属性，可以写：

result = data and data.get("name")

如果data是假值（比如None或空列表），直接返回data，不会去调用.get()方法，也就不会报AttributeError。

但短路求值也可能带来隐蔽的bug。看这个例子：

def check(): print("check被调用了") return True print(False and check()) # 输出 False，check() 根本没执行

如果你在and右边放了一个函数调用，而这个函数有副作用（比如写入日志、修改全局变量），短路发生时就白白错过了这次调用。测验里我会专门设计一题来考察这一点，因为这是真实项目里最容易出幺蛾子的地方。

3. 测验题逐题拆解：从基础到易错全覆盖

下面进入正题。我按难度递增的顺序，把整套测验的核心题目一个个摆出来，每题都给出答案、解析和常见错误分析。强烈建议你先自己动手在Python交互环境或IDE里敲一遍，再看解析，效果完全不同。

3.1 第一梯队：算术操作符的“分水岭”题目

题目1：

print(7 / 2) print(7 // 2) print(7 % 2) print(2 ** 3)

这道题本质是考察四个最常用算术运算符的区别。答案是：

3.5 3 1 8

第一个7 / 2是真正的除法，结果是浮点数3.5，这是Python 3里最常见的“坑”。很多从Python 2转过来的人，或者从C语言、Java转过来的人，总会下意识以为两个整数相除结果是整数，但Python 3里/永远返回浮点数。如果你想要整数结果，必须用//。

第二个7 // 2是地板除，结果为3。注意，地板除是向下取整，不是截断取整。所以-7 // 2的结果是-4而不是-3，因为-3.5向下取整是-4。这一点极其容易踩坑，我在教负数运算时强调过无数次，还是有人错。

第三个7 % 2是取余，结果为1，这个通常没什么争议。

第四个2 ** 3是幂运算，结果为8。注意**的优先级比一元负号高，所以-2 ** 2的结果是-4，而不是4。你要是想让结果为正的4，必须写(-2) ** 2。这道题看似简单，实际上包含了两个隐藏考点。

题目2：

print(10 / 3) print(10 // 3) print(10 % 3) print(5 // 2) print(-5 // 2) print(5 % -2)

这是上一题的升级版，专门考察负数场景下的地板除和取余行为。答案是：

3.3333333333333335 3 1 2 -3 -1

这里我最想强调两点。

第一，10 / 3的结果在Python里显示为3.3333333333333335，后面那个5不是Bug，而是浮点数二进制存储的精度误差。你要是拿它和10 / 3 == 3.3333333333333333比较，结果可能是False。所以浮点数之间做相等比较前，一定三思。

第二，5 % -2的结果是-1，而不是1。Python里取余运算的结果符号总是跟随除数，也就是第二个操作数的符号。所以：

• 5 % -2：除数是负数，结果也是负数，为-1。
• -5 % 2：除数是正数，结果也是正数，为1。

这个规则跟C语言不一样，很多人第一次遇到直接懵。理解了“余数符号跟随除数”之后，你在处理循环索引、时间换算、周期性问题时都会更清楚。

3.2 第二梯队：比较与逻辑操作符的“短路陷阱”

题目3：

a = 5 b = 10 print(a > 3 and b < 20) print(a > 3 or b > 20) print(not a > 3) print(1 < a < 10)

答案依次是True、True、False、True。

前三个常规考察and、or、not，只要记住各自的真值表基本没问题。真正有意思的是第四个：1 < a < 10。这是Python特有的链式比较，它等价于1 < a and a < 10，结果为True。这种写法在数学上很自然，但在很多语言里是语法错误。Python允许你这么写，而且性能上也不差，所以放心用。

不过要注意，链式比较有个隐藏特性：中间的表达式只会被求值一次。比如：

def get_val(): print("get_val被调用") return 5 print(1 < get_val() < 10)

这里get_val()只会被调用一次。如果换成1 < get_val() and get_val() < 10，它会被调用两次。虽然大多数场景下这个区别无伤大雅，但如果函数有副作用，行为就会不同。

题目4：

print(0 and 100) print(2 and 3) print(0 or 100) print(2 or 3) print([] or "default") print("" and "value")

这题不考布尔值，考的是and和or的返回值本质。答案：

0 3 100 2 "default" ""

第一行：0 and 100，因为0是假值触发短路，直接返回0，根本不看100。

第二行：2 and 3，2是真值，继续往右算，返回3。注意这里返回的是3而不是True。

第三行：0 or 100，0是假值，继续往右算，返回100。

第四行：2 or 3，2是真值触发短路，直接返回2。

后面两行是实战中非常常见的“默认值”模式。[] or "default"返回"default"，因为空列表是假值；"" and "value"返回""，因为空字符串是假值且触发短路。

很多初学者以为and和or返回的一定是布尔值，这是不对的。Python里的and和or返回的是最后参与运算的操作数，而不一定是True或False。这个特性让代码更灵活，但也让不熟悉的人容易踩坑。

3.3 第三梯队：身份操作符is到底在比什么

题目5：

a = [1, 2, 3] b = [1, 2, 3] c = a print(a == b) print(a is b) print(a is c)

答案依次是True、False、True。

a == b比较的是值，两个列表内容一样，所以是True。a is b比较的是身份，也就是内存地址，a和b是两个不同的列表对象，即使内容一模一样，地址也不同，所以是False。a is c为True，因为c = a只是让c指向a同一个对象，并没有创建新列表。

这道题是新手重灾区。很多人以为is和==差不多，其实差别巨大。用一句话概括：==比“值是否相等”，is比“是不是同一个东西”。

更隐蔽的坑在整数和字符串上：

x = 256 y = 256 print(x is y) # True m = 257 n = 257 print(m is n) # 可能是 False

CPython里有一个“小整数缓存”机制，-5 到 256 之间的整数是预先创建好的对象，所以x is y为True。但超过这个范围，Python每次都会新建对象，m is n就可能是False。在真实开发里千万不要用is来判断整数或字符串是否相等，这个行为在不同版本、不同实现下都可能变，老老实实用==最安全。

3.4 第四梯队：类型转换与操作符的“混搭”

题目6：

print("3" * 3) print("3" + 3) print(int("3") + 3) print(str(3) + str(3))

第一个："3" * 3，结果是"333"。字符串和整数做乘法，表示重复字符串。

第二个："3" + 3，直接报TypeError。字符串不能和整数相加，Python不会隐式帮你做类型转换。

第三个：int("3") + 3，结果是6。显式转换后再相加，没问题。

第四个：str(3) + str(3)，结果是"33"。把数字转成字符串再拼接，没问题。

这道题考察的核心是：Python是强类型语言，不会在你不注意的时候偷偷帮你转换类型。相比之下，JavaScript里"3" + 3会得到"33"，这让很多人转到Python时极其不适应。

但更有意思的是下面这行代码：

print(True + 1) # 2

因为bool是int的子类，True在数值运算中会被当成1。所以True + 1等于2。这个特性偶尔会派上用场，但大多数时候属于“知道就行，别乱用”的范畴。

3.5 第五梯队：成员操作符与赋值操作符的实战变形

题目7：

fruits = ["apple", "banana", "cherry"] print("apple" in fruits) print("grape" not in fruits) print("a" in "apple") print(3 in range(5))

答案：True、True、True、True。

前面三个都好理解，in可以判断元素是否在列表里、字符串里。第四个值得单独提一下：3 in range(5)返回True，因为range(5)生成的是0到4的整数序列，3在这个序列里。但注意，range判断成员时是通过数学计算直接判断的，不会真的把所有元素列出来，所以即使range(10**10)这种超大范围，判断速度也很快。这是Python内部对range做的优化。

题目8：

x = 10 x += 5 print(x) x *= 2 print(x) x //= 3 print(x)

答案：15、30、10。

+=、*=、//=这类复合赋值操作符，本质是“先计算右边的表达式，再对当前变量做对应操作，最后把结果赋回变量”。但有一个细节需要注意：x += 1对不可变对象（如整数、字符串、元组）是重新绑定变量名；对可变对象（如列表）则可能是在原对象上修改。

比如：

a = [1, 2] b = a a += [3] print(b) # [1, 2, 3]，b也跟着变了

因为a += [3]实际上调用的是a.__iadd__方法，对列表来说就是就地修改，b和a指向同一个列表，所以b的内容也变了。如果你写的是a = a + [3]，则是新建列表再赋值，b不会变。这两者的区别，我在带项目时见过不止一次因为混淆它们而引发的bug。

3.6 第六梯队：位操作符的几个实用场景

题目9：

print(5 & 3) print(5 | 3) print(5 ^ 3) print(~5) print(1 << 3) print(8 >> 2)

答案：

1 7 6 -6 8 2

位操作符在日常业务代码里用得确实不多，但在权限系统、状态标志位、性能敏感的底层计算里却非常有用。

先手算验证一下：5 的二进制是101，3 的二进制是011。

• 5 & 3（按位与）：101 & 011 = 001，十进制是1。
• 5 | 3（按位或）：101 | 011 = 111，十进制是7。
• 5 ^ 3（按位异或）：101 ^ 011 = 110，十进制是6。
• ~5（按位取反）：在Python里结果不是我们直觉上的-5而是-6。因为Python的整数是任意精度的补码表示，~x等价于-x - 1，所以~5是-6。
• 1 << 3（左移3位）：1变成1000，十进制是8，相当于乘以2**3。
• 8 >> 2（右移2位）：1000变成10，十进制是2，相当于整除2**2。

位运算的一个经典应用是“用整数来存储多个布尔标志位”。比如一个文件权限系统，用r、w、x三个位来表示读、写、执行权限：

READ = 4 # 100 WRITE = 2 # 010 EXECUTE = 1 # 001 permission = READ | WRITE # 6，表示可读可写 if permission & READ: print("可读") if permission & EXECUTE: print("可执行") # 这行不会输出

这种写法的好处是节省内存、可以用一个整数同时表示多个开关状态，在很多算法题和底层库里都能看到。测验里出这道题的目的不是让你背答案，而是让你知道Python里有这么一类操作符，将来遇到了能反应过来。

3.7 第七梯队：混合运算的“终极考验”

题目10：

print(2 + 3 * 4 ** 2) print((2 + 3) * 4 ** 2) print(not True and False or True) print(5 == 5 and 6 != 7 or 8 < 3)

答案：

50 80 True True

第一行：4 ** 2 = 16，然后3 * 16 = 48，最后2 + 48 = 50。

第二行：加了括号后，先算2 + 3 = 5，再算4 ** 2 = 16，最后5 * 16 = 80。

第三行：not True是False，因此False and False触发短路，直接返回False；接着False or True返回True。整个过程等价于(not True) and False or True。

第四行：5 == 5是True，6 != 7是True，所以True and True为True；再True or 8 < 3，因为短路直接返回True。注意这里8 < 3根本不会被计算。

这类混合运算题，就是检验你优先级掌握程度的试金石。如果你能在5秒内说出正确答案，说明你已经基本形成了操作符的“肌肉记忆”。

4. 做完测验后的深度复盘：这些“坑”值得反复看

做题不是目的，把错的题弄懂才是目的。下面这些坑，是我在带教学、改作业、看代码评审时反复遇到的，这里一次性列出来。

4.1 赋值 vs 比较：一个等号引发的血案

Python里=是赋值，==是相等比较。这个区别几乎每个教程都会讲，但实际写代码时，还是有人把if a = 5:当成“如果a等于5”，结果直接报语法错误。更隐蔽的是在循环或条件里不小心多写了一个等号，虽然不报错，但逻辑完全错了：

a = 5 if a = 5: # 语法错误 print("相等")

正确写法是：

a = 5 if a == 5: # 注意两个等号 print("相等")

如果实在怕记混，有个土办法：读代码时把=读成“被赋值为”，把==读成“等于”，一读就知道哪里不对了。

还有个小技巧，Python 3.8之后如果你想在条件里“随手赋值并比较”，可以用海象操作符：

if (n := len(data)) > 10: print(f"长度是{n}，超过10了")

这既避免了len(data)调用两次，也绕开了“赋值还是比较”的混淆。

4.2 浮点数比较：绝对不要直接==

我在前面的题目里已经铺垫过浮点数的精度问题，这里再往深里说一层。你可能会问：“既然浮点数有精度问题，那我到底该怎么比较两个浮点数？”

常规做法是设置一个很小的容差值（epsilon）：

a = 0.1 + 0.2 b = 0.3 print(abs(a - b) < 1e-9) # True

或者用Python 3.5+ 的math.isclose：

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

math.isclose是官方推荐的方式，默认考虑相对误差和绝对误差，写起来也最清晰。测验里如果出了0.1 + 0.2 == 0.3这种题，可得留个心眼，千万不要直接写True。

4.3 优先级记不全怎么办：括号是最诚实的工具

坦白说，哪怕是写了好几年Python的人，也很难把每个操作符的优先级顺序倒背如流。我的做法是：除了最基础的算术运算，其他一律加括号。这无关技术能力，而是代码可读性的问题。

举个例子：

result = a and b or c and d

这种写法也许逻辑上是正确的，但读者需要花时间解析优先级。倒不如写成：

result = (a and b) or (c and d)

阅读成本瞬间降低。操作符测试里那些“不写括号考你优先级”的题，是为了帮你建立对规则的理解；但真正写项目代码时，可读性优先，括号不是示弱，而是专业素养。

4.4 布尔值是整数的子类：你以为的“类型错误”其实不是

我在题目6的解析里提到True + 1结果是2。这个特性偶尔会坑人。比如你想统计一个列表里大于0的元素个数，可能会顺手写出：

count = sum(x > 0 for x in nums)

这里x > 0返回布尔值，而sum求和时把True当成1、False当成0，所以这行代码能正常工作。但如果你在if条件里依赖这种隐式转换，就要小心了：

if 2: print("2是真理值") if 0: print("这行不会输出")

Python所有的对象都可以直接用在布尔上下文中，判断标准是“真假值”（truthiness），而不是“是否等于True”。空列表、空字符串、0、None 都是假值，其余大多是真值。理解了这个，很多看似奇怪的代码都能看懂了。

4.5is和==的终极区分：一句话记牢

你想比“值”就用==，你想比“是不是同一个对象”就用is。除了一种特殊情况：你想判断一个变量是不是None。这时官方推荐用is None，而不是== None：

if data is None: print("data是None")

因为None在Python里是单例对象，所有None都是同一个对象，用is判断既快又安全。但如果你要用==判断其他两个对象是否相等，那完全没有问题。

4.6 复合赋值操作符和可变对象：+=的隐藏风险

我在题目8的解析里提到了a += [3]和a = a + [3]的区别。这个知识点在函数参数传递时尤其重要。

def add_item(lst, item): lst += [item] # 外部列表会被修改 def add_item_safe(lst, item): lst = lst + [item] # 外部列表不会被修改 return lst my_list = [1, 2] add_item(my_list, 3) print(my_list) # [1, 2, 3] my_list2 = [1, 2] new_list = add_item_safe(my_list2, 3) print(my_list2) # [1, 2] print(new_list) # [1, 2, 3]

如果你在函数里用了+=且操作的是可变对象，外部变量可能被悄悄改动，这常常导致非常难排查的bug。要记住一个原则：复合赋值操作符对不可变对象是“创建新值”，对可变对象是“就地修改”。如果你拿不准当前对象是可变还是不可变，先查一下id或者干脆用显式的=赋值。

5. 从测验到实战：操作符在真实场景里的正确打开方式

做对几道测验题不代表你就能写出好代码，从测验到实战之间还差着“场景思维”这道坎。这一章我会把操作符放到真实的应用场景里，告诉你它们是怎么协同工作的。

5.1 条件判断中的操作符组合：用括号理清业务逻辑

假设你在写一个用户权限校验的功能，要求是“管理员或者VIP用户都能进入，但被封禁的用户除外”。这个逻辑直接用自然语言描述很简单，翻译成代码就讲究了：

if (is_admin or is_vip) and not is_banned: print("允许进入") else: print("拒绝进入")

这里and、or、not三个操作符全用上了。最关键的写法是：(is_admin or is_vip)这个括号必须加。如果不加括号，写成is_admin or is_vip and not is_banned，因为and优先级高于or，实际等价于is_admin or (is_vip and not is_banned)。这样当is_admin为True时，即使is_banned为True，也会放行，逻辑就错了。

业务需求越复杂，括号越能体现价值。我见过不少老手在代码评审时对着一串andornot盯半天，最后加上括号长舒一口气。不要和优先级较劲，把优先级交给括号，把可读性留给读者。

5.2 用操作符简化数据处理：从笨重到优雅

再看一个数据处理场景。你想筛选出一个列表中所有“非空字符串且长度大于3”的元素，最直观的写法：

items = ["abc", "", "hello", "a", "world"] result = [] for item in items: if item and len(item) > 3: result.append(item) print(result) # ['hello', 'world']

这里item直接用在了布尔上下文中。空字符串是假值，所以item and len(item) > 3在item为空时直接返回空字符串，不会去调用len()，既简洁又安全。

同样的思路可以用在默认值设置上：

name = input("请输入名字：") or "匿名用户"

如果用户什么都没输入，name就是空字符串，属于假值，于是or返回"匿名用户"。这是Python里非常经典的“默认值”写法，一行代码替代了三行if-else。

5.3 在循环和索引中善用算术操作符

另一个高频场景是循环索引。比如你想每隔两个元素处理一次列表：

data = ["a", "b", "c", "d", "e", "f"] for i, value in enumerate(data): if i % 2 == 0: print(f"处理偶数索引{i}：{value}")

%取余操作符在这里就是“判断是否间隔元素”的利器。再比如轮询通知、分页计算、循环队列，也全靠%和//配合。

一个实用小技巧：如果你要把秒数换算成“时:分:秒”格式，可以用：

total = 3661 hours = total // 3600 minutes = (total % 3600) // 60 seconds = total % 60 print(f"{hours}:{minutes}:{seconds}") # 1:1:1

//负责取整部分，%负责剩余部分，两个操作符配合得天衣无缝。

5.4 海象操作符在实战中的正确姿势

海象操作符:=我前面提过，这里给一个更“实用主义”的例子。比如你要从文件里逐行读取，直到遇到空行：

with open("data.txt", "r") as f: while (line := f.readline().strip()): print(f"处理行：{line}")

如果不使用海象操作符，你得先读一行、判断是否为空、然后再进入循环体处理，过程会比较绕：

with open("data.txt", "r") as f: line = f.readline().strip() while line != "": print(f"处理行：{line}") line = f.readline().strip()

两种写法都对，但第一种明显更紧凑，而且不会出现“循环体内忘了更新行变量”的低级错误。海象操作符用得好，确实能让代码更接近你的思维过程。

6. 自查清单：你的操作符掌握度到底什么水平

讲完题目和实战，最后给出一份自查清单。你可以对照清单在脑子里逐条过一遍，看看哪条还不够熟练。

我再补充一点容易被忽略的：字典的in判断的是键而不是值。

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

这个细节很基础，但我见过不少面试者在这个问题上翻车。你如果觉得自己的操作符基础还不够牢，把这份清单打印出来贴在工位旁边，边写代码边对照，进步会非常快。

我从一开始教Python时就坚信一个理念：语法可以查文档，但操作符的直觉必须靠练。文档只能告诉你%是取余，但只有当你真正手算过-7 % 3并意识到结果是2时，你才真正理解了它。这套测验就是帮你建立这种直觉的捷径。把上面的题一道一道亲手敲一遍、错一遍、再改一遍，比你囫囵吞枣刷十遍教程都管用。操作符这一关过了，后面的条件判断、循环、函数、类，都会顺畅很多。