B运算符与表达式.py

前言：在 Python 编程世界中，运算符就像搭积木的工具，表达式则是用这些工具堆砌出来的各式各样有趣的建筑。今天我来和大家一起聊聊 Python 中的运算符和表达式，我发现它们其实没那么高冷，反而挺接地气的，用好了能让代码简洁又高效。

目录

算术运算符：数学课代表上线

比较运算符：爱较真的小裁判

逻辑运算符：会 “偷懒” 的逻辑鬼才

位运算符：玩转二进制的幕后高手

赋值运算符：变量更新的小能手

成员运算符：爱找东西的小侦探

身份运算符：火眼金睛辨对象

实战场景：运算符的花式秀场

总结

算术运算符：数学课代表上线

先说说算术运算符吧，这玩意儿其实就是把数学课上的运算搬到代码里来啦。日常用的加减乘除都有，还有点额外的小功能。

a = 10
b = 3

# 加法运算
addition = a + b
print(f"{a} + {b} = {addition}")  # 输出：10 + 3 = 13

# 减法运算
subtraction = a - b
print(f"{a} - {b} = {subtraction}")  # 输出：10 - 3 = 7

# 乘法运算
multiplication = a * b
print(f"{a} * {b} = {multiplication}")  # 输出：10 * 3 = 30

# 除法运算（返回浮点数）
division = a / b
print(f"{a} / {b} = {division}")  # 输出：10 / 3 = 3.333...

# 取整除（返回整数商）
floor_division = a // b
print(f"{a} // {b} = {floor_division}")  # 输出：10 // 3 = 3

# 取模运算（返回余数）
modulo = a % b
print(f"{a} % {b} = {modulo}")  # 输出：10 % 3 = 1

# 指数运算
exponentiation = a ** b
print(f"{a} ** {b} = {exponentiation}")  # 输出：10 ** 3 = 1000

这些运算符我平时写小程序的时候经常用，比如说算俩数的平均值就用加法和除法，做单位换算之类的也离不开它们。

比较运算符：爱较真的小裁判

比较运算符就像是个爱较真的小裁判，老爱在俩值之间挑挑拣拣，最后给你个 “对” 或者 “错” 的结果。

x = 5
y = 7

# 等于
equal = x == y
print(f"{x} == {y} → {equal}")  # 输出：5 == 7 → False

# 不等于
not_equal = x != y
print(f"{x} != {y} → {not_equal}")  # 输出：5 != 7 → True

# 大于
greater_than = x > y
print(f"{x} > {y} → {greater_than}")  # 输出：5 > 7 → False

# 小于
less_than = x < y
print(f"{x} < {y} → {less_than}")  # 输出：5 < 7 → True

# 大于等于
greater_or_equal = x >= y
print(f"{x} >= {y} → {greater_or_equal}")  # 输出：5 >= 7 → False

# 小于等于
less_or_equal = x <= y
print(f"{x} <= {y} → {less_or_equal}")  # 输出：5 <= 7 → True

我写条件判断的时候就离不开这些小裁判啦，比如说判断用户输入的年龄是不是成年了，或者分数是不是及格了，全靠它们来帮我省事儿。

逻辑运算符：会 “偷懒” 的逻辑鬼才

逻辑运算符看着高深，其实挺有意思，它们有点 “偷懒” 的小聪明，能少算就少算。

p = True
q = False

# 逻辑与
logical_and = p and q
print(f"{p} 与 {q} → {logical_and}")  # 输出：True 与 False → False

# 逻辑或
logical_or = p or q
print(f"{p} 或 {q} → {logical_or}")  # 输出：True 或 False → True

# 逻辑非
logical_not_p = not p
logical_not_q = not q
print(f"{p} 的反义词 → {logical_not_p}")  # 输出：True 的反义词 → False
print(f"{q} 的反义词 → {logical_not_q}")  # 输出：False 的反义词 → True

写复杂条件的时候，逻辑运算符简直是救星。比如说判断用户是不是既成年了又通过了验证，或者是不是学生或者老师，这些情况用逻辑运算符一组合，条件判断就清晰多了。

位运算符：玩转二进制的幕后高手

位运算符就像是一群玩二进制的幕后高手，直接在比特位上做文章，看着挺神秘，其实掌握了规律也就那么回事儿。

c = 6  # 二进制 110
d = 4  # 二进制 100

# 位与
bitwise_and = c & d
print(f"{c} & {d} → {bitwise_and} (二进制 {bin(bitwise_and)})")  # 输出：6 & 4 → 4 (0b100)

# 位或
bitwise_or = c | d
print(f"{c} | {d} → {bitwise_or} (二进制 {bin(bitwise_or)})")  # 输出：6 | 4 → 6 (0b110)

# 位异或
bitwise_xor = c ^ d
print(f"{c} ^ {d} → {bitwise_xor} (二进制 {bin(bitwise_xor)})")  # 输出：6 ^ 4 → 2 (0b010)

