运算符

在 Python 中，运算符是用于执行各种操作的特殊符号，如算术运算、比较、逻辑判断等。熟练掌握运算符是编写任何 Python 程序的基础。

---

1. 算术运算符 (Arithmetic Operators)

算术运算符用于执行基本的数学计算。

运算符	名称	描述	示例 (a=10, b=3)	结果
+	加法	对两个数求和	a + b	13
-	减法	从第一个数中减去第二个数	a - b	7
*	乘法	对两个数求积	a * b	30
/	除法	第一个数除以第二个数，结果总是浮点数	a / b	3.33...
//	整除	第一个数除以第二个数，结果向下取整	a // b	3
%	取余/取模	返回除法的余数	a % b	1
**	幂运算	返回第一个数的第二个数次幂	a ** b	1000

注意:

• + 和 * 也可用于序列类型（如字符串、列表）：

  print("Hello" + " " + "World") # 输出: Hello World
  print([1, 2] + [3, 4])        # 输出: [1, 2, 3, 4]
  print("Ha" * 3)               # 输出: HaHaHa
  print([0] * 4)                # 输出: [0, 0, 0, 0]
  

• 对于负数的整除 //，结果总是向下取整（向负无穷方向）。

  print(-10 // 3) # 输出: -4
  

---

2. 赋值运算符 (Assignment Operators)

赋值运算符用于为变量分配一个值。复合赋值运算符则是一种简化写法。

运算符	示例	等价于
=	x = 5	x = 5
+=	x += 3	x = x + 3
-=	x -= 3	x = x - 3
*=	x *= 3	x = x * 3
/=	x /= 3	x = x / 3
//=	x //= 3	x = x // 3
%=	x %= 3	x = x % 3
**=	x **= 3	x = x ** 3

示例代码:

# 基本赋值
x = 10

# 复合赋值
x += 5  # x 现在是 15
print(x) # 输出: 15

# 链式赋值：将多个变量赋为同一个值
a = b = c = 20
print(f"a={a}, b={b}, c={c}") # 输出: a=20, b=20, c=20

---

3. 比较运算符 (Comparison Operators)

比较运算符用于比较两个值，其返回结果永远是布尔值 True 或 False。

运算符	名称	描述
==	等于	如果两个值相等，返回 True
!=	不等于	如果两个值不相等，返回 True
>	大于	如果左边的值大于右边，返回 True
<	小于	如果左边的值小于右边，返回 True
>=	大于等于	如果左边的值大于或等于右边，返回 True
<=	小于等于	如果左边的值小于或等于右边，返回 True

示例代码:

x = 5
y = 10
print(x < y)  # 输出: True
print(x == 5) # 输出: True

# 比较也适用于字符串（按字典顺序）
print("apple" < "banana") # 输出: True

# 链式比较：判断一个数是否在某个区间内
age = 25
if 18 <= age < 30:
    print("你是青年人。") # 输出: 你是青年人。

---

4. 逻辑运算符 (Logical Operators)

逻辑运算符用于组合多个布尔表达式。

运算符	名称	描述
and	逻辑与	如果两个操作数都为 True，则结果为 True。
or	逻辑或	如果至少有一个操作数为 True，则结果为 True。
not	逻辑非	反转操作数的逻辑状态。not True 为 False。

短路求值 (Short-circuit Evaluation)

这是逻辑运算符一个非常重要的特性：

• x and y: 如果 x 为 False，则整个表达式必为 False，Python 不会再计算 y，直接返回 x 的值。如果 x 为 True，则返回 y 的值。
• x or y: 如果 x 为 True，则整个表达式必为 True，Python 不会再计算 y，直接返回 x 的值。如果 x 为 False，则返回 y 的值。

示例代码:

# 基本用法
has_permission = True
is_admin = False
if has_permission and not is_admin:
    print("有权限，但不是管理员。") # 输出: 有权限，但不是管理员。

# 短路求值示例
# 场景：只有在 user 不为 None 的情况下，才访问其 name 属性
user = None
# 如果没有短路，user.name 会报错
if user and user.name == "Alice": 
    print("欢迎 Alice") # 这行不会执行，也不会报错

# or 的短路特性常用于提供默认值
# 如果 name 为空字符串 "" (被视为False)，则使用 "Guest"
name = ""
username = name or "Guest"
print(username) # 输出: Guest

---

5. 成员运算符 (Membership Operators)

成员运算符用于测试一个值是否存在于一个序列（如字符串、列表、元组、集合、字典）中。

运算符	描述
in	如果在指定的序列中找到值，返回 True。
not in	如果在指定的序列中找不到值，返回 True。

示例代码:

fruits = ["apple", "banana", "cherry"]
print("banana" in fruits)       # 输出: True
print("grape" not in fruits)    # 输出: True

# 对字典，默认检查的是 `键` (key)
student = {"name": "Bob", "age": 22}
print("age" in student)         # 输出: True
print("Bob" in student)         # 输出: False (因为 "Bob" 是值，不是键)
print("Bob" in student.values())# 输出: True

性能提示：对于 set 和 dict，in 操作非常快（时间复杂度 O(1)）。对于 list 和 tuple，in 操作较慢（时间复杂度 O(n)），因为它需要逐个元素检查。

---

6. 身份运算符 (Identity Operators)

身份运算符用于比较两个对象的内存地址是否相同，即它们是否是同一个对象。

运算符	描述
is	如果两个变量引用同一个对象，返回 True。
is not	如果两个变量引用不同对象，返回 True。

is 与 == 的核心区别

• == 比较的是两个对象的值是否相等。
• is 比较的是两个对象的身份是否相同 (ID 是否相等)。

示例代码:

list_a = [1, 2, 3]
list_b = [1, 2, 3] # list_b 是一个新创建的列表
list_c = list_a    # list_c 引用了与 list_a 相同的列表

# 值相等，但身份不同
print(f"list_a == list_b is {list_a == list_b}")  # 输出: list_a == list_b is True
print(f"list_a is list_b is {list_a is list_b}")  # 输出: list_a is list_b is False

# 值相等，且身份相同
print(f"list_a == list_c is {list_a == list_c}")  # 输出: list_a == list_c is True
print(f"list_a is list_c is {list_a is list_c}")  # 输出: list_a is list_c is True

黄金法则: 在判断一个变量是否为 None 时，永远使用 is，而不是 ==。这是一种约定俗成的规范，且更高效。

my_var = None
if my_var is None:
    print("变量是 None") # 输出: 变量是 None

---

7. 位运算符 (Bitwise Operators)

位运算符直接对整数的二进制位进行操作。通常用于底层编程、数据压缩、加密或性能优化。

运算符	名称	描述
&	按位与	对两个数的每个位，如果都为1，则结果位为1。
|	按位或	对两个数的每个位，如果任意一个为1，则结果位为1。
^	按位异或	对两个数的每个位，如果不同，则结果位为1。
~	按位取反	对一个数的所有位取反（0变1，1变0）。
<<	左移	将一个数的位向左移动指定的位数（相当于乘以2的幂）。
>>	右移	将一个数的位向右移动指定的位数（相当于除以2的幂）。

示例代码:

a = 5  # 二进制: 0b0101
b = 3  # 二进制: 0b0011

print(f"a & b: {a & b}")   # 0b0101 & 0b0011 = 0b0001 -> 输出: a & b: 1
print(f"a | b: {a | b}")   # 0b0101 | 0b0011 = 0b0111 -> 输出: a | b: 7
print(f"a ^ b: {a ^ b}")   # 0b0101 ^ 0b0011 = 0b0110 -> 输出: a ^ b: 6
print(f"~a: {~a}")         # ~0101 = ...1010 (二进制补码) -> 输出: ~a: -6
print(f"a << 1: {a << 1}") # 0b0101 << 1 = 0b1010 -> 输出: a << 1: 10
print(f"a >> 1: {a >> 1}") # 0b0101 >> 1 = 0b0010 -> 输出: a >> 1: 2

实际应用场景：权限管理

# 定义权限：每个权限是2的幂
READ_PERM = 4  # 二进制: 0b0100
WRITE_PERM = 2 # 二进制: 0b0010
EXEC_PERM = 1  # 二进制: 0b0001

# 给用户分配权限 (可读可写)
user_perms = READ_PERM | WRITE_PERM # 0b0100 | 0b0010 = 0b0110 (十进制为 6)

# 检查权限
# user_perms & READ_PERM  -> 6 & 4 -> 0b0110 & 0b0100 = 0b0100 (4), 结果 > 0, 有权限
can_read = user_perms & READ_PERM
# user_perms & EXEC_PERM -> 6 & 1 -> 0b0110 & 0b0001 = 0b0000 (0), 结果 == 0, 无权限
can_exec = user_perms & EXEC_PERM

print(f"用户有读权限吗? {'有' if can_read else '没有'}") # 输出: 用户有读权限吗? 有
print(f"用户有执行权限吗? {'有' if can_exec else '没有'}") # 输出: 用户有执行权限吗? 没有

---

8. 运算符优先级 (Operator Precedence)

当一个表达式中包含多个运算符时，Python 会根据优先级规则决定计算顺序。

优先级	类别	运算符
最高	括号	()
15	指数	**
14	位反、一元加减	~, +x, -x
13	乘、除、模、整除	*, /, %, //
12	加减	+, -
11	移位	<<, >>
10	按位与	&
9	按位异或	^
8	按位或	|
7	比较、身份、成员	==, !=, >, >=, <, <=, is, is not, in, not in
6	逻辑非	not
5	逻辑与	and
4	逻辑或	or
最低	赋值	= 及其所有变体 (+=, -= 等)

黄金法则：如果不确定优先级，就使用圆括号 () 来明确指定计算顺序。

# 一个复杂的例子
# 运算顺序: 2**2 -> 4;  3*2 -> 6;  10/5 -> 2.0;  6 + 2.0 -> 8.0;  8.0 - 4 -> 4.0
result = 3 * 2 + 10 / 5 - 2**2

# 使用括号，意图更清晰
result_with_parens = (3 * 2) + (10 / 5) - (2**2)
print(f"无括号结果: {result}")             # 输出: 无括号结果: 4.0
print(f"带括号结果: {result_with_parens}") # 输出: 带括号结果: 4.0

# 改变优先级
# 运算顺序: 2**2 -> 4;  2+10 -> 12;  5-4 -> 1;  3*12 -> 36;  36/1 -> 36.0
result_changed = 3 * (2 + 10) / (5 - 2**2)
print(f"改变优先级后: {result_changed}") # 输出: 改变优先级后: 36.0