Python运算符

你可以把运算符看作成我们日常生活中做计算或者做比较时用到的那些小动作或小符号。它们帮助我们对数据进行各种操作。

一、到底什么是运算符？

我们先从一个简单的数学题开始： 2 + 3 = 5。

  • 在这个式子中，2 和 3 是我们要计算的数字，我们给它们起个专业点的名字叫 “操作数” (就像是被“操作”的数字)。
  • 中间的 + 号，就是运算符！它告诉我们要对 2 和 3 做什么操作——这里是“相加”。
  • 最后的 5 就是这个操作的结果。

所以，运算符 就是用来对 操作数 进行某种运算处理的特殊符号。没有运算符，我们就没法让数字或其他数据进行互动

Python 语言支持以下类型的运算符：

接下里，我将一个个来介绍 Python 的运算符

算术运算符

Python 的算术运算符就像数学课本里的“+”、“-”、“×”、“÷”一样，用来对数字进行各种计算

假设我们现在有两个“盒子”（即上一部分内容中讲的变量），里面分别装着两个数字：

  • 变量 a，里面装着数字 10
  • 变量 b，里面装着数字 20

接下来，我们就用 a 和 b 作为例子，看看 Python 能帮我们做哪些数学运算。

一、最常用的加减乘除

1.1 加法 +：把两个数合起来

🌰：就像你有 a 块糖，又得到 b 块糖，现在一共有多少块？

写法：a + b

1.2 减法 -：从一个数里去掉另一个数

🌰：你有 a 块糖，给了别人 b 块，还剩多少块？或者，a 比 b 少多少？

写法：a - b

1.3 乘法 *：几个相同的数加起来

🌰：你每天吃 a 颗草莓，吃了 b 天，一共吃了多少颗？

写法：a * b （注意，乘法符号是 * 星号，不是 ×）

1.4 除法 /：把一个数平均分成几份

🌰：你有 b 颗糖，平均分给 a 个小朋友，每个小朋友能得到几颗？

写法：b / a

特别提醒：
在 Python 里，除法运算的结果通常是一个带小数点的数，我们叫它浮点数，比如 5 / 2 会得到 2.5。
但是！如果你的 Python 版本非常非常旧，比如 Python 2.x，两个整数相除（比如 5 / 2）可能会得到 2（只保留整数部分）。不过现在大家一般都用比较新的 Python 3 啦，所以放心用 / 即可

二、取余数和整除

除了上面最基本的加减乘除，Python 还有两个在数学计算中也很常用的运算符。

2.1 取模（即求余数） %：平均分完后还剩多少

🌰：你有 b 个苹果，每 a 个装一袋，能装满几袋？还会剩下几个苹果？% 就是帮我们求“剩下几个”的。

写法：b % a

结论：20 % 10 的结果是 0
再比如：7 % 3，3*2=6，7-6=1，所以结果是 1。

2.2 取整除（地板除） //：平均分完后能装满几整份

🌰：接着上面的例子，b 个苹果，每 a 个装一袋，能装满几袋？// 就是帮我们求“能装满几袋”的。只保留整数部分，而且是向下取整

写法：b // a

结论：

  • 20 // 10 的结果是 2。
  • 9 // 2：2*4=8，9-8=1，所以能装满 4 袋，结果是 4。
  • 再看一个带负数的：-9 // 2。2*(-5) = -10，-9 比 -10 大一点，所以向下取整就是 -5。这个刚开始可能有点绕，多想想向下取整

三、乘方 **

🌰：计算一个数的几次方。比如 a 的 b 次方，就是 b 个 a 相乘。

写法：a ** b （两个星号连在一起）

结论：a = 10，b = 20，a ** b 就是 10 的 20 次方。
10**2 是 10*10=100，
10**3 是 10*10*10=1000，
那 10**20 就是 1 后面跟着 20 个 0，结果是 100000000000000000000。

算术运算符表

运算符 叫什么名字 是干嘛的 简单例子 (x 和 y 是数字)
+ 加号（加法） 把 x 和 y 加起来 x + y
- 减号（减法） 用 x 减去 y x - y
* 星号（乘法） 把 x 和 y 乘起来 x * y
/ 斜杠（除法） 用 x 除以 y，结果是小数 x / y
% 百分号（取模） 用 x 除以 y，结果是剩下的余数 x % y
** 双星号（乘方） x 的 y 次方，比如 2**3 是 8 x ** y
// 双斜杠（取整除） 用 x 除以 y，结果是商的整数部分（向下取整） x // y

比较（关系）运算符

就像我们平时会比较两个苹果哪个大、两块糖哪个甜一样，在 Python 里，我们也可以比较两个数字大小、是否相等。

比较的结果只会有两种：是 或者 不是。在 Python 里，这两种结果用 True（真，表示“是”）和 False（假，表示“不是”）来表示

假设我们还是有两个变量：

  • 变量 a，里面装着数字 10
  • 变量 b，里面装着数字 20

我们就用 a 和 b 来看看能进行哪些比较。

一、判断“等于”和“不等于”

1.1 等于 ==：它们俩一样吗？

用处：判断 a 的值和 b 的值是不是完全一样。
重要：这里是两个连在一起的等号 ==，而不是一个等号 =。一个等号是用来赋值的（即，把东西放进盒子），两个等号才是用来比较是否相等的（再次强调！！！）

写法：a == b

🌰：a 是 10，b 是 20。10 和 20 一样吗？当然不一样！所以 a == b 的结果是 False。

如果 a 和 b 都是 10，那么 a == b 的结果就是 True。

1.2 不等于 !=：它们俩不一样吗？

用处：判断 a 的值和 b 的值是不是不一样。

写法：a != b

🌰：a 是 10，b 是 20。10 和 20 不一样吗？是的！所以 a != b 的结果是 True。

如果 a 和 b 都是 10，那么 a != b 的结果就是 False。

<> (了解即可，不用学)

你可能会看到一个长的像 <> 的符号，它在很久很久以前的 Python 版本（比如 Python 2.x）里也是表示“不等于”，和 != 一样。但是现在的 Python 3 版本已经不用它了，所以我们只需要记住 != 即可

二、判断大小

2.1 大于 >：左边的比右边的大吗？

用处：判断 a 的值是不是大于 b 的值。

写法：a > b

🌰：a 是 10，b 是 20。10 大于 20 吗？10 > 20？不是的！所以结果是 False。
反过来，如果问 b > a （20 > 10），那结果就是 True。

