Python 3.5中算术、逻辑与位运算符代码示例

# 算术运算符综合示例
a = 14
b = 4

print("加法 a + b  =", a + b)
print("减法 a - b  =", a - b)
print("乘法 a * b  =", a * b)
print("真除法 a / b =", a / b)        # 注意：返回 float
print("整除 a // b =", a // b)       # 向负无穷截断
print("取模 a % b  =", a % b)
print("幂运算 a ** 2 =", a ** 2)

# 负数运算的向下取整与取模
print("-14 // 4    =", -14 // 4)     # 结果为 -4 (而非 -3)
print("-14 % 4     =", -14 % 4)      # (-4 * 4) + 2 = -14，余数为 2
print("14 % -4     =", 14 % -4)      # (-4 * -4) + (-2) = 14，余数为 -2

# 自定义实现支持 @ 矩阵乘法的简易矩阵类
class SimpleMatrix:
    def __init__(self, data):
        self.data = data
        self.rows = len(data)
        self.cols = len(data[0])

    def __matmul__(self, other):
        # 实现 PEP 465 规定的 @ 运算符
        if self.cols != other.rows:
            raise ValueError("矩阵维度不匹配：无法进行点乘")

        # 初始化结果矩阵尺寸: self.rows x other.cols
        result = [[0] * other.cols for _ in range(self.rows)]
        for i in range(self.rows):
            for j in range(other.cols):
                for k in range(self.cols):
                    result[i][j] += self.data[i][k] * other.data[k][j]
        return SimpleMatrix(result)

    def __repr__(self):
        return "SimpleMatrix({})".format(self.data)

# 实例化两个 2x2 矩阵
m1 = SimpleMatrix([[1, 2], [3, 4]])
m2 = SimpleMatrix([[5, 6], [7, 8]])

# 在 Python 3.5+ 中直接使用 @ 进行矩阵乘法
m3 = m1 @ m2
print("m1 @ m2 运算结果:", m3)

# 1. 基础返回值验证：返回操作数本身而非布尔值
res1 = 0 and "Python"
res2 = 100 and "Python"
print("0 and 'Python'   ->", repr(res1))
print("100 and 'Python' ->", repr(res2))

res3 = "默认名称" or "备用名称"
res4 = "" or "备用名称"
print("'默认名称' or '备用名称' ->", repr(res3))
print("'' or '备用名称'         ->", repr(res4))

# 2. not 运算始终返回布尔类型
print("not ''       ->", not '')
print("not [1, 2]   ->", not [1, 2])

# 3. 短路求值防崩溃实战：避免 ZeroDivisionError 与 NoneAttribute 访问
denominator = 0
# 如果没有短路，denominator != 0 之后的 (10 / denominator) 会直接抛出 ZeroDivisionError
is_valid = (denominator != 0) and (10 / denominator > 1)
print("零分母守卫运算结果:", is_valid)

# 4. 函数调用触发验证
def trigger():
    print(">>> 警告: 右侧表达式 trigger() 被执行了!")
    return True

print("测试 False and trigger():")
result_a = False and trigger()   # trigger 不会执行

print("测试 True or trigger():")
result_b = True or trigger()    # trigger 不会执行

# 定义两个整型操作数
x = 10   # 二进制: 0b1010
y = 12   # 二进制: 0b1100

print("x = {:2d} (0b{:08b})".format(x, x))
print("y = {:2d} (0b{:08b})".format(y, y))
print("-" * 35)

# 1. 逻辑位运算
bit_and = x & y     # 0b1000 -> 8
bit_or  = x | y     # 0b1110 -> 14
bit_xor = x ^ y     # 0b0110 -> 6

print("x & y  = {:2d} (0b{:08b})".format(bit_and, bit_and))
print("x | y  = {:2d} (0b{:08b})".format(bit_or, bit_or))
print("x ^ y  = {:2d} (0b{:08b})".format(bit_xor, bit_xor))

# 2. 按位取反
bit_not = ~x        # -(10 + 1) = -11
print("~x     = {:2d} (数学公式: -(x + 1) = {})".format(bit_not, -(x + 1)))

# 3. 移位运算
shift_left  = x << 2   # 10 * 4 = 40 (0b00101000)
shift_right = x >> 1   # 10 // 2 = 5 (0b00000101)

print("x << 2 = {:2d} (0b{:08b})".format(shift_left, shift_left))
print("x >> 1 = {:2d} (0b{:08b})".format(shift_right, shift_right))

# 4. 负数右移测试（算术右移验证）
neg = -14
print("-14 >> 1 = {} (等价于 -14 // 2)".format(neg >> 1))

在C、C++及Python中，比较运算符（如 ==, !=, <, >）的优先级均高于按位与（&）、按位或（|）和按位异或（^）。

例如判断变量 flags 的最低位是否为1：若编写为 if flags & 1 == 1:，解释器实际会先计算 1 == 1（得到 True 即 1），再计算 flags & 1；而如果写成 if flags & 2 == 2:，则先计算 2 == 2 得到 1，最终变为 flags & 1，导致完全错误的逻辑判断！

# 陷阱 1：按位与 & 与比较 == 的优先级问题
state = 0b0010   # 十进制 2

# 错误写法：== 优先于 &
# 实际被解释为: state & (2 == 2) -> state & 1 -> 2 & 1 -> 0 -> False
if state & 2 == 2:
    print("错误写法判定为 True")
else:
    print("错误写法判定为 False (Bug发生！)")

# 正确写法：显式添加圆括号
if (state & 2) == 2:
    print("正确写法: 成功匹配状态位 2")

# 陷阱 2：连续幂运算的右结合特性
# 2 ** 3 ** 2 等价于 2 ** (3 ** 2) = 2 ** 9 = 512
# 而非 (2 ** 3) ** 2 = 8 ** 2 = 64
calc = 2 ** 3 ** 2
print("2 ** 3 ** 2 实际计算结果:", calc)

# 陷阱 3：加减法优先于位移
# 1 + 2 << 1 实际计算为 (1 + 2) << 1 = 3 << 1 = 6
# 而非 1 + (2 << 1) = 1 + 4 = 5
shift_calc = 1 + 2 << 1
print("1 + 2 << 1 实际计算结果:", shift_calc)