2.1 算术运算符

2.1.1 理论知识

算术运算符用于执行基本的数学运算，Python 提供了以下几种算术运算符：

• 加（+）：用于将两个数值相加。
• 减（-）：从第一个数中减去第二个数。
• 乘（*）：将两个数相乘。
• 除（/）：用第一个数除以第二个数，结果为浮点数。
• 整除（//）：执行除法运算并返回商的整数部分。
• 取余（%）：返回除法运算后的余数。
• 幂运算（**）：将第一个数作为底数，第二个数作为指数进行幂运算。

2.1.2 示例代码

a = 10
b = 3

# 加法
result_add = a + b
print(f"{a} + {b} 的结果是: {result_add}")

# 减法
result_sub = a - b
print(f"{a} - {b} 的结果是: {result_sub}")

# 乘法
result_mul = a * b
print(f"{a} * {b} 的结果是: {result_mul}")

# 除法
result_div = a / b
print(f"{a} / {b} 的结果是: {result_div}")

# 整除
result_floor_div = a // b
print(f"{a} // {b} 的结果是: {result_floor_div}")

# 取余
result_mod = a % b
print(f"{a} % {b} 的结果是: {result_mod}")

# 幂运算
result_pow = a ** b
print(f"{a} ** {b} 的结果是: {result_pow}")

2.1.3 代码解释

• 首先定义了两个变量 a 和 b 并分别赋值为 10 和 3。
• 然后使用不同的算术运算符对 a 和 b 进行运算，并将结果存储在相应的变量中。
• 使用 print() 函数输出每个运算的表达式及结果，其中使用了 f 字符串格式化输出，使输出更清晰易读。

2.2 比较运算符

2.2.1 理论知识

比较运算符用于比较两个值的大小关系，运算结果是布尔值（True 或 False）。Python 中的比较运算符包括：

• 等于（==）：判断两个值是否相等。
• 不等于（!=）：判断两个值是否不相等。
• 大于（>）：判断第一个值是否大于第二个值。
• 小于（<）：判断第一个值是否小于第二个值。
• 大于等于（>=）：判断第一个值是否大于或等于第二个值。
• 小于等于（<=）：判断第一个值是否小于或等于第二个值。

2.2.2 示例代码

x = 5
y = 10

# 等于
is_equal = x == y
print(f"{x} == {y} 的结果是: {is_equal}")

# 不等于
is_not_equal = x!= y
print(f"{x}!= {y} 的结果是: {is_not_equal}")

# 大于
is_greater = x > y
print(f"{x} > {y} 的结果是: {is_greater}")

# 小于
is_less = x < y
print(f"{x} < {y} 的结果是: {is_less}")

# 大于等于
is_greater_or_equal = x >= y
print(f"{x} >= {y} 的结果是: {is_greater_or_equal}")

# 小于等于
is_less_or_equal = x <= y
print(f"{x} <= {y} 的结果是: {is_less_or_equal}")

2.2.3 代码解释

• 定义变量 x 为 5，y 为 10。
• 使用不同的比较运算符对 x 和 y 进行比较，并将结果存储在相应的布尔变量中。
• 通过 print() 函数输出每个比较表达式及其结果。

2.3 逻辑运算符

2.3.1 理论知识

逻辑运算符用于组合多个条件，对条件进行逻辑判断，结果也是布尔值。Python 中有以下逻辑运算符：

• 与（and）：只有当两个条件都为 True 时，结果才为 True，否则为 False。
• 或（or）：只要两个条件中有一个为 True，结果就为 True，只有当两个条件都为 False 时，结果才为 False。
• 非（not）：对一个条件进行取反操作，如果原条件为 True，则结果为 False；如果原条件为 False，则结果为 True。

2.3.2 示例代码

condition1 = True
condition2 = False

# 与运算
result_and = condition1 and condition2
print(f"{condition1} and {condition2} 的结果是: {result_and}")

# 或运算
result_or = condition1 or condition2
print(f"{condition1} or {condition2} 的结果是: {result_or}")

# 非运算
result_not = not condition1
print(f"not {condition1} 的结果是: {result_not}")

2.3.3 代码解释

• 定义了两个布尔变量 condition1 为 True，condition2 为 False。
• 分别使用 and、or、not 逻辑运算符对这两个条件进行运算，并将结果存储在相应变量中。
• 最后通过 print() 函数输出每个逻辑运算表达式及其结果。

2.4 赋值运算符

2.4.1 理论知识

赋值运算符用于将右侧的值赋给左侧的变量。除了基本的赋值运算符 = 外，Python 还提供了一些复合赋值运算符，这些运算符在进行运算的同时会将结果赋值给变量。常见的赋值运算符有：

• 简单赋值（=）：将右侧的值赋给左侧变量。
• 加法赋值（+=）：先将变量与右侧的值相加，然后将结果赋给该变量，例如 a += b 等价于 a = a + b。
• 减法赋值（-=）：先将变量减去右侧的值，然后将结果赋给该变量，例如 a -= b 等价于 a = a - b。
• 乘法赋值（*=）：先将变量与右侧的值相乘，然后将结果赋给该变量，例如 a *= b 等价于 a = a * b。
• 除法赋值（/=）：先将变量除以右侧的值（结果为浮点数），然后将结果赋给该变量，例如 a /= b 等价于 a = a / b。
• 整除赋值（//=）：先将变量除以右侧的值并取整数部分，然后将结果赋给该变量，例如 a //= b 等价于 a = a // b。
• 取余赋值（%=）：先将变量对右侧的值取余，然后将结果赋给该变量，例如 a %= b 等价于 a = a % b。
• 幂运算赋值（**=）：先将变量进行幂运算（以自身为底数，右侧值为指数），然后将结果赋给该变量，例如 a **= b 等价于 a = a ** b。