2.2 小于 <：左边的比右边的小吗？

用处：判断 a 的值是不是小于 b 的值。

写法：a < b

🌰：a 是 10，b 是 20。10 小于 20 吗？10 < 20？是的！所以结果是 True。
反过来，如果问 b < a （20 < 10），那结果就是 False。

2.3 大于等于 >=：左边的比右边的大，或者一样大吗？

用处：判断 a 的值是不是大于或者等于 b 的值。只要满足其中一个条件，结果就是 True。

写法：a >= b

🌰：

  • a 是 10，b 是 20。10 大于等于 20 吗？10 >= 20？10 既不大于 20，也不等于 20，所以结果是 False。
  • 如果 a 是 20，b 是 20。20 >= 20？等于，所以结果是 True。
  • 如果 a 是 25，b 是 20。25 >= 20？大于，所以结果是 True。

2.4 小于等于 <=：左边的比右边的小，或者一样小吗？

用处：判断 a 的值是不是小于或者等于 b 的值。只要满足其中一个条件，结果就是 True。

写法：a <= b

🌰：

  • a 是 10，b 是 20。10 小于等于 20 吗？10 <= 20？是的，10 小于 20，所以结果是 True。
  • 如果 a 是 20，b 是 20。20 <= 20？等于，所以结果是 True。
  • 如果 a 是 25，b 是 20。25 <= 20？25 比 20 大，所以结果是 False。

比较运算符表

运算符 名字 描述（以 a 和 b 为例） 例子 (a=10, b=20) 结果 (True/False)
== 等于 a 的值是否等于 b 的值？ 10 == 20 False
!= 不等于 a 的值是否不等于 b 的值？ 10 != 20 True
> 大于 a 的值是否大于 b 的值？ 10 > 20 False
< 小于 a 的值是否小于 b 的值？ 10 < 20 True
>= 大于等于 a 的值是否大于或等于 b 的值？ 10 >= 20 False
<= 小于等于 a 的值是否小于或等于 b 的值？ 10 <= 20 True
<> 不等于 (旧写法，同 !=，Python 3 已弃用) 10 <> 20 True (古老版本)

赋值运算符

赋值 听起来有点专业，其实很简单，就是 把一个值放到一个变量里 的过程。就像你把一颗糖放进标着自己名字的小盒子里一样

我们已经知道，= 这个等号就是最基本的赋值运算符。比如 a = 10，就是把数字 10 放进了叫做 a 的这个“盒子”里。

除了简单的 =，Python 还有一些复合赋值运算符，它们能把运算和赋值这两步操作合并成一步，写起来更简洁

我们还是用两个变量来举例（但是，具体的值会根据例子变化）：

  • 变量 a
  • 变量 c (以下内容，我们主要用 c 来演示各种赋值操作)

一、最基本的赋值：=

1.1 =：把右边的值，放到左边的变量里

用处：这是最常用的赋值运算符。它的意思是：把等号右边计算得到的结果，存放到等号左边的变量里。

写法：变量 = 表达式 在这里，表达式可以是一个数字，或者一个计算式

举例：

1
2
3
4
a = 10      # 把数字 10 放进变量 a 这个盒子里。现在 a 里面是 10。
b = 20      # 把数字 20 放进变量 b 这个盒子里。现在 b 里面是 20。
c = a + b   # 先计算 a + b (10 + 20 = 30)，然后把结果 30 放进变量 c 这个盒子里。现在 c 里面是 30。
print("c 的值为：", c)  # 打印 c，会显示 30。

记住：等号 = 在这里不是等于的意思（比较相等我们用 ==），而是赋值。比如 c = a + b，读作“把 a 加 b 的结果赋值给 c”

二、复合赋值运算符

假设现在变量 c 里面已经有一个值了。如果我们想对 c 里面的这个值进行一些运算，比如加、减、乘、除某个数，然后再把新的结果放回到 c 里面，该怎么做呢？

比如，c 现在是 10，我们想让 c 加上 5，然后还是存回 c。
普通写法是：c = c + 5。
用复合赋值运算符，可以写成：c += 5。是不是更简洁？

下面我们就来看看这些复合赋值运算符：

2.1 +=：加法赋值 (先加后存)

用处：c += a 等效于 c = c + a。
意思是：把变量 c 现在的值，加上 a 的值，然后把得到的新结果再存回 c 里。

举例：
假设 c 现在是 31 ，a 是 21。

1
2
c += a   # 相当于 c = c + a → c = 31 + 21 = 52
print("c 的值为：", c)  # 现在 c 是 52

2.2 -=：减法赋值 (先减后存)

用处：c -= a 等效于 c = c - a。
意思是：把变量 c 现在的值，减去 a 的值，然后把得到的新结果再存回 c 里。

举例：
假设 c 现在是 52，a 是 21。

1
2
c -= a   # 相当于 c = c - a → c = 52 - 21 = 31
print("c 的值为：", c)  # 现在 c 是 31

2.3 *=：乘法赋值 (先乘后存)

用处：c *= a 等效于 c = c * a。
意思是：把变量 c 现在的值，乘以 a 的值，然后把得到的新结果再存回 c 里。

举例：
假设 c 现在是 52 (接上面 += 的例子)，a 是 21。

1
2
c *= a   # 相当于 c = c * a → c = 52 * 21 = 1092
print("c 的值为：", c)  # 现在 c 是 1092

2.4 /=：除法赋值 (先除后存)

用处：c /= a 等效于 c = c / a。
意思是：把变量 c 现在的值，除以 a 的值，然后把得到的新结果再存回 c 里。 (结果通常是默认为浮点数)

举例：
假设 c 现在是 1092 (接上面 *= 的例子)，a 是 21。

1
2
c /= a   # 相当于 c = c / a → c = 1092 / 21 = 52.0 (在 Python 3 里会得到 52.0)
print("c 的值为：", c)  # 现在 c 是 52.0 (如果 a 和 c 是整数，结果可能带小数点)

2.5 %=：取模赋值 (先取余后存)

用处：c %= a 等效于 c = c % a。
意思是：把变量 c 现在的值，对 a 的值进行取模运算，然后把得到的新结果再存回 c 里。

举例：
现在，我们重新给 c 赋值， c 现在是 2 ，a 是 21。

