Python基础指南之运算符优先级对照表与记忆方法详解

# 猜猜输出什么？
result = 2 + 3 * 4
print(f"2 + 3 * 4 = {result}")     # 14 还是 20？

result = 10 - 5 - 2
print(f"10 - 5 - 2 = {result}")    # 3 还是 7？

result = 2 ** 3 ** 2
print(f"2 ** 3 ** 2 = {result}")   # 64 还是 512？

result = not True and False or True
print(f"not True and False or True = {result}")   # ?

result = 3 > 2 == True
print(f"3 > 2 == True = {result}")  # ?

result = 10 / 2 * 5
print(f"10 / 2 * 5 = {result}")     # 25.0 还是 1.0？

# === 验证乘法高于加法 ===
print(2 + 3 * 4)         # 14 —— 先算3*4=12，再算2+12=14
print((2 + 3) * 4)       # 20 —— 括号改变了优先级
# === 验证一元运算符高于二元运算符 ===
print(-3 ** 2)           # -9 —— 先算3**2=9，再取负= -9
print((-3) ** 2)         # 9 —— 先取负得-3，再平方=9
# === 验证幂运算从右向左 ===
print(2 ** 3 ** 2)       # 512 —— 先算3**2=9，再算2**9=512
print((2 ** 3) ** 2)     # 64 —— 先算2**3=8，再算8**2=64
# === 验证比较运算符优先级高于逻辑运算符 ===
print(3 > 2 == True)     # True —— 等价于 (3 > 2) and (2 == True)
# 3 > 2 是 True, 2 == True 也是 True（True被当作1），所以True
# === 验证乘除优先级相同，从左向右 ===
print(10 / 2 * 5)        # 25.0 —— (10/2)*5 = 5*5 = 25.0
print(10 / (2 * 5))      # 1.0
# === 验证 not > and > or ===
print(not True and False or True)
# = ((not True) and False) or True
# = (False and False) or True
# = False or True
# = True

# === 左结合（从左向右）—— 大多数运算符 ===
print(10 - 5 - 2)        # 3 —— (10-5)-2 = 3
print(100 / 10 / 2)      # 5.0 —— (100/10)/2 = 5.0
print(10 + 20 - 5)       # 25 —— (10+20)-5 = 25

# === 右结合（从右向左）—— 特殊运算符 ===

# 1. 幂运算 ** 是右结合
print(2 ** 3 ** 2)       # 512 —— 2 ** (3 ** 2) = 2 ** 9 = 512

# 2. 一元运算符是右结合
print(- - 5)             # 5 —— -(-5) = 5

# 3. 赋值运算符是右结合
a = b = c = 10
# 等价于 a = (b = (c = 10))
# c=10 → b=10 → a=10

# 4. 条件表达式是右结合（但不建议嵌套使用）
x = "正数" if a > 0 else "零或负数"
# 嵌套时要注意可读性

# 链式比较的等价展开
a < b < c
# 等价于 (a < b) and (b < c)
# 注意：不等于 (a < b) < c！

# 验证
print(1 < 3 < 5)     # True —— (1 < 3) and (3 < 5)
print(1 < 3 > 2)     # True —— (1 < 3) and (3 > 2)

# 混合比较和逻辑运算符
print(1 < 3 and 5 > 2)   # True —— 比较优先于and
# 等价于 (1 < 3) and (5 > 2)

# 优先级决定了哪些操作数"绑定"到哪个运算符
# 短路求值决定了表达式的哪些部分实际被执行

def show(v):
    print(f"  计算了 show({v})")
    return v

# 由于and优先级高于or，所以：
# True or False and show(1)
# = True or (False and show(1))
# 短路：True已经确定or的结果，show(1)不会执行
print("True or False and show(1):")
result = True or False and show(1)
print(f"  结果: {result}")

# 但如果改成：
# (True or False) and show(1)
# show(1)会执行，因为and的左边暂时未知
print("(True or False) and show(1):")
result = (True or False) and show(1)
print(f"  结果: {result}")

# 再验证 and 优先级高于 or
print("\n验证优先级: show(0) or show(1) and show(2)")
# 等价于 show(0) or (show(1) and show(2))
# show(0)为假，继续计算show(1) and show(2)
# show(1)为真，需要计算show(2)来确定and的结果
result = show(0) or show(1) and show(2)
print(f"  结果: {result}")

# 场景1：位运算参与逻辑判断
flags = 0b1010
MASK = 0b1000

# ❌ 错误 —— 位运算优先级低于比较！
if flags & MASK == MASK:   # 等价于 flags & (MASK == MASK) = flags & True!
    print("匹配")   # 结果可能不对

# ✅ 正确 —— 括号明确意图
if (flags & MASK) == MASK:
    print("匹配")

# 场景2：左移/右移参与算术运算
# ❌ 模糊
result = 1 << 2 + 3
# 等价于 1 << (2 + 3) = 1 << 5 = 32

# ✅ 明确
result = (1 << 2) + 3    # 4 + 3 = 7

# 场景3：not 作用于复杂表达式
# ❌ 可能误解
if not a > 0 and b > 0:
    pass
# 等价于 (not (a > 0)) and (b > 0)

# ✅ 明确意图
if not (a > 0 and b > 0):    # 两者不都大于0
    pass
if (not a > 0) and b > 0:    # a不大于0 且 b大于0
    pass

# 场景4：复合赋值与表达式混用
# ❌ 不清晰
x = y = f(z) + g(z) * h(z)

# ✅ 拆分开
temp = f(z) + g(z) * h(z)
x = temp
y = temp