2.4.2 示例代码

num = 5

# 简单赋值
num = 10
print(f"简单赋值后 num 的值为: {num}")

# 加法赋值
num += 3
print(f"加法赋值后 num 的值为: {num}")

# 减法赋值
num -= 2
print(f"减法赋值后 num 的值为: {num}")

# 乘法赋值
num *= 4
print(f"乘法赋值后 num 的值为: {num}")

# 除法赋值
num /= 2
print(f"除法赋值后 num 的值为: {num}")

# 整除赋值
num //= 3
print(f"整除赋值后 num 的值为: {num}")

# 取余赋值
num %= 5
print(f"取余赋值后 num 的值为: {num}")

# 幂运算赋值
num **= 2
print(f"幂运算赋值后 num 的值为: {num}")

2.4.3 代码解释

• 首先定义变量 num 并赋值为 5。
• 然后依次使用不同的赋值运算符对 num 进行操作，每次操作后通过 print() 函数输出 num 的新值，展示赋值运算符的效果。

2.5 位运算符

2.5.1 理论知识

位运算符用于对整数在二进制层面上进行操作。Python 支持的位运算符有：

• 按位与（&）：对两个整数的二进制表示逐位进行与操作，只有当对应位都为 1 时，结果位才为 1，否则为 0。
• 按位或（|）：对两个整数的二进制表示逐位进行或操作，只要对应位中有一个为 1，结果位就为 1，只有当对应位都为 0 时，结果位才为 0。
• 按位异或（^）：对两个整数的二进制表示逐位进行异或操作，当对应位不同时，结果位为 1，相同时为 0。
• 按位取反（~）：对一个整数的二进制表示逐位取反，0 变为 1，1 变为 0。由于 Python 中整数的表示方式，取反结果会涉及补码运算。
• 左移（<<）：将一个整数的二进制表示向左移动指定的位数，右边空出的位用 0 填充，相当于乘以 2 的移动位数次方。
• 右移（>>）：将一个整数的二进制表示向右移动指定的位数，左边空出的位根据原数的正负进行填充（正数用 0 填充，负数用 1 填充），相当于除以 2 的移动位数次方并向下取整。

2.5.2 示例代码

a = 5  # 二进制表示为 0000 0101
b = 3  # 二进制表示为 0000 0011

# 按位与
result_and = a & b
print(f"{a} & {b} 的结果是: {result_and}")

# 按位或
result_or = a | b
print(f"{a} | {b} 的结果是: {result_or}")

# 按位异或
result_xor = a ^ b
print(f"{a} ^ {b} 的结果是: {result_xor}")

# 按位取反
result_not = ~a
print(f"~{a} 的结果是: {result_not}")

# 左移
result_left_shift = a << 2
print(f"{a} << 2 的结果是: {result_left_shift}")

# 右移
result_right_shift = a >> 1
print(f"{a} >> 1 的结果是: {result_right_shift}")

2.5.3 代码解释

• 定义变量 a 为 5，b 为 3，并注释出它们的二进制表示。
• 使用不同的位运算符对 a 和 b 进行操作，将结果存储在相应变量中。
• 通过 print() 函数输出每个位运算表达式及其结果，展示位运算符对二进制数据的操作效果。虽然结果以十进制形式输出，但反映了位运算在二进制层面的操作结果。

2.6 运算符优先级

2.6.1 理论知识

当一个表达式中包含多个运算符时，Python 按照一定的优先级顺序来执行运算。优先级从高到低大致如下：

1. 括号内的表达式：()
2. 指数运算：**
3. 按位取反：~
4. 乘、除、整除、取余：*、/、//、%
5. 加、减：+、-
6. 左移、右移：<<、>>
7. 按位与：&
8. 按位异或：^
9. 按位或：|
10. 比较运算符：==、!=、>、<、>=、<=
11. 逻辑非：not
12. 逻辑与：and
13. 逻辑或：or
14. 赋值运算符：=、+=、-= 等

在同一优先级的运算符中，按照从左到右的顺序进行计算。如果需要改变运算顺序，可以使用括号 ()。

2.6.2 示例代码

result = 2 + 3 * 4 ** 2 & 7 // 2
print(f"表达式 2 + 3 * 4 ** 2 & 7 // 2 的结果是: {result}")

# 使用括号改变运算顺序
result_with_parentheses = (2 + 3) * (4 ** 2 & 7 // 2)
print(f"表达式 (2 + 3) * (4 ** 2 & 7 // 2) 的结果是: {result_with_parentheses}")

2.6.3 代码解释

• 第一个表达式 2 + 3 * 4 ** 2 & 7 // 2 按照运算符优先级进行运算，先计算指数 4 ** 2，再依次进行乘、整除、按位与和加法运算。
• 第二个表达式 (2 + 3) * (4 ** 2 & 7 // 2) 使用括号改变了运算顺序，先分别计算括号内的表达式，再进行乘法运算。通过 print() 函数输出两个表达式的结果，展示运算符优先级和括号对运算顺序的影响。