运算符是什么
本章节主要说明 Python 的运算符。
举个简单的例子:
4 + 5 = 9例子中， 4 和 5 被称为 操作数 ，+ 称为 运算符 。
Python 语言支持以下类型的运算符:
接下来让我们一个个来学习Python的运算符。
Python算术运算符
以下假设变量 a=10，变量 b=21：
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 加 - 两个对象相加 | a + b 输出结果 31 |
| - | 减 - 得到负数或是一个数减去另一个数 | a - b 输出结果 -11 |
| * | 乘 - 两个数相乘或是返回一个被重复若干次的字符串 | a * b 输出结果 210 |
| / | 除 - x 除以 y | b / a 输出结果 2.1 |
| % | 取模 - 返回除法的余数 | b % a 输出结果 1 |
| ** | 幂 - 返回x的y次幂 | a**b 为10的21次方 |
| // | 取整除 - 往小的方向取整数 | >>> 9//2 4 >>> -9//2 -5 |
以下实例演示了Python所有算术运算符的操作：
实例(Python 3.0+)
a = 21
b = 10
c = 0
c = a + b
print("1 - c 的值为：", c)
c = a - b
print("2 - c 的值为：", c)
c = a * b
print("3 - c 的值为：", c)
c = a / b
print("4 - c 的值为：", c)
c = a % b
print("5 - c 的值为：", c)
a = 2
b = 3
c = a**b
print("6 - c 的值为：", c)
a = 10
b = 5
c = a // b
print("7 - c 的值为：", c)以上实例输出结果：
1 - c 的值为： 31
2 - c 的值为： 11
3 - c 的值为： 210
4 - c 的值为： 2.1
5 - c 的值为： 1
6 - c 的值为： 8
7 - c 的值为： 2Python 比较运算符
以下假设变量 a 为 10，变量 b 为20：
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 等于 - 比较对象是否相等 | (a == b) 返回 False。 |
| != | 不等于 - 比较两个对象是否不相等 | (a!= b) 返回 True。 |
| > | 大于 - 返回x是否大于y | (a > b) 返回 False。 |
| < | 小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。 | (a < b) 返回 True。 |
| >= | 大于等于 - 返回x是否大于等于y。 | (a >= b) 返回 False。 |
| <= | 小于等于 - 返回x是否小于等于y。 | (a <= b) 返回 True。 |
以下实例演示了Python所有比较运算符的操作：
实例(Python 3.0+)
a = 21
b = 10
c = 0
if (a == b):
print("1 - a 等于 b")
else:
print("1 - a 不等于 b")
if (a != b):
print("2 - a 不等于 b")
else:
print("2 - a 等于 b")
if (a < b):
print("3 - a 小于 b")
else:
print("3 - a 大于等于 b")
if (a > b):
print("4 - a 大于 b")
else:
print("4 - a 小于等于 b")
a = 5
b = 20
if (a <= b):
print("5 - a 小于等于 b")
else:
print("5 - a 大于 b")
if (b >= a):
print("6 - b 大于等于 a")
else:
print("6 - b 小于 a")以上实例输出结果：
1 - a 不等于 b
2 - a 不等于 b
3 - a 大于等于 b
4 - a 大于 b
5 - a 小于等于 b
6 - b 大于等于 aPython赋值运算符
以下假设变量a为10，变量b为20：
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 简单的赋值运算符 | c = a + b 将 a + b 的运算结果赋值为 c |
| += | 加法赋值运算符 | c += a 等效于 c = c + a |
| -= | 减法赋值运算符 | c -= a 等效于 c = c - a |
| *= | 乘法赋值运算符 | c *= a 等效于 c = c * a |
| /= | 除法赋值运算符 | c /= a 等效于 c = c / a |
| %= | 取模赋值运算符 | c %= a 等效于 c = c % a |
| **= | 幂赋值运算符 | c **= a 等效于 c = c ** a |
| //= | 取整除赋值运算符 | c //= a 等效于 c = c // a |
| := | 海象运算符，这个运算符的主要目的是在表达式中同时进行赋值和返回赋值的值。 Python3.8 版本新增运算符 。 | 在这个示例中，赋值表达式可以避免调用 len() 两次: if (n := len(a)) > 10: print(f"List is too long ({n} elements, expected <= 10)") |
以下实例演示了Python所有赋值运算符的操作：
实例(Python 3.0+)
a = 21
b = 10
c = 0
c = a + b
print("1 - c 的值为：", c)
c += a
print("2 - c 的值为：", c)
c *= a
print("3 - c 的值为：", c)
c /= a
print("4 - c 的值为：", c)
c = 2
c %= a
print("5 - c 的值为：", c)
c **= a
print("6 - c 的值为：", c)
c //= a
print("7 - c 的值为：", c)以上实例输出结果：
1 - c 的值为： 31
2 - c 的值为： 52
3 - c 的值为： 1092
4 - c 的值为： 52.0
5 - c 的值为： 2
6 - c 的值为： 2097152
7 - c 的值为： 99864在 Python 3.8 及更高版本中，引入了一种新的语法特性，称为"海象运算符"（Walrus Operator），它使用:= 符号。这个运算符的主要目的是在表达式中同时进行赋值和返回赋值的值。
使用海象运算符可以在一些情况下简化代码，尤其是在需要在表达式中使用赋值结果的情况下。这对于简化循环条件或表达式中的重复计算很有用。
下面是一个简单的实例，演示了海象运算符的使用：
实例
# 传统写法
n = 10
if n > 5:
print(n)
# 使用海象运算符
if (n := 10) > 5:
print(n)if (n := 10) > 5:：这是使用海象运算符（:=）的写法。海象运算符在表达式中进行赋值操作。(n := 10)：将变量n赋值为 10，同时返回这个赋值结果。> 5：检查赋值后的n是否大于 5。如果条件为真，则执行接下来的代码块。
print(n)：如果条件为真，打印变量n的值（即 10）。
海象运算符的优点：
- 海象运算符（
:=）允许在表达式内部进行赋值，这可以减少代码的重复，提高代码的可读性和简洁性。 - 在上述例子中，传统写法需要单独一行来赋值
n，然后在if语句中进行条件检查。而使用海象运算符的写法可以在if语句中直接进行赋值和条件检查。
Python位运算符
按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：
下表中变量 a 为 60，b 为 13二进制格式如下：
a = 0011 1100
b = 0000 1101
-----------------
a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
~a = 1100 0011| 运算符 | 描述 | 实例 |
|---|---|---|
| & | 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 | (a & b) 输出结果 12 ，二进制解释： 0000 1100 |
| | | 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。 | (a | b) 输出结果 61 ，二进制解释： 0011 1101 |
| ^ | 按位异或运算符：当两对应的二进位相异时，结果为1 | (a ^ b) 输出结果 49 ，二进制解释： 0011 0001 |
| ~ | 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1 | (~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。 |
| << | 左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。 | a << 2 输出结果 240 ，二进制解释： 1111 0000 |
| >> | 右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数 | a >> 2 输出结果 15 ，二进制解释： 0000 1111 |
以下实例演示了Python所有位运算符的操作：
实例(Python 3.0+)
a = 60
b = 13
c = 0
c = a & b
print("1 - c 的值为：", c)
c = a | b
print("2 - c 的值为：", c)
c = a ^ b
print("3 - c 的值为：", c)
c = ~a
print("4 - c 的值为：", c)
c = a << 2
print("5 - c 的值为：", c)
c = a >> 2
print("6 - c 的值为：", c)以上实例输出结果：
1 - c 的值为： 12
2 - c 的值为： 61
3 - c 的值为： 49
4 - c 的值为： -61
5 - c 的值为： 240
6 - c 的值为： 15Python逻辑运算符
Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:
| 运算符 | 逻辑表达式 | 描述 | 实例 |
|---|---|---|---|
| and | x and y | 布尔"与" - 如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值。 | (a and b) 返回 20。 |
| or | x or y | 布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。 | (a or b) 返回 10。 |
| not | not x | 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 | not(a and b) 返回 False |
以上实例输出结果：
实例(Python 3.0+)
a = 10
b = 20
if (a and b):
print("1 - 变量 a 和 b 都为 true")
else:
print("1 - 变量 a 和 b 有一个不为 true")
if (a or b):
print("2 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
print("2 - 变量 a 和 b 都不为 true")
a = 0
if (a and b):
print("3 - 变量 a 和 b 都为 true")
else:
print("3 - 变量 a 和 b 有一个不为 true")
if (a or b):
print("4 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
print("4 - 变量 a 和 b 都不为 true")
if not (a and b):
print("5 - 变量 a 和 b 都为 false，或其中一个变量为 false")
else:
print("5 - 变量 a 和 b 都为 true")以上实例输出结果：
1 - 变量 a 和 b 都为 true
2 - 变量 a 和 b 都为 true，或其中一个变量为 true
3 - 变量 a 和 b 有一个不为 true
4 - 变量 a 和 b 都为 true，或其中一个变量为 true
5 - 变量 a 和 b 都为 false，或其中一个变量为 falsePython成员运算符
除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。
| 运算符 | 描述 | 实例 |
|---|---|---|
| in | 如果在指定的序列中找到值返回 True，否则返回 False。 | x 在 y 序列中, 如果 x 在 y 序列中返回 True。 |
| not in | 如果在指定的序列中没有找到值返回 True，否则返回 False。 | x 不在 y 序列中, 如果 x 不在 y 序列中返回 True。 |
以下实例演示了Python所有成员运算符的操作：
实例(Python 3.0+)
a = 10
b = 20
list = [1, 2, 3, 4, 5]
if (a in list):
print("1 - 变量 a 在给定的列表中 list 中")
else:
print("1 - 变量 a 不在给定的列表中 list 中")
if (b not in list):
print("2 - 变量 b 不在给定的列表中 list 中")
else:
print("2 - 变量 b 在给定的列表中 list 中")
a = 2
if (a in list):
print("3 - 变量 a 在给定的列表中 list 中")
else:
print("3 - 变量 a 不在给定的列表中 list 中")以上实例输出结果：
1 - 变量 a 不在给定的列表中 list 中
2 - 变量 b 不在给定的列表中 list 中
3 - 变量 a 在给定的列表中 list 中Python身份运算符
身份运算符用于比较两个对象的存储单元
| 运算符 | 描述 | 实例 |
|---|---|---|
| is | is 是判断两个标识符是不是引用自一个对象 | x is y, 类似 id(x) == id(y), 如果引用的是同一个对象则返回 True，否则返回 False |
| is not | is not 是判断两个标识符是不是引用自不同对象 | x is not y ， 类似 id(x)!= id(y) 。如果引用的不是同一个对象则返回结果 True，否则返回 False。 |
注： id() 函数用于获取对象内存地址。
以下实例演示了Python所有身份运算符的操作：
实例(Python 3.0+)
a = 20
b = 20
if (a is b):
print("1 - a 和 b 有相同的标识")
else:
print("1 - a 和 b 没有相同的标识")
if (id(a) == id(b)):
print("2 - a 和 b 有相同的标识")
else:
print("2 - a 和 b 没有相同的标识")
b = 30
if (a is b):
print("3 - a 和 b 有相同的标识")
else:
print("3 - a 和 b 没有相同的标识")
if (a is not b):
print("4 - a 和 b 没有相同的标识")
else:
print("4 - a 和 b 有相同的标识")以上实例输出结果：
1 - a 和 b 有相同的标识
2 - a 和 b 有相同的标识
3 - a 和 b 没有相同的标识
4 - a 和 b 没有相同的标识is 与 == 区别：
is 用于判断两个变量引用对象是否为同一个，== 用于判断引用变量的值是否相等。
>>> a = [1, 2, 3]
>>> b = a
>>> b is a
True
>>> b == a
True
>>> b = a[:]
>>> b is a
False
>>> b == a
TruePython运算符优先级
以下表格列出了从最高到最低优先级的所有运算符， 相同单元格内的运算符具有相同优先级。 运算符均指二元运算，除非特别指出。 相同单元格内的运算符从左至右分组（除了幂运算是从右至左分组）：
| 运算符 | 描述 |
|---|---|
(expressions...), [expressions...], {key: value...}, {expressions...} | 圆括号的表达式 |
x[index], x[index:index], x(arguments...), x.attribute | 读取，切片，调用，属性引用 |
| await x | await 表达式 |
** | 乘方(指数) |
+x, -x, ~x | 正，负，按位非 NOT |
*, @, /, //, % | 乘，矩阵乘，除，整除，取余 |
+, - | 加和减 |
<<, >> | 移位 |
& | 按位与 AND |
^ | 按位异或 XOR |
| | 按位或 OR |
`in`,`not in`, `is`,`is not`, `<`, `<=`, `>`, `>=`, `!=`, `==` | 比较运算，包括成员检测和标识号检测 |
`not x` | 逻辑非 NOT |
`and` | 逻辑与 AND |
`or` | 逻辑或 OR |
`if` -- `else` | 条件表达式 |
`lambda` | lambda 表达式 |
:= | 赋值表达式 |
以下实例演示了Python所有运算符优先级的操作：
实例(Python 3.0+)
a = 20
b = 10
c = 15
d = 5
e = 0
e = (a + b) * c / d
print("(a + b) * c / d 运算结果为：", e)
e = ((a + b) * c) / d
print("((a + b) * c) / d 运算结果为：", e)
e = (a + b) * (c / d)
print("(a + b) * (c / d) 运算结果为：", e)
e = a + (b * c) / d
print("a + (b * c) / d 运算结果为：", e)以上实例输出结果：
(a + b) * c / d 运算结果为： 90.0
((a + b) * c) / d 运算结果为： 90.0
(a + b) * (c / d) 运算结果为： 90.0
a + (b * c) / d 运算结果为： 50.0and 拥有更高优先级:
实例
x = True
y = False
z = False
print("情况1：默认优先级（先算and）")
if x or y and z:
print("yes")
else:
print("no")
print("\n情况2：强制改变优先级（先算or）")
if (x or y) and z:
print("yes")
else:
print("no")以上实例先计算 y and z 并返回 False ，然后 x or False 返回 True，输出结果：
情况1：默认优先级（先算and）
yes
情况2：强制改变优先级（先算or）
no注意： Python3 已不支持 <> 运算符，可以使用!= 代替，如果你一定要使用这种比较运算符，可以使用以下的方式：
>>> from __future__ import barry_as_FLUFL
>>> 1 <> 2
True三元运算符（条件表达式）
语法： <true_value> if 条件表达式 else <false_value>
条件为真时整个表达式的结果是第一个值，否则是第二个值。因为它能"算出结果"，所以是表达式而不是语句，可以直接写在赋值、函数参数里面。
age = 20
# 普通写法
if age >= 18:
result = "成年"
else:
result = "未成年"
# 三元运算符写法：一行搞定
result = "成年" if age >= 18 else "未成年"
print(result) # 成年在项目中的实际用法（AI 智能伴侣侧边栏，当前会话的按钮高亮）：
st.button(
session,
key=f"load_{session}",
type="primary" if session == st.session_state.current_session else "secondary"
)条件是"这个会话是不是当前会话"，为真则按钮类型取 "primary"（高亮），否则取 "secondary"（普通）。
注意： 三元运算符是先算条件前面那个值、再看条件的写法，不要和
and/or的短路混用；嵌套多层（a if x else b if y else c）会严重影响可读性，超过两层建议改回if...elif...else。
相关
练习题
一、知识回顾（读完直接做下面的实践题）
- 算术运算符：
+加、-减、*乘、/除（结果一定是浮点数）、%取模（余数）、**幂、//整除（往小的方向取整数，-9 // 2得-5） - 比较运算符：
==等于、!=不等于、>、<、>=、<=，结果都是True或False；注意=是赋值、==才是比较，别写混 - 赋值运算符：
=直接赋值；复合赋值+=、-=、*=、/=、%=、**=、//=——c += a就等价于c = c + a - 海象运算符
:=（Python 3.8 新增）：在表达式里同时赋值并返回这个值，如if (n := len(a)) > 10:可以避免把len(a)算两遍 - 位运算符：把数字看成二进制来算——
&按位与、|按位或、^按位异或、~按位取反、<<左移、>>右移（例：60 & 13 = 12） - 逻辑运算符：
and（x 为假就返回 x，否则返回 y）、or（x 为真就返回 x，否则返回 y）、not（取反）；and/or返回的是参与运算的值本身，不一定是 True/False（10 and 20得20） - 成员运算符：
in（在序列里找到就返回 True）、not in（找不到才返回 True），可用于字符串、列表、元组 - 身份运算符：
is/is not比的是是不是同一个对象（相当于比id()）；==比的是值。b = a是同一个对象，b = a[:]只是值相等的新对象 - 运算符优先级（从高到低）：括号 → 索引/切片/调用/属性 →
**→ 正负号、~→*///%→+-→ 移位 →&^|→ 比较/成员/身份 →not→and→or→ 条件表达式 - 三元运算符（条件表达式）：
值1 if 条件 else 值2——条件为真取前面的值，为假取后面的值；它是个表达式（能算出结果），可以直接写在赋值和函数参数里
二、裸写题
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}")- 参考答案（做完再点开）
python# 2-1 print(f"15 + 4 = {15 + 4}") # 19 print(f"15 - 4 = {15 - 4}") # 11 print(f"15 * 4 = {15 * 4}") # 60 print(f"15 / 4 = {15 / 4}") # 3.75 print(f"15 // 4 = {15 // 4}") # 3 print(f"15 % 4 = {15 % 4}") # 3 print(f"2 ** 10 = {2 ** 10}") # 1024- 比较
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}")- 参考答案（做完再点开）
python# 2-2 print(f"10 == 10: {10 == 10}") # True print(f"10 != 5: {10 != 5}") # True print(f"10 > 5: {10 > 5}") # True print(f"10 < 5: {10 < 5}") # False print(f"10 >= 10: {10 >= 10}") # True print(f"10 <= 5: {10 <= 5}") # False- 比较
- 创建变量
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 //= ____- 参考答案（做完再点开）
python# 2-3 a = 10 print(f"初始值: a = {a}") # 10 a += 5 print(f"a += 5: {a}") # 15 a -= 3 print(f"a -= 3: {a}") # 12 a *= 2 print(f"a *= 2: {a}") # 24 a //= 3 print(f"a //= 3: {a}") # 8- 创建变量
- 测试
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}")- 参考答案（做完再点开）
python# 2-4 print(f"True and False: {True and False}") # False print(f"True or False: {True or False}") # True print(f"not True: {not True}") # False a = 10 b = 20 print(f"a and b: {a and b}") # 20（返回最后一个真值） print(f"a or b: {a or b}") # 10（返回第一个真值） print(f"not a: {not a}") # False- 测试
- 创建列表
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}")- 参考答案（做完再点开）
python# 2-5 fruits = ["苹果", "香蕉", "橘子"] print(f"'苹果' in fruits: {'苹果' in fruits}") # True print(f"'西瓜' not in fruits: {'西瓜' not in fruits}") # True print(f"'香蕉' in fruits: {'香蕉' in fruits}") # True- 创建列表
- 创建
a = [1, 2, 3]，b = a，c = a[:] - 测试
a is b、a is c、a == b、a == c - 用
id()查看内存地址
批改（2026-09-28）：✅ 正确（
a is bTrue、a is cFalse、a == b/a == cTrue；实测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)}")- 参考答案（做完再点开）
python# 2-6 a = [1, 2, 3] b = a c = a[:] print(f"a is b: {a is b}") # True（同一个对象） print(f"a is c: {a is c}") # False（不同对象） print(f"a == b: {a == b}") # True（值相等） print(f"a == c: {a == c}") # True（值相等） print(f"id(a): {id(a)}") print(f"id(b): {id(b)}") # 和 a 相同 print(f"id(c): {id(c)}") # 和 a 不同- 创建