1
2
3
c = 2    # 现在 c 里面是 2
c %= a   # 相当于 c = c % a → c = 2 % 21。2 除以 21 商 0 余 2，所以结果是 2。
print("c 的值为：", c)  # 现在 c 是 2

再比如：如果 c = 25，a = 10，那么 c %= a 就是 25 % 10 = 5，之后 c 就是 5。

2.6 **=：幂赋值 (先乘方后存)

用处：c **= a 等效于 c = c** a。
意思是：把变量 c 现在的值，作为底数，a 的值作为指数进行乘方运算，然后把得到的新结果再存回 c 里。

举例：
假设 c 现在是 2，a 是 21 (哇，2 的 21 次方是个大数字！)。

1
2
3
c = 2    # 现在 c 里面是 2
c **= a  # 相当于 c = c **a → c = 2** 21。2 的 21 次方是 2097152。
print("c 的值为：", c)  # 现在 c 是 2097152

2.7 //=：取整除赋值 (先整除后存)

用处：c //= a 等效于 c = c // a。
意思是：把变量 c 现在的值，除以 a 的值，然后对结果进行向下取整（取整除），再把得到的新结果存回 c 里。

举例：
假设 c 现在是 2097152 (接上面 **= 的例子)，a 是 21。

1
2
3
c //= a   # 相当于 c = c // a → c = 2097152 // 21
          # 21 * 99864 = 2097144，2097152 - 2097144 = 8，所以商是 99864。
print("c 的值为：", c)  # 现在 c 是 99864

赋值运算符表

运算符 名称 例子 (假设 c 初始值为 10, a=5) 等效于 运算后 c 的值
= 赋值 c = a c = a 5
+= 加法赋值 c += a c = c + a 10 + 5 = 15
-= 减法赋值 c -= a c = c - a 10 - 5 = 5
*= 乘法赋值 c *= a c = c * a 10 * 5 = 50
/= 除法赋值 c /= a c = c / a 10 / 5 = 2.0
%= 取模赋值 c %= a c = c % a 10 % 5 = 0
**= 幂赋值 c **= a c = c** a 10^5 = 100000
//= 取整除赋值 c //= a c = c // a 10 // 5 = 2

逻辑运算符

现在设想一下，你和朋友约好周末出去玩，可能会有这样的对话：

  1. “如果明天天气好并且我作业写完了，我们就去公园。” → 两个条件都要满足才行！
  2. “如果明天下雨或者我生病了，我们就不去了。” → 只要有一个条件满足就不去。
  3. “不是因为我不想去，而是因为我有事。” → 否定一个条件。

这些“并且”、“或者”、“不是”，在 Python 中就是逻辑运算符的作用！它们连接多个条件（通常是比较运算的结果，比如 a > b，x == 5 等），最终得到一个 True（真）或 False（假）的结果。

Python 有三个逻辑运算符：and（与）、or（或）、not（非）。

一、and：并且（两个条件都要满足）

1.1 and 运算符（逻辑与）

逻辑表达式：条件1 and 条件2

描述：

  • 如果 条件1 是 False（假），那么整个表达式直接返回 False（因为，“并且”需要两个都真，一个假了整体就假了）。
  • 如果 条件1 是 True（真），那么整个表达式的结果就取决于 条件2：条件2 是 True 就返回 True，条件2 是 False 就返回 False。

生活例子：

  • 你能玩游戏的条件：(作业写完了) and (妈妈同意了)。两个条件都满足才能玩。
  • 如果作业没写完（条件1 False），不管妈妈同不同意，都不能玩（整体 False）。
  • 如果作业写完了（条件1 True），那就看妈妈是否同意（条件2）：妈妈同意（True）→ 能玩；妈妈不同意（False）→ 不能玩。

Python 实例（用数字代替条件理解）：
在 Python 中，0 代表 False，非 0 数字代表 True。我们先看一个简单的例子，假设 a = 10（True），b = 20（True）：

1
2
3
4
5
6
7
8
9
a = 10  # 非0 → True
b = 20  # 非0 → True

# (a and b)：因为 a 是 True，所以结果是 b 的值（20，代表 True）
print("a and b 的结果:", a and b)  # 输出 20（实际逻辑结果是 True，但这里返回了 b 的值，后面会解释）

# 如果 a 是 0（False）：
a = 0
print("0 and b 的结果:", a and b)  # 输出 0（因为 a 是 False，整体直接返回 False，即 0）

1.2 在条件判断中使用 and（更常用！）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
a = 10
b = 20

# 判断 a 是否大于 5 并且 b 是否大于 15
if a > 5 and b > 15:
    print("1 - 变量 a 和 b 都满足条件（a>5 并且 b>15）")  # a>5 (True), b>15 (True) → 整体 True
else:
    print("1 - 变量 a 和 b 至少有一个不满足条件")

# 修改 a 为 3
a = 3
if a > 5 and b > 15:
    print("2 - 变量 a 和 b 都满足条件")
else:
    print("2 - 变量 a 和 b 至少有一个不满足条件")  # a>5 (False), 所以整体 False

输出：

1
2
1 - 变量 a 和 b 都满足条件（a>5 并且 b>15）
2 - 变量 a 和 b 至少有一个不满足条件

二、or：或者（满足一个条件就行）

2.1 or 运算符（逻辑或）

逻辑表达式：条件1 or 条件2

描述：

  • 如果 条件1 是 True（真），那么整个表达式直接返回 True（因为，“或者”只要有一个真就行）。
  • 如果 条件1 是 False（假），那么整个表达式的结果就取决于 条件2：条件2 是 True 就返回 True，条件2 是 False 就返回 False。

实际例子：

  • 你不能上学的条件：(生病了) or (下雨了)。只要满足一个就不能上学。
  • 如果你生病了（条件1 True），不管下不下雨，都不能上学（整体 True）。
  • 如果你没生病（条件1 False），那就看是否下雨（条件2）：下雨（True）→ 不能上学；不下雨（False）→ 能上学。

Python 实例（用数字代替条件理解）：
a = 10（True），b = 20（True）：

1
2
3
4
5
6
7
8
9
a = 10  # True
b = 20  # True

# (a or b)：因为 a 是 True，所以结果是 a 的值（10，代表 True）
print("a or b 的结果:", a or b)  # 输出 10

# 如果 a 是 0（False）：
a = 0
print("0 or b 的结果:", a or b)  # 输出 20（因为 a 是 False，所以看 b，b 是 True，返回 b 的值）

2.2 在条件判断中使用 or（更常用！）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
a = 10
b = 20