# 左移
left_shift = c << 1
print(f"{c} << 1 → {left_shift} (二进制 {bin(left_shift)})")  # 输出：6 << 1 → 12 (0b1100)

# 右移
right_shift = c >> 1
print(f"{c} >> 1 → {right_shift} (二进制 {bin(right_shift)})")  # 输出：6 >> 1 → 3 (0b11)

我感觉在处理一些特别底层的、和硬件打交道的代码时候，位运算符应该挺吃香的。比如说搞通信协议解析或者压缩算法的时候，说不定就能派上大用场。

赋值运算符：变量更新的小能手

赋值运算符就是专门干更新变量值这活儿的，有了它，代码看着整洁多了。

e = 5
e += 3  # 相当于 e = e + 3
print(f"e += 3 → e = {e}")  # 输出：e += 3 → e = 8

e -= 2  # 相当于 e = e - 2
print(f"e -= 2 → e = {e}")  # 输出：e -= 2 → e = 6

e *= 4  # 相当于 e = e * 4
print(f"e *= 4 → e = {e}")  # 输出：e *= 4 → e = 24

e /= 2  # 相当于 e = e / 2
print(f"e /= 2 → e = {e}")  # 输出：e /= 2 → e = 12.0

我写循环或者需要频繁更新变量值的小工具程序的时候，这些赋值运算符真是省了不少事儿，代码看着也简洁利落。

成员运算符：爱找东西的小侦探

成员运算符就像是个爱找东西的小侦探，在序列里头帮咱找值，特别方便。

fruits = ["苹果", "香蕉", "樱桃"]

# in 运算符
contains_apple = "苹果" in fruits
print(f"'苹果' 在列表里 → {contains_apple}")  # 输出：'苹果' 在列表里 → True

contains_orange = "欧润吉" in fruits
print(f"'欧润吉' 在列表里 → {contains_orange}")  # 输出：'欧润吉' 在列表里 → False

# not in 运算符
not_contains_orange = "欧润吉" not in fruits
print(f"'欧润吉' 不在列表里 → {not_contains_orange}")  # 输出：'欧润吉' 不在列表里 → True

平常处理列表、字符串这些数据的时候，成员运算符用起来贼方便。比如说判断用户输入的单词是不是在某个词库里，或者某个字符是不是在特定字符串里，用它一查便知。

身份运算符：火眼金睛辨对象

身份运算符就是有双火眼金睛，能分辨出俩对象是不是一个 “人”。

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

# is 运算符
a_is_b = a is b
a_is_c = a is c
print(f"a is b → {a_is_b}")  # 输出：a is b → True
print(f"a is c → {a_is_c}")  # 输出：a is c → False

# is not 运算符
a_is_not_c = a is not c
print(f"a is not c → {a_is_not_c}")  # 输出：a is not c → True

这个在处理一些对对象身份敏感的场景时还挺关键的，比如说判断俩变量是不是指向同一个列表，方便咱们搞清楚数据的引用关系。

实战场景：运算符的花式秀场

运算符可不是摆设，在实际编程里头用处大着呢。就说说数据过滤吧：

# 过滤价格大于 100 且库存大于 0 的商品
products = [
    {"名字": "mac", "价格": 9999, "库存": 5},
    {"名字": "IPhone 16 pro max 1t", "价格": 8999, "库存": 0},
    {"名字": "平板", "价格": 2999, "库存": 3}
]

available_products = [
    product for product in products 
    if product["价格"] > 100 and product["库存"] > 0
]

print(available_products)
# 输出：[{'名字': 'mac', '价格': 9999, '库存': 5}, {'名字': '平板', '价格': 2999, '库存': 3}]

算数学公式的时候也超方便：

# 计算圆的面积和周长
radius = 5
pi = 3.14159

area = pi * radius ** 2  # 使用指数运算符
circumference = 2 * pi * radius

print(f"面积: {area}, 周长: {circumference}")
# 面积: 78.53975, 周长: 31.4159

搞点位操作优化的时候也行：

# 判断一个数是否为 2 的幂次方
def is_power_of_two(n):
    return n > 0 and (n & (n - 1)) == 0

print(is_power_of_two(8))  # 输出：True
print(is_power_of_two(10)) # 输出：False

总结

Python 运算符种类不少，但我觉得只要把它们当成编程路上的得力助手就行啦。算术运算符帮我算数，比较运算符给我当裁判，逻辑运算符帮我理清复杂条件，位运算符在底层搞事情，赋值运算符让变量更新整洁利落，成员运算符帮我找东西，身份运算符给我辨对象。它们虽然看着功能各异，但其实都是为了让咱们写代码的时候更轻松、更高效。

我感觉只要平时多用用，把这些运算符的习性摸熟了，在写代码的时候就能顺手拈来，把复杂的问题简单化。要是大家还有什么特别妙的运算符用法，咱们也可以一起交流交流，说不定能碰撞出新的灵感火花呢！