一、知识回顾（读完直接做下面的实践题）#

1. 算术运算符：+ 加、- 减、* 乘、/ 除（结果一定是浮点数）、% 取模（余数）、** 幂、// 整除（往小的方向取整数，-9 // 2 得 -5）
2. 比较运算符：== 等于、!= 不等于、>、<、>=、<=，结果都是 True 或 False；注意 = 是赋值、== 才是比较，别写混
3. 赋值运算符：= 直接赋值；复合赋值 +=、-=、*=、/=、%=、**=、//=——c += a 就等价于 c = c + a
4. 海象运算符 :=（Python 3.8 新增）：在表达式里同时赋值并返回这个值，如 if (n := len(a)) > 10: 可以避免把 len(a) 算两遍
5. 位运算符：把数字看成二进制来算——& 按位与、| 按位或、^ 按位异或、~ 按位取反、<< 左移、>> 右移（例：60 & 13 = 12）
6. 逻辑运算符：and（x 为假就返回 x，否则返回 y）、or（x 为真就返回 x，否则返回 y）、not（取反）；and/or 返回的是参与运算的值本身，不一定是 True/False（10 and 20 得 20）
7. 成员运算符：in（在序列里找到就返回 True）、not in（找不到才返回 True），可用于字符串、列表、元组
8. 身份运算符：is / is not 比的是是不是同一个对象（相当于比 id()）；== 比的是值。b = a 是同一个对象，b = a[:] 只是值相等的新对象
9. 运算符优先级（从高到低）：括号 → 索引/切片/调用/属性 → ** → 正负号、~ → * / // % → + - → 移位 → & ^ | → 比较/成员/身份 → not → and → or → 条件表达式
10. 三元运算符（条件表达式）：值1 if 条件 else 值2——条件为真取前面的值，为假取后面的值；它是个表达式（能算出结果），可以直接写在赋值和函数参数里

二、裸写题#

• 2-1 算术运算符练习 ❌ 创建文件 test_arithmetic.py，完成以下计算并打印结果：

  • 15 + 4（加法）
  • 15 - 4（减法）
  • 15 * 4（乘法）
  • 15 / 4（除法，得到小数）
  • 15 // 4（整除）
  • 15 % 4（取余）
  • 2 ** 10（乘方）

  批改（2026-09-28）：❌ 7 个 print 都漏了 f 前缀，输出成了字面量 15+4={15+4}；正确写法是 print(f"15 + 4 = {15 + 4}")。另外第 7 行写的是 15**4（题面要求 2 ** 10），字符串里还多写了一个 a（15**4=a{15**4}），应改成 print(f"2 ** 10 = {2 ** 10}")。

  提示（先自己想，实在想不出再点开）

  一级 · 思路：七个小算式一个一个算出来打印，把算式直接写进输出字符串的花括号里，让 Python 替你算完再填进去 二级 · 方法：带 f 前缀的格式化输出，如 print(f"15 + 4 = {15 + 4}")；记住 // 是整除、% 是取余、** 是乘方 三级 · 骨架：print(f"15 + 4 = {15 ____ 4}") / print(f"2 ** 10 = {2 ____ 10}")

  参考答案（做完再点开）

  1
  # 2-1
  2
  print(f"15 + 4 = {15 + 4}")      # 19
  3
  print(f"15 - 4 = {15 - 4}")      # 11
  4
  print(f"15 * 4 = {15 * 4}")      # 60
  5
  print(f"15 / 4 = {15 / 4}")      # 3.75
  6
  print(f"15 // 4 = {15 // 4}")    # 3
  7
  print(f"15 % 4 = {15 % 4}")      # 3
  8
  print(f"2 ** 10 = {2 ** 10}")    # 1024

• 2-2 比较运算符练习 创建文件 test_compare.py，完成以下操作：

  • 比较 10 == 10、10 != 5、10 > 5、10 < 5、10 >= 10、10 <= 5
  • 打印每个结果

  批改（2026-09-28）：⚠️ 6 个结果值全对（True/True/True/False/True/False），但第 5 项写的是 10 >= 5，题面要求 10 >= 10（两者结果恰好都是 True）。

  提示（先自己想，实在想不出再点开）

  一级 · 思路：六个比较各算一遍，把整个比较式放进花括号里，Python 会把 True/False 填进去 二级 · 方法：比较运算符 ==、!=、>、<、>=、<=；输出用 print(f"10 == 10: {10 == 10}") 这种写法 三级 · 骨架：print(f"10 >= 10: {10 ____ 10}") / print(f"10 != 5: {10 ____ 5}")

  参考答案（做完再点开）

  1
  # 2-2
  2
  print(f"10 == 10: {10 == 10}")   # True
  3
  print(f"10 != 5: {10 != 5}")    # True
  4
  print(f"10 > 5: {10 > 5}")      # True
  5
  print(f"10 < 5: {10 < 5}")      # False
  6
  print(f"10 >= 10: {10 >= 10}")  # True
  7
  print(f"10 <= 5: {10 <= 5}")    # False