# 判断 a 是否小于 5 或者 b 是否小于 15
if a < 5 or b < 15:
    print("3 - 变量 a 和 b 至少有一个满足条件（a<5 或者 b<15）")
else:
    print("3 - 变量 a 和 b 都不满足条件")  # a<5 (False), b<15 (False) → 整体 False

# 修改 a 为 3
a = 3
if a < 5 or b < 15:
    print("4 - 变量 a 和 b 至少有一个满足条件")  # a<5 (True) → 整体 True
else:
    print("4 - 变量 a 和 b 都不满足条件")

输出：

1
2
3 - 变量 a 和 b 都不满足条件
4 - 变量 a 和 b 至少有一个满足条件

三、not：不是（否定一个条件）

3.1 not 运算符（逻辑非）

逻辑表达式：not 条件

描述：

  • 如果 条件 是 True（真），那么 not 条件 就返回 False（假）。
  • 如果 条件 是 False（假），那么 not 条件 就返回 True（真）。

生活例子：

  • “今天不是晴天。” → 如果今天是晴天（True），那么这句话就是 False；如果今天不是晴天（False），这句话就是 True。
  • “我不是不想去。” → 如果“我不想去”是 True，那么这句话就是 False（其实我想去）。

Python 实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
a = 10  # True

# not a：a 是 True，所以 not a 是 False
print("not a 的结果:", not a)  # 输出 False

b = 0  # False
print("not b 的结果:", not b)  # 输出 True（因为 b 是 False，not b 就是 True）

# 在条件判断中
if not (a > 20):  # a>20 是 False，not False 是 True
    print("5 - a 不大于 20")  # 会执行这句
else:
    print("5 - a 大于 20")

输出：

1
2
3
not a 的结果: False
not b 的结果: True
5 - a 不大于 20

四、综合实例

现在我们来看你提供的完整示例代码，理解逻辑运算符在条件判断中的应用。

已知：初始 a = 10（非0 → True），b = 20（非0 → True）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
a = 10
b = 20

# 1. 判断 a 和 b 是否都为 True（非0即True）
if a and b:  # a 是 True，b 是 True → True and True = True
    print("1 - 变量 a 和 b 都为 True")
else:
    print("1 - 变量 a 和 b 有一个不为 True")

# 2. 判断 a 或 b 是否为 True
if a or b:  # a 是 True → True or ... = True
    print("2 - 变量 a 和 b 都为 True，或其中一个变量为 True")
else:
    print("2 - 变量 a 和 b 都不为 True")

# 修改 a 的值为 0（0 代表 False）
a = 0

# 3. 再次判断 a 和 b 是否都为 True
if a and b:  # a 是 False → False and ... = False
    print("3 - 变量 a 和 b 都为 True")
else:
    print("3 - 变量 a 和 b 有一个不为 True")  # 执行这句

# 4. 再次判断 a 或 b 是否为 True
if a or b:  # a 是 False，但 b 是 True → False or True = True
    print("4 - 变量 a 和 b 都为 True，或其中一个变量为 True")  # 执行这句
else:
    print("4 - 变量 a 和 b 都不为 True")

# 5. 判断 not (a and b) 的结果
if not (a and b):  # a and b 是 False → not False = True
    print("5 - 变量 a 和 b 都为 False，或其中一个变量为 False")  # 执行这句
else:
    print("5 - 变量 a 和 b 都为 True")

输出结果和示例完全一样：

1
2
3
4
5
1 - 变量 a 和 b 都为 True
2 - 变量 a 和 b 都为 True，或其中一个变量为 True
3 - 变量 a 和 b 有一个不为 True
4 - 变量 a 和 b 都为 True，或其中一个变量为 True
5 - 变量 a 和 b 都为 False，或其中一个变量为 False

五、逻辑运算符的“短路特性”

逻辑运算符有个有趣的“短路”特性，当然，只对 and 和 or 有效。但它可以帮助我们理解它们的执行过程：

5.1 and 的短路：

  • 如果第一个条件是 False，后面的条件不会执行（因为整体已经是 False 了，没必要看后面）。
    1
    print(0 and (1/0))  # 输出 0，不会报错！因为 0 是 False，后面的 1/0（除零错误）不会执行。

5.2 or 的短路：

  • 如果第一个条件是 True，后面的条件不会执行（因为整体已经是 True 了，没必要看后面）。
    1
    print(10 or (1/0))  # 输出 10，不会报错！因为 10 是 True，后面的 1/0 不会执行。

逻辑运算符表

运算符 逻辑表达式 描述（条件版） 描述（数字版，0=False，非0=True） 例子（a=10, b=20, c=0）
and 条件1 and 条件2 两个条件都为 True，结果才为 True；否则 False。 若第一个数是 0，返回 0；否则返回第二个数。 a and b → 20，c and a → 0
or 条件1 or 条件2 至少一个条件为 True，结果就为 True；都为 False 才返回 False。 若第一个数非0，返回第一个数；否则返回第二个数。 a or b → 10，c or a → 10
not not 条件 条件为 True，结果为 False；条件为 False，结果为 True。 非0数返回 False；0 返回 True。 not a → False，not c → True

最重要的是理解并且、或者、不是的逻辑，在条件判断（if 语句）中非常常用！多结合生活例子想想，很快就能掌握啦！加油！

位运算符

在此之前，我们计算用的都是 十进制（0,1,2,…,9,10,11…）。而位运算，是直接对数字的二进制（0 和 1）形式进行操作的。就像我们拼积木，这次我们是一小块一小块（地拼

别担心，我会从最基础的二进制概念开始

预备知识：什么是二进制？

我们日常用的是十进制，满 10 进 1。
二进制 是计算机最喜欢的计数方式，因为它只有 0 和 1 两个数字，满 2 就进 1。

  • 十进制的 1 → 二进制 1
  • 十进制的 2 → 二进制 10 (因为 1*2 + 0 = 2)
  • 十进制的 3 → 二进制 11 (1*2 + 1 = 3)
  • 十进制的 4 → 二进制 100 (14 + 02 + 0 =4)
  • …以此类推。

我们今天的例子会用到：

  • 变量 a = 60 → 它的二进制是 0011 1100 (为了方便看，我们写成 8 位)
  • 变量 b = 13 → 它的二进制是 0000 1101

一、按位与 & (AND)：全 1 才得 1，有 0 就为 0

