介绍
在这个 Lab 中，你将全面了解 Python 中的各种运算符，这是编写有效代码的一个基本概念。我们将探索并练习使用算术、比较、赋值、逻辑、位、成员资格和身份运算符。
通过使用集成的 VS Code 编辑器和终端进行的实践练习，你将学习如何执行计算、进行比较、赋值、组合条件、操作位、检查成员资格以及比较对象身份。到本 Lab 结束时，你将熟练掌握使用这些运算符来构建更复杂和功能性的 Python 程序。
探索算术运算符和比较运算符
在这一步中，我们将探索 Python 中基本的算术运算符和比较运算符。这些运算符对于在你的程序中执行计算和做出决策至关重要。Lab 环境已经在 ~/project 目录下为你创建了一个名为 operators.py 的文件。
首先，在 VS Code 编辑器左侧的文件浏览器中找到 operators.py 文件并打开它。我们将把所有的代码写在这个文件中。
让我们从算术运算符开始。将以下 Python 代码添加到 operators.py 文件中：
## Arithmetic Operators
a = 21
b = 5
print(f'{a} + {b} = {a + b}')
print(f'{a} - {b} = {a - b}')
print(f'{a} * {b} = {a * b}')
print(f'{a} / {b} = {a / b}') ## 标准除法
print(f'{a} // {b} = {a // b}') ## 整除，向下取整到最近的整数
print(f'{a} % {b} = {a % b}') ## 取模，返回余数
print(f'{a} ** {b} = {a ** b}') ## 幂运算，a 的 b 次方
添加代码后，按 Ctrl + S 保存文件。
要运行脚本，请从顶部菜单选择 Terminal > New Terminal 打开 VS Code 中的集成终端。然后，执行以下命令：
python ~/project/operators.py
你应该在终端中看到以下输出：
21 + 5 = 26
21 - 5 = 16
21 * 5 = 105
21 / 5 = 4.2
21 // 5 = 4
21 % 5 = 1
21 ** 5 = 4084101
接下来，让我们探索比较运算符。这些运算符比较两个值并返回一个布尔值：True 或 False。
将以下代码添加到你的 operators.py 文件的末尾：
## Comparison Operators
print("\n--- Comparison Operators ---")
a = 6
b = 5
print(f'{a} == {b} is {a == b}') ## 等于
print(f'{a} != {b} is {a != b}') ## 不等于
print(f'{a} > {b} is {a > b}') ## 大于
print(f'{a} < {b} is {a < b}') ## 小于
print(f'{a} >= {b} is {a >= b}') ## 大于或等于
print(f'{a} <= {b} is {a <= b}') ## 小于或等于
再次保存文件，并从终端运行它：
python ~/project/operators.py
输出现在将包括比较操作的结果：
21 + 5 = 26
21 - 5 = 16
21 * 5 = 105
21 / 5 = 4.2
21 // 5 = 4
21 % 5 = 1
21 ** 5 = 4084101
--- Comparison Operators ---
6 == 5 is False
6 != 5 is True
6 > 5 is True
6 < 5 is False
6 >= 5 is True
6 <= 5 is False
你现在已成功在 Python 脚本中使用了算术运算符和比较运算符。
练习赋值运算符和逻辑运算符
在这一步中，我们将练习使用赋值运算符和逻辑运算符。赋值运算符用于分配或更新变量的值，而逻辑运算符用于组合条件语句。
继续在 VS Code 编辑器中使用 operators.py 文件。
首先，让我们添加赋值运算符的示例。它们提供了一种执行操作并将结果分配回同一变量的简写方式。
将以下代码添加到你的 operators.py 文件的末尾：
## Assignment Operators
print("\n--- Assignment Operators ---")
a = 10
b = 3
print(f'Initial a: {a}')
c = a
c += b ## 等同于 c = c + b
print(f'a += b: {c}')
c = a
c -= b ## 等同于 c = c - b
print(f'a -= b: {c}')
c = a
c *= b ## 等同于 c = c * b
print(f'a *= b: {c}')
c = a
c /= b ## 等同于 c = c / b
print(f'a /= b: {c}')
## 海象运算符 (Walrus operator, Python 3.8+)
## 它在更大的表达式的一部分中将一个值赋给一个变量。
print("\n--- Walrus Operator ---")
text = 'hello python'
if (n := len(text)) > 10:
print(f'The string is long enough ({n} characters)')
保存文件，并从终端运行它：
python ~/project/operators.py
你应该会看到赋值运算符的输出：
... (前一步的输出) ...
--- Assignment Operators ---
Initial a: 10
a += b: 13
a -= b: 7
a *= b: 30
a /= b: 3.3333333333333335
--- Walrus Operator ---
The string is long enough (12 characters)
现在，让我们添加逻辑运算符（and、or、not）的示例。这些运算符处理布尔值，但它们也可以处理其他类型。在 Python 中，像 0、None 和空集合（''、[]、{}）这样的值被视为 False。所有其他值都被视为 True。
将以下代码添加到你的 operators.py 文件的末尾：
## Logical Operators
print("\n--- Logical Operators ---")
x = True
y = False
print(f'{x} and {y} is {x and y}')
print(f'{x} or {y} is {x or y}')
print(f'not {x} is {not x}')
## 使用非布尔值的求值
a = 10 ## True
b = 0 ## False
print(f'{a} and {b} returns {a and b}') ## 返回第一个 Falsy 值或最后一个 Truthy 值
print(f'{a} or {b} returns {a or b}') ## 返回第一个 Truthy 值或最后一个 Falsy 值
保存文件并再次运行它：
python ~/project/operators.py
输出现在将包括逻辑操作的结果：
... (前一个示例的输出) ...
--- Logical Operators ---
True and False is False
True or False is True
not True is False
10 and 0 returns 0
10 or 0 returns 10
你现在已在 Python 中练习了赋值运算符和逻辑运算符的使用。
学习位运算符
在这一步中，我们将学习位运算符（Bitwise Operators）。这些运算符直接对整数的二进制（base-2）表示形式执行操作。这对于底层数据操作非常有用。
继续编辑 operators.py 文件。
首先，我们使用 bin() 函数来看看一些数字的二进制表示。0b 前缀表示后面的数字是二进制的。
将以下代码添加到 operators.py 的末尾：
## Bitwise Operators
print("\n--- Bitwise Operators ---")
a = 5 ## Binary: 0b101
b = 9 ## Binary: 0b1001
print(f'Binary of {a} is {bin(a)}')
print(f'Binary of {b} is {bin(b)}')
## 为了清晰起见，我们用 4 位来对齐它们：
## a = 0101
## b = 1001
## 位与 (&): 如果两个位都是 1，则结果位设置为 1。
## 0101 & 1001 = 0001 (十进制 1)
print(f'{a} & {b} = {a & b}')
## 位或 (|): 如果两个位中有一个是 1，则结果位设置为 1。
## 0101 | 1001 = 1101 (十进制 13)
print(f'{a} | {b} = {a | b}')
## 位异或 (^): 如果只有两个位中有一个是 1，则结果位设置为 1。
## 0101 ^ 1001 = 1100 (十进制 12)
print(f'{a} ^ {b} = {a ^ b}')
## 位非 (~): 反转所有位。
## ~a 等同于 -(a+1)
print(f'~{a} = {~a}')
## 左移 (<<): 将位向左移动，右侧用零填充。
## 等同于乘以 2**n。
## 5 << 2 表示 0101 变为 10100 (十进制 20)
print(f'{a} << 2 = {a << 2}')
## 右移 (>>): 将位向右移动，丢弃右侧的位。
## 等同于进行 2**n 的整除。
## 9 >> 2 表示 1001 变为 10 (十进制 2)
print(f'{b} >> 2 = {b >> 2}')
保存文件，并从终端运行脚本：
python ~/project/operators.py
你将看到演示每次位操作的输出：
... (前一步的输出) ...
--- Bitwise Operators ---
Binary of 5 is 0b101
Binary of 9 is 0b1001
5 & 9 = 1
5 | 9 = 13
5 ^ 9 = 12
~5 = -6
5 << 2 = 20
9 >> 2 = 2
你现在已经学会了如何使用位运算符来在位级别上操作整数。
使用成员运算符和身份运算符
在最后一步中，我们将介绍成员资格运算符（in、not in）和身份运算符（is、is not）。成员资格运算符用于测试一个值是否存在于一个序列中，而身份运算符用于检查两个变量是否引用内存中完全相同的对象。
继续编辑 operators.py 文件。
首先，让我们添加成员资格运算符的示例。它们通常与列表（list）、元组（tuple）和字符串（string）等序列一起使用。
将以下代码添加到你的 operators.py 文件的末尾：
## Membership Operators
print("\n--- Membership Operators ---")
my_list = [1, 3, 5, 7]
print(f'3 in {my_list} is {3 in my_list}')
print(f'4 not in {my_list} is {4 not in my_list}')
greeting = "hello world"
print(f'"world" in "{greeting}" is {"world" in greeting}')
保存文件并运行：
python ~/project/operators.py
成员资格运算符的输出将是：
... (前一步的输出) ...
--- Membership Operators ---
3 in [1, 3, 5, 7] is True
4 not in [1, 3, 5, 7] is True
"world" in "hello world" is True
现在，让我们探索身份运算符。理解 is（身份）和 ==（相等性）之间的区别非常重要。== 检查两个对象的值是否相同，而 is 检查它们是否是同一个对象（即它们具有相同的内存地址）。
将以下代码添加到你的 operators.py 文件中：
## Identity Operators
print("\n--- Identity Operators ---")
## 对于小整数，Python 通常会重用同一个对象。
x = 256
y = 256
print(f'x is y (for 256): {x is y}') ## 这通常是 True
## 对于较大的整数，Python 可能会创建单独的对象。
a = 257
b = 257
print(f'a is b (for 257): {a is b}') ## 这通常是 False
## 对于像列表（list）这样的可变对象（mutable objects），即使它们的内容相同，它们也是不同的对象。
list1 = [1, 2, 3]
list2 = [1, 2, 3]
print(f'list1 == list2: {list1 == list2}') ## 检查内容是否相等 (True)
print(f'list1 is list2: {list1 is list2}') ## 检查是否是同一个对象 (False)
print(f'list1 is not list2: {list1 is not list2}') ## 检查是否是不同的对象 (True)
保存文件并最后一次运行它：
python ~/project/operators.py
输出展示了相等性和身份之间的区别：
... (前一个示例的输出) ...
--- Identity Operators ---
x is y (for 256): True
a is b (for 257): True
list1 == list2: True
list1 is list2: False
list1 is not list2: True
你已成功使用成员资格运算符和身份运算符，完成了对 Python 主要运算符类型的探索。
总结
在这个实验（Lab）中，你获得了关于 Python 中各种类型运算符的实践经验。你从探索基本的算术运算符（Arithmetic Operators）和比较运算符（Comparison Operators）开始，用于执行计算和评估条件。然后，你练习使用赋值运算符（Assignment Operators）来高效地更新变量，并使用逻辑运算符（Logical Operators）来组合条件逻辑。
此外，你深入研究了位运算符（Bitwise Operators）以了解底层数据操作，并最后学习了成员资格运算符（Membership Operators）和身份运算符（Identity Operators），用于检查项的存在性和对象身份。通过在 VS Code 编辑器中为每种运算符类型编写和执行代码，你为在未来的 Python 编程中使用这些基本工具打下了坚实的基础。