• 2-3 赋值运算符练习 创建文件 test_assignment.py，完成以下操作：

  • 创建变量 a = 10
  • 用 += 加 5
  • 用 -= 减 3
  • 用 *= 乘 2
  • 用 //= 整除 3
  • 每步打印结果

  批改（2026-09-28）：✅ 正确（15、12、24、8 四步结果都对）；没有打印初始值 10，参考答案有 print(f"初始值: a = {a}") 这一行。

  提示（先自己想，实在想不出再点开）

  一级 · 思路：每做一次复合赋值就立刻输出一次，盯着变量一步一步变成多少 二级 · 方法：复合赋值运算符 +=、-=、*=、//=——a += 5 等价于 a = a + 5 三级 · 骨架：a ____ 5 / a -= ____ / a *= 2 / a //= ____

  参考答案（做完再点开）

  1
  # 2-3
  2
  a = 10
  3
  print(f"初始值: a = {a}")    # 10
  4
  
  5
  a += 5
  6
  print(f"a += 5: {a}")       # 15
  7
  
  8
  a -= 3
  9
  print(f"a -= 3: {a}")       # 12
  10
  
  11
  a *= 2
  12
  print(f"a *= 2: {a}")       # 24
  13
  
  14
  a //= 3
  15
  print(f"a //= 3: {a}")      # 8

  显示更多显示更少

• 2-4 逻辑运算符练习 创建文件 test_logical.py，完成以下操作：

  • 测试 True and False、True or False、not True
  • 用变量测试：a = 10, b = 20，测试 a and b、a or b、not a

  批改（2026-09-28）：✅ 正确（False、True、False、20、10、False 全对）。

  提示（先自己想，实在想不出再点开）

  一级 · 思路：先拿两个布尔值直接算一遍，再换成两个数字变量算一遍，对比两次的输出 二级 · 方法：and、or、not；输出写 print(f"a and b: {a and b}")；留意 and/or 返回的是值本身，not 返回的才是布尔值 三级 · 骨架：print(f"a or b: {a ____ b}") / print(f"not a: {____ a}")

  参考答案（做完再点开）

  1
  # 2-4
  2
  print(f"True and False: {True and False}")   # False
  3
  print(f"True or False: {True or False}")     # True
  4
  print(f"not True: {not True}")               # False
  5
  
  6
  a = 10
  7
  b = 20
  8
  print(f"a and b: {a and b}")   # 20（返回最后一个真值）
  9
  print(f"a or b: {a or b}")     # 10（返回第一个真值）
  10
  print(f"not a: {not a}")       # False

• 2-5 成员运算符练习 创建文件 test_member.py，完成以下操作：

  • 创建列表 fruits = ["苹果", "香蕉", "橘子"]
  • 测试 "苹果" in fruits
  • 测试 "西瓜" not in fruits
  • 测试 "香蕉" in fruits

  批改（2026-09-28）：✅ 正确（"苹果" in fruits、"西瓜" not in fruits、"香蕉" in fruits 三项都输出 True）。

  提示（先自己想，实在想不出再点开）

  一级 · 思路：先建一个水果列表，再用成员运算符一项一项判断某个值在不在里面 二级 · 方法：成员运算符 in 和 not in；输出写 print(f"'苹果' in fruits: {'苹果' in fruits}") 三级 · 骨架：print(f"'西瓜' not in fruits: {'西瓜' ____ fruits}") / print(f"'香蕉' in fruits: {'香蕉' ____ fruits}")

  参考答案（做完再点开）

  1
  # 2-5
  2
  fruits = ["苹果", "香蕉", "橘子"]
  3
  
  4
  print(f"'苹果' in fruits: {'苹果' in fruits}")       # True
  5
  print(f"'西瓜' not in fruits: {'西瓜' not in fruits}")  # True
  6
  print(f"'香蕉' in fruits: {'香蕉' in fruits}")       # True

• 2-6 身份运算符练习 创建文件 test_identity.py，完成以下操作：

  • 创建 a = [1, 2, 3]，b = a，c = a[:]
  • 测试 a is b、a is c、a == b、a == c
  • 用 id() 查看内存地址

  批改（2026-09-28）：✅ 正确（a is b True、a is c False、a == b/a == c True；实测 id(a) 与 id(b) 相同、id(c) 不同）。

  提示（先自己想，实在想不出再点开）

  一级 · 思路：b = a 只是给同一个对象又起了一个名字，切片 c = a[:] 才是真的造出一个新对象；用身份运算符比一比，再看两者的内存地址 二级 · 方法：身份运算符 is / is not、相等比较 ==；看内存地址用内置函数 id(对象) 三级 · 骨架：print(f"a is c: {a ____ c}") / print(f"id(a): {____(a)}")

  参考答案（做完再点开）

  1
  # 2-6
  2
  a = [1, 2, 3]
  3
  b = a
  4
  c = a[:]
  5
  
  6
  print(f"a is b: {a is b}")     # True（同一个对象）
  7
  print(f"a is c: {a is c}")     # False（不同对象）
  8
  print(f"a == b: {a == b}")     # True（值相等）
  9
  print(f"a == c: {a == c}")     # True（值相等）
  10
  
  11
  print(f"id(a): {id(a)}")
  12
  print(f"id(b): {id(b)}")  # 和 a 相同
  13
  print(f"id(c): {id(c)}")  # 和 a 不同