1.1 & 运算符：对二进制的每一位进行“与”操作

规则（很重要，记下来！）：
当两个二进制位都为 1 时，结果位才是 1；否则，结果位就是 0。
可以想像成“并且”：两位都得是 1，结果才是 1。

1
2
3
4
0 & 0 = 0
0 & 1 = 0
1 & 0 = 0
1 & 1 = 1  ✔️ 只有这个是 1

实例：计算 a & b，其中 a=60 (0011 1100)，b=13 (0000 1101)

我们把二进制上下对齐，逐位进行 & 操作：

1
2
3
4
    a:  0011 1100
    b:  0000 1101
  &----------------
结果:  0000 1100   (这就是二进制的 12)

所以：a & b = 12

二、按位或 | (OR)：有 1 就为 1，全 0 才得 0

2.1 | 运算符：对二进制的每一位进行“或”操作

规则（记下来！）：
当两个二进制位中有一个为 1 时，结果位就是 1；只有两个都为 0，结果位才是 0。
可以想像成“或者”：只要有一个是 1，结果就是 1。

1
2
3
4
0 | 0 = 0
0 | 1 = 1  ✔️
1 | 0 = 1  ✔️
1 | 1 = 1  ✔️

实例：计算 a | b，其中 a=60 (0011 1100)，b=13 (0000 1101)

逐位进行 | 操作：

1
2
3
4
    a:  0011 1100
    b:  0000 1101
  |----------------
结果:  0011 1101   (这就是二进制的 61)

所以：a | b = 61

三、按位异或 ^ (XOR)：不同为 1，相同为 0

3.1 ^ 运算符：对二进制的每一位进行“异或”操作

规则（记下来！）：
当两个二进制位不一样时（一个 0，一个 1），结果位就是 1；如果一样（都是 0 或都是 1），结果位就是 0。
可以理解为“找不同”：不一样才是 1。

1
2
3
4
0 ^ 0 = 0  (相同)
0 ^ 1 = 1  (不同) ✔️
1 ^ 0 = 1  (不同) ✔️
1 ^ 1 = 0  (相同)

实例：计算 a ^ b，其中 a=60 (0011 1100)，b=13 (0000 1101)

逐位进行 ^ 操作：

1
2
3
4
    a:  0011 1100
    b:  0000 1101
  ^----------------
结果:  0011 0001   (这就是二进制的 49)

所以：a ^ b = 49

四、按位取反 ~ (NOT)：0 变 1，1 变 0 (也叫单目运算符)

4.1 ~ 运算符：对二进制的每一位进行“取反”操作

规则（记下来！）：
把二进制位中的 0 变成 1，1 变成 0。
它只有一个操作数（不像 & 需要两个数）。

举例：~a，其中 a=60 (0011 1100)

首先对 a 的每一位取反：
0011 1100 → 取反后 1100 0011。

但这里有个难点：在计算机中，数字通常用补码表示，最高位是符号位（0 正，1 负）。
所以 ~a 的结果计算方式简单记为：-a - 1。

对 a=60：~60 = -60 -1 = -61。

所以：~a = -61

五、左移 <<：二进制位整体向左移

5.1 << 运算符：将一个数的二进制位全部向左移动指定的位数

规则：

  • 左边（高位）溢出的二进制位会被丢弃。
  • 右边（低位）空出来的位置用 0 补齐。
  • 效果相当于：a << n → a * (2的n次方)

实例：计算 a << 2，a=60 (0011 1100)

向左移动 2 位：
原来：0011 1100
左移1位：0111 1000 (末尾补一个 0)
左移2位：1111 0000 (末尾再补一个 0)

这个二进制 1111 0000 等于十进制的 240。
也可以算：60 * (2^2) = 60 *4=240。

所以：a << 2 = 240

六、右移 >>：二进制位整体向右移

6.1 >> 运算符：将一个数的二进制位全部向右移动指定的位数

规则：

  • 右边（低位）溢出的二进制位会被丢弃。
  • 左边（高位）空出来的位置，对于正数用 0 补齐，对于负数不同语言处理方式可能不同（Python 用 0 补齐）。
  • 效果相当于：a >> n → a // (2的n次方) (整除)

实例：计算 a >> 2，a=60 (0011 1100)

向右移动 2 位：
原来：0011 1100
右移1位：0001 1110 (丢弃最右边一位，左边补 0)
右移2位：0000 1111 (再丢弃最右边一位，左边补 0)

这个二进制 0000 1111 等于十进制的 15。
也可以算：60 // (2^2) = 60 //4=15。

所以：a >> 2 = 15

位运算符表

