Python运算符：//整除、**幂运算、and/or/not，这些C语言里没有的运算符

运算符是编程的基础工具，用于执行各种计算和逻辑操作。Python的运算符与C语言大体相似，但也有一些独特之处（如//整除、**幂运算、and/or/not逻辑运算）。本篇将详细介绍Python的各类运算符及其使用方法。

• Python运算符与表达式
  • 1. 算术运算符
  • 2. 比较运算符
  • 3. 赋值运算符
  • 4. 逻辑运算符
  • 5. 位运算符
  • 6. 成员运算符
  • 7. 身份运算符
  • 8. 运算符优先级
  • 9. 海象运算符（Python 3.8+）
  • 10. Python vs C语言运算符对比
  • 11. 常见错误与避坑
  • 12. 实战练习
  • 13. 总结
  • 📖 下一步学习

1. 算术运算符

# 基本算术运算
a, b = 7, 2

print(f"加法：{a} + {b} = {a + b}")      # 9
print(f"减法：{a} - {b} = {a - b}")      # 5
print(f"乘法：{a} * {b} = {a * b}")      # 14
print(f"除法：{a} / {b} = {a / b}")      # 3.5
print(f"整除：{a} // {b} = {a // b}")    # 3
print(f"取模：{a} % {b} = {a % b}")      # 1
print(f"幂运算：{a} ** {b} = {a ** b}")  # 49

# 注意：Python的/是真除法
print(7 / 2)   # 3.5（Python 3）
# C语言：7 / 2 = 3（整数除法）