# 不加括号：需要查优先级表
result = a << b + c * d & e | f

# 加括号：一眼看懂
result = (a << (b + c * d)) & e | f

# 更好：拆分成多步
shift_amount = b + c * d
shifted = a << shift_amount
result = (shifted & e) | f

# Bug代码：检查权限位的函数
def has_permission_bug(user_permissions, required):
    """有bug：位运算优先级低于比较"""
    return user_permissions & required == required
    # 等价于: user_permissions & (required == required)
    #       = user_permissions & True
    #       = user_permissions & 1
    # 这几乎总是错的！

# 修复后
def has_permission_fixed(user_permissions, required):
    """修复：加括号"""
    return (user_permissions & required) == required

# 测试
READ = 0b001
WRITE = 0b010
EXECUTE = 0b100

user_perm = READ | WRITE     # 0b011

print(f"Bug版本: {has_permission_bug(user_perm, WRITE)}")   # 可能错误
print(f"修复版本: {has_permission_fixed(user_perm, WRITE)}") # True
print(f"修复版本: {has_permission_fixed(user_perm, EXECUTE)}") # False

# 这是另一个常见错误
is_active = True
is_admin = False

# ❌ 本意："如果不是管理员且是活跃用户"
if not is_admin and is_active:
    print("可以操作")
# 但这等价于 (not is_admin) and is_active
# 效果：is_admin=False, is_active=True → True（碰巧对了）

# 但如果想表达"不是(管理员且活跃)"？
if not (is_admin and is_active):
    print("不是同时为管理员和活跃用户")

# 所以使用not时一定要明确范围

# 海象运算符的优先级很低，仅次于逗号
# 几乎总是需要括号！

# ❌ 错误
# if n := len(data) > 0:  # 等价于 if n := (len(data) > 0)
#     pass                 # n是True/False，不是长度！

# ✅ 正确
if (n := len(data)) > 0:
    print(f"数据长度为{n}")

# 另一个例子
# ❌
# result = x := 10 + 5  # SyntaxError

# ✅
result = (x := 10) + 5   # result=15, x=10

class PrecedenceTester:
    """运算符优先级互动测试器"""
    
    def __init__(self):
        self.score = 0
        self.total = 0
    
    def test_question(self, expression, expected, explanation=""):
        """测试一道优先级题目"""
        self.total += 1
        try:
            actual = eval(expression)
            if actual == expected:
                self.score += 1
                print(f"✅ 第{self.total}题 正确！{expression} = {actual}")
            else:
                print(f"❌ 第{self.total}题 错误！")
                print(f"   表达式: {expression}")
                print(f"   你的直觉: {expected}")
                print(f"   实际结果: {actual}")
                if explanation:
                    print(f"   💡 解释: {explanation}")
        except Exception as e:
            print(f"⚠️ 第{self.total}题 异常: {e}")
    
    def run_all_tests(self):
        """运行所有测试题"""
        print("=" * 50)
        print("Python 运算符优先级测试")
        print("=" * 50)
        
        # 算术优先级
        self.test_question("2 + 3 * 4", 14, "乘法优先级高于加法")
        self.test_question("10 - 5 - 2", 3, "减法从左向右结合")
        self.test_question("2 ** 3 ** 2", 512, "幂运算从右向左结合")
        self.test_question("-3 ** 2", -9, "幂运算优先级高于一元负号")
        self.test_question("(-3) ** 2", 9, "括号改变优先级")
        self.test_question("10 / 2 * 5", 25.0, "乘除同级，从左向右")
        
        # 位移和位运算
        self.test_question("1 << 2 + 3", 32, "加法优先级高于左移")
        self.test_question("(1 << 2) + 3", 7, "括号改变优先级")
        self.test_question("5 & 3 == 3", 1, "== 优先级高于 &，小心!")
        self.test_question("(5 & 3) == 3", False, "括号改变优先级")
        
        # 逻辑优先级
        self.test_question("not True and False", False, 
                          "not > and: (not True) and False")
        self.test_question("not (True and False)", True, "括号改变优先级")
        self.test_question("True or False and False", True,
                          "and > or: True or (False and False)")
        self.test_question("(True or False) and False", False, "括号改变优先级")
        
        # 比较和逻辑
        self.test_question("3 > 2 and 4 < 5", True, "比较 > and")
        self.test_question("3 > 2 == True", True, "链式比较")
        
        # 综合
        self.test_question("2 + 3 * 4 ** 2 - 8 / 2", 
                          46.0, "综合优先级测试")
        
        print(f"\n{'='*50}")
        print(f"总计: {self.total}题, 正确: {self.score}题")
        print(f"得分: {self.score/self.total*100:.0f}%")

# 运行测试
tester = PrecedenceTester()
tester.run_all_tests()

# 现代IDE（PyCharm、VS Code + Pylance）会给出优先级警告
# 例如：
flags = 0b1010
MASK = 0b1000

# 当你写：
result = flags & MASK == MASK
# IDE通常会显示警告："Equality check is not the same as bitwise and"
# 建议改为：
result = (flags & MASK) == MASK

import ast

def show_precedence(expr_str):
    """使用AST查看Python如何解析表达式"""
    print(f"\n表达式: {expr_str}")
    try:
        tree = ast.parse(expr_str, mode='eval')
        print(f"AST结构: {ast.dump(tree, indent=2)}")
    except SyntaxError as e:
        print(f"语法错误: {e}")

# 演示不同表达式如何被解析
show_precedence("2 + 3 * 4")
show_precedence("not True and False")
show_precedence("1 << 2 + 3")
show_precedence("flags & MASK == MASK")