运算符 名称 规则 简单记法 (对正数) 例子 (a=60, b=13) 结果
& 按位与 两位都为 1，结果才为 1 60 & 13 12
` ` 按位或 两位有一个为 1，结果就为 1 `60
^ 按位异或 两位不同为 1，相同为 0 60 ^ 13 49
~ 按位取反 0 变 1，1 变 0 ~a = -a - 1 ~60 -61
<< 左移 向左移 n 位，右边补 0 a << n = a * (2^n) 60 << 2 240
>> 右移 向右移 n 位，左边补 0 (正数)，右边丢弃 a >> n = a // (2^n) 60 >> 2 15

为什么要学位运算？

位运算执行速度快，在底层编程、图形处理、加密算法等领域非常常用。虽然平时可能不天天用，但了解它能帮助你理解计算机的基本工作方式

成员运算符

现在，你去参加一个生日派对，门口有个 list（名单），上面写着所有被邀请人的名字。你想知道自己能不能进去，就要看你的名字在不在这个名单上。这里的在不在，就是成员运算符要解决的问题

在 Python 中，我们把像“名单”这样的东西叫做“序列”（sequence），比如我们之前提到过的 列表(list)，还有以后会学到的字符串(str)、元组(tuple) 等等。成员运算符就是用来判断一个元素是不是这个“序列”里的一员。

Python 有两个成员运算符：in 和 not in。

一、in 它在里面吗？

1.1 in：判断某个元素是否是序列中的成员

用处：如果 左边的元素 是 右边序列，比如列表、字符串、元组等等里的一员，就返回 True（是），否则返回 False（不是）。

写法：元素 in 序列

生活例子：

  • 你的名字是“小明”，派对名单是 ["小红", "小刚", "小明"]。那么 小明 in 名单 → True（可以进去！）。
  • 如果名单是 ["小红", "小刚"]，那么 小明 in 名单 → False 不能进去

Python 实例：
假设我们有一个列表 list = [1, 2, 3, 4, 5]就像派对名单，里面有数字 1 到 5
变量 a = 10（比如“小明”）。

1
2
3
4
5
6
7
a = 10
list = [1, 2, 3, 4, 5]

if (a in list):  # 判断 a (10) 是不是 list 里的成员？
    print("1 - 变量 a 在给定的列表中 list 中")  # 如果是，打印这个
else:
    print("1 - 变量 a 不在给定的列表中 list 中")  # 如果不是，打印这个

结果是什么？
list 里面是 [1,2,3,4,5]，a 是 10。10 不在 list 里，所以会打印：
1 - 变量 a 不在给定的列表中 list 中

二、not in：它不在里面吗？

2.1 not in：判断某个元素是否不是序列中的成员

用处：如果 左边的元素 不是 右边序列 里的一员，就返回 True（是），否则返回 False（不是）。
它刚好和 in 的结果相反。

写法：元素 not in 序列

实际例子：

  • 你的名字是“小明”，派对名单是 ["小红", "小刚"]。那么 小明 not in 名单 → True
  • 如果名单上有“小明”，那么 小明 not in 名单 → False

Python 实例：
还是用上面的列表 list = [1, 2, 3, 4, 5]，变量 b = 20。

1
2
3
4
5
6
7
b = 20
list = [1, 2, 3, 4, 5]

if (b not in list):  # 判断 b (20) 是不是不在 list 里？
    print("2 - 变量 b 不在给定的列表中 list 中")  # 如果不在，打印这个
else:
    print("2 - 变量 b 在给定的列表中 list 中")  # 如果在，打印这个

结果是什么？
20 肯定不在 [1,2,3,4,5] 里，所以 b not in list 是 True，会打印：
2 - 变量 b 不在给定的列表中 list 中

三、再试一次：如果元素在里面呢？

我们修改一下 a 的值，让它变成 2（2 是 list [1,2,3,4,5] 里的成员）。

1
2
3
4
5
a = 2  # 修改变量 a 的值为 2
if (a in list):
    print("3 - 变量 a 在给定的列表中 list 中")
else:
    print("3 - 变量 a 不在给定的列表中 list 中")

现在结果是什么？
2 在 list 里，所以 a in list 是 True，会打印：
3 - 变量 a 在给定的列表中 list 中

四、综合实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
a = 10
b = 20
list = [1, 2, 3, 4, 5]  # 这是一个列表，里面有 1,2,3,4,5 这几个成员

# 检查 a (10) 是否在 list 里
if (a in list):
    print("1 - 变量 a 在给定的列表中 list 中")
else:
    print("1 - 变量 a 不在给定的列表中 list 中")  # 10 不在，所以打印这个

# 检查 b (20) 是否不在 list 里
if (b not in list):
    print("2 - 变量 b 不在给定的列表中 list 中")  # 20 不在，所以打印这个
else:
    print("2 - 变量 b 在给定的列表中 list 中")

# 修改 a 的值为 2
a = 2
# 再检查 a (2) 是否在 list 里
if (a in list):
    print("3 - 变量 a 在给定的列表中 list 中")  # 2 在，所以打印这个
else:
    print("3 - 变量 a 不在给定的列表中 list 中")

运行上面的代码，输出结果和示例完全一样：

1
2
3
1 - 变量 a 不在给定的列表中 list 中
2 - 变量 b 不在给定的列表中 list 中
3 - 变量 a 在给定的列表中 list 中

五、字符串和元组的应用

成员运算符不止能用于列表，还能用于字符串和元组

5.1 字符串示例：

1
2
3
4
s = "Hello, World!"
print('H' in s)      # 'H' 是不是在 "Hello, World!" 里？ → True
print('x' in s)      # 'x' 是不是在里面？ → False
print('llo' in s)    # 'llo' 这个子字符串是不是在里面？ → True (因为 "Hello" 里有 "llo")

5.2 元组示例：

1
2
3
t = (10, 20, 30)
print(20 in t)       # 20 是不是在元组里？ → True
print(40 not in t)   # 40 是不是不在元组里？ → True

成员运算符表

运算符 描述 例子 (list = [1,2,3,4,5]) 结果
in 如果元素在序列中，返回 True 2 in list True
in 如果元素不在序列中，返回 False 10 in list False
not in 如果元素不在序列中，返回 True 10 not in list True
not in 如果元素在序列中，返回 False 2 not in list False

身份运算符

生活中有这样的情况：

  1. 你有一个双胞胎弟弟/妹妹，你们长得一模一样（用python话来说，值相等），但你们是两个人（身份不同）。
  2. 你穿了一件红色的衣服，这件衣服和你是同一个人吗？当然不是！衣服只是你身上的东西（值）。
  3. “你”这个个体，无论今天穿什么衣服（值怎么变），“你”的身份是独一无二的。

在 Python 中，每个对象（就像“人”）都有一个独一无二的“身份证号”——内存地址（可以用 id() 函数查看）。身份运算符就是用来比较两个变量是不是指向同一个对象（即，
身份证号是否相同）。

Python 有两个身份运算符：is 和 is not。

一、is：它们是不是同一个对象？

1.1 is：判断两个变量是否引用同一个对象

用处：如果 左边变量 和 右边变量 指向的是内存中的同一个对象（即，它们的身份证号id 相同），就返回 True（是），否则返回 False（不是）。

写法：变量1 is 变量2

生活例子：

  • 你叫“小明”，你的双胞胎弟弟也叫“小明”（假设）。小明(你) is 小明(弟弟) → False（你们是两个人，虽然名字和长相一样）。
  • 你指着镜子里的自己说：“这就是我”。我 is 镜子里的我 → True（都是你自己）。

Python 实例：
我们先看一个简单的例子：

1
2
3
4
5
6
7
8
9
10
a = 20  # 把数字 20 放进变量 a 这个“盒子”里。a 指向内存中存储 20 的那个对象。
b = 20  # 把数字 20 放进变量 b 这个“盒子”里。b 指向哪里呢？

print("a 的内存地址:", id(a))  # 查看 a 的“身份证号”
print("b 的内存地址:", id(b))  # 查看 b 的“身份证号”

if (a is b):
    print("a 和 b 是同一个对象")
else:
    print("a 和 b 不是同一个对象")

结果是什么？
在 Python 中，对于一些简单的小整数（如 -5 到 256），为了提高效率，会被“缓存”起来。所以 a=20 和 b=20，Python 可能会让它们指向同一个内存地址。因此：
a 的内存地址 和 b 的内存地址 会相同，a is b → True。

所以会打印：
a 和 b 有相同的标识 (即“a 和 b 是同一个对象”)

二、is not：它们是不是不同的对象？

2.1 is not：判断两个变量是否引用不同的对象

用处：如果 左边变量 和 右边变量 指向的是内存中的不同对象（即它们的“身份证号”id 不同），就返回 True（是不同的），否则返回 False（是同一个）。

写法：变量1 is not 变量2

实际例子：

  • 你和你的好朋友。你 is not 好朋友 → True（你们是不同的人）。
  • 你和你自己。你 is not 你 → False（就是同一个人）。

Python 实例：
接着上面的例子，我们修改 b 的值：

1
2
3
4
5
6
7
8
9
10
11
12
a = 20
b = 20

# 前面 a is b → True

b = 30  # 现在 b 指向了新的对象（数字 30）
print("修改后 b 的内存地址:", id(b))  # 新的“身份证号”

if (a is not b):
    print("a 和 b 不是同一个对象")
else:
    print("a 和 b 是同一个对象")

结果：
现在 a 指向 20，b 指向 30，它们的内存地址肯定不同了。所以 a is not b → True，会打印：
a 和 b 没有相同的标识 (即，a 和 b 不是同一个对象)

三、综合实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
a = 20
b = 20

# 1. 判断 a 和 b 是否是同一个对象
if (a is b):
    print("1 - a 和 b 有相同的标识")  # 如果是，打印这个
else:
    print("1 - a 和 b 没有相同的标识")

# 2. 判断 a 和 b 是否不是同一个对象
if (a is not b):
    print("2 - a 和 b 没有相同的标识")
else:
    print("2 - a 和 b 有相同的标识")  # 因为 a 和 b 现在还是同一个对象，所以打印这个

# 修改变量 b 的值为 30
b = 30

# 3. 再次判断 a 和 b 是否是同一个对象
if (a is b):
    print("3 - a 和 b 有相同的标识")
else:
    print("3 - a 和 b 没有相同的标识")  # 现在 b 指向了 30，所以打印这个

# 4. 再次判断 a 和 b 是否不是同一个对象
if (a is not b):
    print("4 - a 和 b 没有相同的标识")  # 现在它们不是同一个对象了，所以打印这个
else:
    print("4 - a 和 b 有相同的标识")

运行结果和示例完全一样：

1
2
3
4
1 - a 和 b 有相同的标识
2 - a 和 b 有相同的标识
3 - a 和 b 没有相同的标识
4 - a 和 b 没有相同的标识

四、is vs == (身份 vs 值)

这是初学者最容易混淆的两个概念！一定要分清楚：

is (身份运算符) == (比较运算符)
判断 两个变量是否指向同一个对象（内存地址是否相同） 判断 两个变量指向的对象的值是否相等
看“身份证号”是否一样 看“长得像不像”
例子：双胞胎（== True，is False） 例子：双胞胎（== True，is False）

4.1 经典例子：列表的复制

1
2
3
4
5
6
7
8
9
10
11
a = [1, 2, 3]  # a 指向一个列表 [1,2,3]
b = a          # b 也指向 a 指向的那个列表（同一个对象！）

print(b == a)  # b 的值和 a 的值一样吗？ → True
print(b is a)  # b 和 a 是同一个对象吗？ → True (id(a) == id(b))

# 现在，我们用切片创建一个新列表赋值给 b (切片会创建新对象)
b = a[:]       # a[:] 是 a 列表的一个副本，b 指向这个新副本

print(b == a)  # 新副本的值还是 [1,2,3]，和 a 一样吗？ → True
print(b is a)  # 现在 b 和 a 还是同一个对象吗？ → False (id(a) != id(b)，它们是两个不同的列表，只是长得一样)

输出：

1
2
3
4
True
True
True
False

这个例子完美说明了：== 只关心值是否相等，is 关心是否是同一个对象。

身份运算符表

运算符 描述 例子 (a 和 b 指向同一对象) 例子 (a 和 b 指向不同对象)
is 如果是同一个对象，返回 True a is b → True a is b → False
is not 如果不是同一个对象，返回 True a is not b → False a is not b → True

如何查看内存地址？
用 id() 函数：id(a) 返回 a 指向的对象的内存地址。

1
2
3
4
5
6
a = 20
b = 20
print(id(a))   # 比如：140708432563296
print(id(b))   # 比如：140708432563296 (可能和 a 一样，因为小整数缓存)
b = 30
print(id(b))   # 比如：140708432563616 (和 a 不一样了)

运算符优先级

当一个表达式里有多个运算符时，先算哪个，后算哪个？

比如数学题：1 + 2 × 3，答案是 7 而不是 9，因为我们规定先乘除后加减。这就是优先级的概念

Python 里的运算符也有自己的优先级排行榜。优先级高的运算符会先动手，优先级低的会后动手。如果优先级一样，就按从左到右的顺序算，但少数运算符如 ** 是从右到左

不过，优先级表那么长，记不住怎么办？没关系！最重要的规则是：不确定就用括号 ()，括号里的运算永远最先算！

一、一个生活例子：早上出门的“优先级”

你可以设想，你早上出门前要做这些事：

  1. 穿衣服（必须先穿，不然光着身子）
  2. 刷牙洗脸（可以在穿衣服后）
  3. 吃早餐（可以在刷牙后）
  4. 背书包出门（最后做）

这就是生活中的优先级：穿衣服 > 刷牙洗脸 > 吃早餐 > 背书包。

在 Python 中，运算符也有这样的先后顺序

二、最常用的优先级（记住这几个就够应付大部分情况！）

我们从高到低列出一些最常用的运算符优先级（越上面越先算）：

优先级顺序 (高→低) 运算符类型 举例 解释
1 (最高) ** 指数（乘方） 2**3 (2的3次方) 先算乘方
2 * / % // 3*4 10/2 乘、除、取模（余数）、取整除
3 + - 5+6 10-3 加、减
（括号随时可用） () 括号 (1+2)*3 括号里的永远最先算，优先级最高！

记住这个口诀（和数学一样）：
先算括号内，再算乘方，然后乘除，最后加减。

三、实例分析：为什么结果不一样？

我们来看你提供的例子，理解优先级和括号的作用。

已知：a=20, b=10, c=15, d=5

3.1 例子 1：(a + b) * c / d

1
e = (a + b) * c / d  # a=20, b=10, c=15, d=5

分析：

  1. 先算括号里的 a + b → 20 + 10 = 30
  2. 再算 * c → 30 * 15 = 450
  3. 最后算 / d → 450 / 5 = 90
    结果：90

3.2 例子 2：((a + b) * c) / d

1
e = ((a + b) * c) / d

分析：
括号多了几层，但运算顺序和例子 1 一样：

  1. 最内层 a + b = 30
  2. 中间层 30 * 15 = 450
  3. 最外层 450 /5 =90
    结果：90（和例子 1 一样，因为括号只是明确了顺序，没改变顺序）

3.3 例子 3：(a + b) * (c / d)

1
e = (a + b) * (c / d)

分析：
这里有两个括号，优先级一样，从左到右算：

  1. 第一个括号 a + b = 30
  2. 第二个括号 c / d = 15 /5 =3
  3. 最后算 30 * 3 =90
    结果：90（还是 90，因为 (30*15)/5 和 30*(15/5) 结果相同）

3.4 例子 4：a + (b * c) / d

1
e = a + (b * c) / d

分析：
这里括号改变了运算顺序！如果没有括号，应该先算 b*c/d，再加 a（因为乘除优先级高于加减）。有括号也一样，因为 * 优先级已经比 + 高了。

  1. 括号里 b * c =10*15=150
  2. 再算 /d → 150 /5=30
  3. 最后算 a + 30 → 20 +30=50
    结果：50（这个和前面不一样！因为先算了 b*c/d，再加的 a）

四、运行实例的输出结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
a = 20
b = 10
c = 15
d = 5
e = 0

e = (a + b) * c / d       # (30 * 15) /5 = 450/5=90
print("(a + b) * c / d 运算结果为：", e)  # 90

e = ((a + b) * c) / d     # (30*15)/5=450/5=90
print("((a + b) * c) / d 运算结果为：", e)  # 90

e = (a + b) * (c / d);    # 30 * (15/5)=30*3=90
print("(a + b) * (c / d) 运算结果为：", e)  # 90

e = a + (b * c) / d;      # 20 + (150/5)=20+30=50
print("a + (b * c) / d 运算结果为：", e)  # 50

输出结果和示例完全一样：

1
2
3
4
(a + b) * c / d 运算结果为： 90
((a + b) * c) / d 运算结果为： 90
(a + b) * (c / d) 运算结果为： 90
a + (b * c) / d 运算结果为： 50

五、优先级表（不用死记硬背）

以下是从最高到最低优先级的常用运算符（完整版比较长，我们记重点）：

优先级 运算符类型 符号 例子
最高 括号 () (1+2)*3
指数（乘方） ** 2**3=8
乘、除、取模、整除 * / % // 3*4=12 10//3=3
加、减 + - 5+6=11
最低 赋值运算符 = += -= 等 a=10 a+=5

原则：

  1. 括号 () 优先级最高，想先算谁就把谁括起来！
  2. 先乘除后加减（和数学一样）。
  3. 同一优先级从左到右算 （比如 30 /5 *2 先算 30/5=6，再算 6*2=12）。

六、提醒：

优先级表很长，就算现在记住了，以后也可能忘。最简单、最安全的方法就是：用括号明确指定运算顺序！

比如：

  • 不确定 a + b * c 先算哪个？写成 a + (b * c) 就清楚了（虽然 * 本身优先级就高，但括号让代码更易读）。
  • 对于复杂的表达式，多用括号分组，不仅自己不容易错，别人看你的代码也能一目了然。

练习

一、选择题（共5题）

1. 以下表达式的结果是多少？5 + 3 * 2

A. 16
B. 11
C. 26
D. 10

2. 执行 a = 10; b = 3; print(a % b) 的输出结果是？

A. 3
B. 1
C. 0
D. 4

3. 假设 x = 5，执行 x += 3 后，x 的值是？

A. 5
B. 3
C. 8
D. 15

4. 以下哪个表达式的结果是 True？

A. (3 > 5) and (2 < 4)
B. not (5 > 3)
C. (10 // 3 == 3) or (5 % 2 == 0)
D. 2 **3 < 10

5. 关于 is 和 == 的区别，以下说法正确的是？

A. is 判断值是否相等，== 判断是否为同一对象
B.** is 判断是否为同一对象，== 判断值是否相等**C. 两者完全相同
D. is 只能用于数字，== 只能用于字符串

二、填空题（共3题）

1. 计算 8 // 3 的结果是 ______，8 / 3 的结果是 ______（保留一位小数）。

2. 假设 a = [1, 2, 3]，b = a，则 b is a 的结果是 ______；若 b = a.copy()，则 b is a 的结果是 ______。

3. 逻辑运算符中，and 表示 ______（逻辑与/逻辑或），or 表示 ______（逻辑与/逻辑或），not 表示 ______（取反/取余）。

三、代码实践题（共4题）

1. 基础算术运算

问题：小明有 20 元零花钱，买零食花了 8 元，又收到妈妈给的 15 元红包，现在他有多少钱？用代码计算并打印结果。
代码模板：

1
2
3
4
5
6
7
8
9
10
# 定义初始金额、花费和红包金额
initial = 20
cost = 8
red_packet = 15

# 计算当前金额
current = initial - cost + red_packet

# 打印结果（输出应为：27）
print(current)

2. 比较运算符与条件判断

问题：判断一个整数 num 是否为偶数且大于 10。若满足条件，打印“符合条件”，否则打印“不符合条件”。（假设 num = 12）

3. 成员运算符实践

问题：检查字符串 "Hello, Python" 中是否包含子串 "Python"，以及列表 [1, 3, 5, 7] 中是否包含数字 4，分别打印结果。

4. 综合运算：温度转换

问题：编写代码将摄氏度 celsius 转换为华氏度，公式为：华氏度 = 摄氏度 × 1.8 + 32。
要求：用户输入摄氏度（假设输入 25），计算并打印转换后的华氏度（保留一位小数）。

四、附加：逻辑运算符简要说明（供初学者参考）

运算符 作用 例子 结果
and 逻辑与（两边都为 True 才返回 True） True and False False
or 逻辑或（至少一边为 True 就返回 True） True or False True
not 逻辑非（取反） not True False