# 整除的向下取整特性
print(7 // 2)    # 3
print(-7 // 2)   # -4（向下取整，不是-3）
print(7 // -2)   # -4

# 幂运算
print(2 ** 10)   # 1024
print(2 ** 0.5)  # 1.414...（平方根）
print(8 ** (1/3))  # 2.0（立方根）

# 取模的应用
# 判断奇偶
num = 17
if num % 2 == 0:
    print("偶数")
else:
    print("奇数")

# 循环索引
for i in range(10):
    print(i % 3, end=" ")  # 0 1 2 0 1 2 0 1 2 0

与C语言的区别：

2. 比较运算符

a, b = 5, 3

print(a == b)  # False
print(a != b)  # True
print(a > b)   # True
print(a < b)   # False
print(a >= b)  # True
print(a <= b)  # False

# 链式比较（Python特色！）
x = 5
print(1 < x < 10)      # True（等价于 1 < x and x < 10）
print(1 < x < 3)       # False
print(1 <= x <= 10)    # True

# C语言中需要写成：1 < x && x < 10

# 字符串比较（按字典序）
print("apple" < "banana")  # True
print("abc" < "abd")       # True

# 列表比较（逐元素比较）
print([1, 2, 3] < [1, 2, 4])  # True
print([1, 2] < [1, 2, 3])     # True（长度短的更小）

# 注意：不同类型比较
# Python 3中，不同类型通常不能比较
# print(5 < "3")  # TypeError

3. 赋值运算符

# 复合赋值运算符
x = 10
x += 5   # x = 15
x -= 3   # x = 12
x *= 2   # x = 24
x //= 5  # x = 4
x **= 2  # x = 16

# 多重赋值
a = b = c = 0
print(a, b, c)  # 0 0 0

# 解包赋值
x, y, z = 1, 2, 3
print(x, y, z)  # 1 2 3

# 交换变量
a, b = 10, 20
a, b = b, a
print(a, b)  # 20 10

# 扩展解包（Python 3）
first, *rest = [1, 2, 3, 4, 5]
print(first)  # 1
print(rest)   # [2, 3, 4, 5]

*start, last = [1, 2, 3, 4, 5]
print(start)  # [1, 2, 3, 4]
print(last)   # 5

# 注意：Python没有++和--运算符
# x++  # SyntaxError
x += 1  # 正确写法

4. 逻辑运算符

# 基本逻辑运算
print(True and True)   # True
print(True and False)  # False
print(True or False)   # True
print(False or False)  # False
print(not True)        # False
print(not False)       # True

# 与C语言对比
# C: && || !
# Python: and or not

# 短路求值
# and：第一个为False时，不计算第二个
# or：第一个为True时，不计算第二个

def check():
    print("check被调用")
    return True

print(False and check())  # False（check不会被调用）
print(True or check())    # True（check不会被调用）

# 逻辑运算符返回值（不一定是布尔值！）
# and：返回第一个假值，或最后一个值
# or：返回第一个真值，或最后一个值

print(1 and 2 and 3)    # 3（最后一个值）
print(1 and 0 and 3)    # 0（第一个假值）
print(0 or "" or [])    # []（最后一个值）
print(0 or 1 or 2)      # 1（第一个真值）

# 实际应用：默认值
name = ""
display_name = name or "匿名用户"
print(display_name)  # "匿名用户"

# 实际应用：条件执行
debug = True
debug and print("调试信息")  # 会打印

# 组合使用
age = 25
is_student = True
if age >= 18 and (is_student or age < 30):
    print("符合条件")

5. 位运算符

位运算符对整数的二进制位进行操作，在FPGA开发中非常常用。

# 位运算示例
a = 0b0101  # 5
b = 0b0011  # 3

print(f"a = {a:04b} ({a})")  # 0101 (5)
print(f"b = {b:04b} ({b})")  # 0011 (3)

# 按位与（都为1才为1）
print(f"a & b = {a & b:04b} ({a & b})")  # 0001 (1)

# 按位或（有1就为1）
print(f"a | b = {a | b:04b} ({a | b})")  # 0111 (7)

# 按位异或（不同为1）
print(f"a ^ b = {a ^ b:04b} ({a ^ b})")  # 0110 (6)

# 按位取反（0变1，1变0）
print(f"~a = {~a} ({bin(~a & 0xFF)})")  # -6 (0b11111010)

# 左移（乘以2的n次方）
print(f"a << 1 = {a << 1:04b} ({a << 1})")  # 1010 (10)
print(f"a << 2 = {a << 2:04b} ({a << 2})")  # 10100 (20)

# 右移（除以2的n次方）
print(f"a >> 1 = {a >> 1:04b} ({a >> 1})")  # 0010 (2)

# FPGA常用操作
# 1. 提取特定位
data = 0b11010110
bit3 = (data >> 3) & 1  # 提取第3位
print(f"第3位：{bit3}")  # 0

# 2. 设置特定位为1
data = 0b11010110
data = data | (1 << 3)  # 设置第3位为1
print(f"设置后：{data:08b}")  # 11011110

# 3. 清除特定位为0
data = 0b11010110
data = data & ~(1 << 2)  # 清除第2位
print(f"清除后：{data:08b}")  # 11010010

# 4. 翻转特定位
data = 0b11010110
data = data ^ (1 << 4)  # 翻转第4位
print(f"翻转后：{data:08b}")  # 11000110

# 5. 提取多位字段
data = 0b11010110
field = (data >> 2) & 0b111  # 提取第2-4位
print(f"字段值：{field:03b} ({field})")  # 101 (5)

# 6. 掩码操作
mask = 0x0F  # 低4位掩码
data = 0xAB
low_nibble = data & mask
high_nibble = (data >> 4) & mask
print(f"低4位：{low_nibble:X}, 高4位：{high_nibble:X}")  # B, A

6. 成员运算符

# 字符串
print('a' in 'abc')      # True
print('d' in 'abc')      # False
print('ab' in 'abc')     # True（子串）

# 列表
fruits = ['apple', 'banana', 'cherry']
print('apple' in fruits)     # True
print('orange' in fruits)    # False
print('orange' not in fruits)  # True

# 元组
point = (3, 4, 5)
print(3 in point)  # True

# 字典（检查键）
person = {'name': '张三', 'age': 25}
print('name' in person)    # True
print('张三' in person)    # False（检查的是键，不是值）
print('张三' in person.values())  # True

# 集合
numbers = {1, 2, 3, 4, 5}
print(3 in numbers)  # True

# 实际应用
valid_commands = {'start', 'stop', 'restart', 'status'}
user_input = 'start'
if user_input in valid_commands:
    print("有效命令")
else:
    print("无效命令")

7. 身份运算符

# is vs ==
# is：比较对象的身份（内存地址）
# ==：比较对象的值

a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a == b)   # True（值相等）
print(a is b)   # False（不是同一对象）
print(a is c)   # True（是同一对象）

# 查看对象id
print(id(a))  # 如：140234567890
print(id(b))  # 如：140234567891（不同）
print(id(c))  # 如：140234567890（与a相同）

# None的比较（推荐用is）
x = None
print(x is None)      # True（推荐）
print(x == None)      # True（不推荐）

# 小整数缓存（Python优化）
a = 256
b = 256
print(a is b)  # True（小整数被缓存）

a = 257
b = 257
print(a is b)  # False（大整数不缓存）

# 字符串驻留
s1 = "hello"
s2 = "hello"
print(s1 is s2)  # True（短字符串被驻留）

s1 = "hello world!"
s2 = "hello world!"
print(s1 is s2)  # 可能是False（长字符串不一定驻留）

⚠️ 最佳实践：

• 比较值用==
• 比较None用is
• 不要依赖小整数缓存或字符串驻留

8. 运算符优先级

从高到低排列：

# 优先级示例
print(2 + 3 * 4)      # 14（先乘后加）
print((2 + 3) * 4)    # 20（括号优先）
print(2 ** 3 ** 2)    # 512（幂运算右结合：2^(3^2)=2^9）
print(True or False and False)  # True（and优先于or）

# 建议：复杂表达式使用括号明确优先级
result = (a + b) * c / (d - e)

# 位运算优先级陷阱
x = 1 << 2 + 3  # 1 << 5 = 32（+优先于<<）
x = (1 << 2) + 3  # 4 + 3 = 7（明确优先级）

9. 海象运算符（Python 3.8+）

海象运算符:=允许在表达式中赋值。

# 传统写法
line = input("输入：")
while line != "quit":
    print(f"你输入了：{line}")
    line = input("输入：")

# 使用海象运算符
while (line := input("输入：")) != "quit":
    print(f"你输入了：{line}")

# 在条件中使用
data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
if (n := len(data)) > 5:
    print(f"数据量{n}超过5个")

# 在列表推导式中使用
# 避免重复计算
import re
text = "apple 123 banana 456 cherry 789"
numbers = [int(match.group()) for word in text.split() 
           if (match := re.match(r'\d+', word))]
print(numbers)  # [123, 456, 789]

# 实际应用：读取文件
with open("data.txt") as f:
    while (line := f.readline()):
        print(line.strip())

10. Python vs C语言运算符对比

# 三元运算符对比
# C: result = (a > b) ? a : b;
# Python:
result = a if a > b else b

# 更复杂的条件表达式
grade = "A" if score >= 90 else "B" if score >= 80 else "C" if score >= 70 else "D"

# 等价于
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
else:
    grade = "D"

11. 常见错误与避坑

❌ 错误1：混淆=和==

# 错误：在条件中使用=
# if x = 10:  # SyntaxError（Python不允许）

# 正确
if x == 10:
    pass

# 海象运算符是特例
if (x := get_value()) > 10:
    pass

❌ 错误2：浮点数比较

# 错误：直接比较浮点数
if 0.1 + 0.2 == 0.3:  # False！
    print("相等")

# 正确：使用误差范围
if abs(0.1 + 0.2 - 0.3) < 1e-9:
    print("相等")

# 或使用math.isclose
import math
if math.isclose(0.1 + 0.2, 0.3):
    print("相等")

❌ 错误3：is和==混用

# 错误：用is比较值
a = [1, 2, 3]
b = [1, 2, 3]
if a is b:  # False（不是同一对象）
    print("相等")

# 正确：用==比较值
if a == b:  # True
    print("相等")

# 但比较None时用is
if x is None:
    pass

❌ 错误4：位运算优先级

# 错误：位运算优先级低于比较运算
if x & 1 == 1:  # 实际是 x & (1 == 1) = x & True = x & 1
    pass

# 正确：使用括号
if (x & 1) == 1:
    pass

❌ 错误5：逻辑运算符返回值

# 可能的误解
result = 1 and 2  # 结果是2，不是True
result = 0 or ""  # 结果是""，不是False

# 如果需要布尔值
result = bool(1 and 2)  # True

12. 实战练习

练习1：位操作工具

"""
练习：实现位操作工具函数（FPGA开发常用）
"""

def get_bit(value, bit_pos):
    """获取指定位的值"""
    return (value >> bit_pos) & 1

def set_bit(value, bit_pos):
    """设置指定位为1"""
    return value | (1 << bit_pos)

def clear_bit(value, bit_pos):
    """清除指定位为0"""
    return value & ~(1 << bit_pos)

def toggle_bit(value, bit_pos):
    """翻转指定位"""
    return value ^ (1 << bit_pos)

def get_bits(value, start, length):
    """获取指定位域的值"""
    mask = (1 << length) - 1
    return (value >> start) & mask

# 测试
data = 0b11010110
print(f"原始值：{data:08b}")
print(f"第3位：{get_bit(data, 3)}")
print(f"设置第3位：{set_bit(data, 3):08b}")
print(f"清除第2位：{clear_bit(data, 2):08b}")
print(f"翻转第4位：{toggle_bit(data, 4):08b}")
print(f"第2-4位：{get_bits(data, 2, 3):03b}")

练习2：成绩等级判断

"""
练习：使用条件表达式判断成绩等级
"""

def get_grade(score):
    """根据分数返回等级"""
    return ("A" if score >= 90 else
            "B" if score >= 80 else
            "C" if score >= 70 else
            "D" if score >= 60 else
            "F")

# 测试
scores = [95, 82, 75, 63, 45]
for score in scores:
    print(f"分数：{score}，等级：{get_grade(score)}")

练习3：表达式计算器

"""
练习：简单的表达式计算器
"""

def calculate(a, b, operator):
    """执行二元运算"""
    operations = {
        '+': lambda x, y: x + y,
        '-': lambda x, y: x - y,
        '*': lambda x, y: x * y,
        '/': lambda x, y: x / y if y != 0 else "除数不能为0",
        '//': lambda x, y: x // y if y != 0 else "除数不能为0",
        '%': lambda x, y: x % y if y != 0 else "除数不能为0",
        '**': lambda x, y: x ** y,
        '&': lambda x, y: x & y,
        '|': lambda x, y: x | y,
        '^': lambda x, y: x ^ y,
    }
    
    if operator in operations:
        return operations[operator](a, b)
    else:
        return "不支持的运算符"

# 测试
print(calculate(10, 3, '+'))   # 13
print(calculate(10, 3, '**'))  # 1000
print(calculate(10, 3, '&'))   # 2

13. 总结

🔑 核心要点

✅ 学习检查清单

• 掌握Python除法（/和//）的区别
• 理解逻辑运算符的短路求值和返回值
• 熟练使用位运算符
• 理解is和==的区别
• 了解运算符优先级
• 能使用条件表达式（三元运算符）

📖 下一步学习

掌握了运算符后，让我们学习Python的流程控制：

常见问题 FAQ

💬 is和==到底什么区别？

==比较值是否相等，is比较是否是同一个对象（内存地址相同）。判断None必须用is None，不要用== None。

💬 Python的and/or返回值不是布尔？

是的。x and y如果x为假返回x，否则返回y。x or y如果x为真返回x，否则返回y。常用技巧：name = input() or "默认名"。

� 系列导航

• 上一篇：05 - Python容器类型详解
• 当前：06 - Python运算符与表达式
• 下一篇：07 - Python流程控制