【python基础】运算符与布尔值全解析

一、引言

运算符是Python处理数据的“工具”，布尔值是判断逻辑的“开关”。掌握它们的用法，能让你写出更高效、更易读的代码。本文将系统讲解布尔值、逻辑运算符、比较运算符、位运算符、增强赋值运算符、同一运算符、整数缓存、成员运算符和运算符优先级，结合代码示例，帮你彻底搞懂这些核心知识点。

二、布尔值：True/False的底层逻辑

布尔值（bool）是Python表示“真假”的类型，只有两个值：True（真）和False（假）。其底层是整数的子类（True对应1，False对应0），因此可以和整数运算。

1. 布尔值与整数的关系

a = True  # True == 1
b = 3
c = a + b  # 1 + 3 = 4
print(c)  # 输出：4

2. 哪些值是“假值”？

Python中，以下值会被视为False（其余均为True）：

• None（空值）
• 0（整数/浮点数/复数的0）
• 空容器（""空字符串、[]空列表、()空元组、{}空字典、set()空集合）
• False本身

代码示例：

print(bool(""))     # 输出：False（空字符串）
print(bool([]))     # 输出：False（空列表）
print(bool(None))   # 输出：False（空值）
print(bool(0))      # 输出：False（整数0）

3. 非空字符串的布尔值

注意：非空字符串（即使内容是"False"）的布尔值都是True。

print(bool("False"))  # 输出：True（非空字符串）
print(bool("True"))   # 输出：True（非空字符串）

三、逻辑运算符：短路求值的效率技巧

逻辑运算符用于连接布尔表达式，返回布尔值。Python中的逻辑运算符有三个：and（与）、or（或）、not（非）。

1. 核心规则

运算符	描述	短路逻辑
and	两个都为True才返回True	左为False，右不执行
or	有一个为True就返回True	左为True，右不执行
not	取反（True→False，False→True）	无短路

2. 短路求值示例

# and：左为False，右不执行
print(0 and 1)  # 输出：0（0是False，1不执行）# or：左为True，右不执行
print(1 or 0)   # 输出：1（1是True，0不执行）# not：取反
print(not True) # 输出：False
print(not 0)    # 输出：True（0是False，取反为True）

3. 短路的优势

短路求值能避免不必要的计算，提高效率。例如判断用户是否登录且是否是管理员：

if user.is_logged_in() and user.is_admin():# 执行管理员操作

如果user.is_logged_in()返回False，后面的user.is_admin()不会执行，节省了一次函数调用。

四、比较运算符：连续判断与简洁写法

比较运算符用于比较两个值的大小或相等性，返回布尔值。Python支持连续比较，写法更简洁。

1. 常用比较运算符

运算符	描述	示例
==	等于	10 == 10.0 → True
!=	不等于	10 != 5 → True
>	大于	10 > 5 → True
>=	大于等于	10 >= 10 → True
<	小于	5 < 10 → True
<=	小于等于	5 <= 10 → True

2. 连续比较（推荐）

连续比较等价于用and连接多个表达式，写法更简洁。

print(1 < 2 < 3)    # 等价于1<2 and 2<3 → True
print(5 > 3 >= 2)   # 等价于5>3 and 3>=2 → True
print(10 == 10.0)   # 输出：True（值相等，类型不同）

五、位运算符：二进制层面的操作

位运算符用于处理整数的二进制位，返回整数。常用位运算符如下：

1. 位运算符列表

运算符	描述	示例（a=5→0b101，b=3→0b011）
&	按位与（对应位都为1才为1）	a&b→0b001→1
`	`	按位或（对应位有1就为1）
^	按位异或（对应位不同才为1）	a^b→0b110→6
~	按位取反（0变1，1变0，结果为补码）	~a→-6（~x = -(x+1)）
<<	左移（左移n位，等价于×2ⁿ）	a<<1→0b1010→10
>>	右移（右移n位，等价于÷2ⁿ，整数除法）	a>>1→0b10→2

2. 代码示例

a = 5  # 二进制：0b101
b = 3  # 二进制：0b011print(a & b)  # 输出：1（0b001）
print(a | b)  # 输出：7（0b111）
print(a ^ b)  # 输出：6（0b110）
print(~a)     # 输出：-6（补码）
print(a << 1) # 输出：10（左移1位，×2）
print(a >> 1) # 输出：2（右移1位，÷2）

3. bin()函数：查看二进制

用bin()函数可以将整数转换为二进制字符串，便于调试位运算。

print(bin(a))  # 输出：0b101（5的二进制）
print(bin(b))  # 输出：0b011（3的二进制）

六、增强赋值运算符：简写与效率

增强赋值运算符是赋值运算符+算术/位运算符的结合，用于简化变量更新操作。其优势是减少一次变量查找，效率更高。

1. 常用增强赋值运算符

运算符	描述	示例
+=	加法赋值（整数/字符串拼接）	a += 3 → a = a+3
-=	减法赋值	a -= 3 → a = a-3
*=	乘法赋值（整数/字符串重复）	a *= 3 → a = a*3
/=	浮点除赋值	a /= 3 → a = a/3
//=	整数除赋值	a //= 3 → a = a//3
%=	取余赋值	a %= 3 → a = a%3
**=	幂运算赋值	a **= 3 → a = a**3

2. 代码示例

# 整数加法赋值
a = 5
a += 3  # 等价于a = a+3 →8
print(a)  # 输出：8# 字符串拼接赋值
s = "hello"
s += "world"  # 等价于s = s+"world" →"helloworld"
print(s)  # 输出：helloworld# 字符串重复赋值
t = "a"
t *= 3  # 等价于t = t*3 →"aaa"
print(t)  # 输出：aaa

七、同一运算符：is与==的区别

同一运算符用于判断两个变量是否引用同一个对象（地址相同），而==用于判断值是否相同（内容相同）。

1. 核心区别

运算符	比较内容	示例
==	值（equality）	[1,2,3] == [1,2,3] → True
is	地址（identity）	[1,2,3] is [1,2,3] → False（地址不同）

2. 代码示例

# 值相同，地址不同（列表是可变对象）
a = [1,2,3]
b = [1,2,3]
print(a == b)  # 输出：True（值相同）
print(a is b)  # 输出：False（地址不同）# 值相同，地址相同（整数缓存）
c = 100
d = 100
print(c == d)  # 输出：True
print(c is d)  # 输出：True（100在缓存范围内）

八、整数缓存：为什么1000 is 1000返回False？

整数缓存是Python的优化机制，用于减少内存分配。Python默认缓存**-5到256**之间的整数，这些数的is比较会返回True（复用对象）；超过这个范围的整数，会创建新对象，is比较返回False（除非在同一个代码块中，解释器优化复用）。

1. 缓存范围示例

# 缓存范围内（-5~256）
a = 256
b = 256
print(a is b)  # 输出：True（复用对象）# 超过缓存范围（257）
c = 257
d = 257
print(c is d)  # 输出：False（创建新对象，交互式环境）

2. 代码块内的优化

在同一个代码块中，超过256的整数如果值相同，解释器会复用对象，is比较返回True。

# 脚本中（同一个代码块）
e = 257
f = 257
print(e is f)  # 输出：True（解释器优化）

九、成员运算符：判断元素是否在容器中

成员运算符用于判断元素是否存在于容器（列表、字符串、字典、集合）中，返回布尔值。

1. 常用成员运算符

运算符	描述	示例
in	元素存在	"a" in "apple" → True
not in	元素不存在	"b" not in "apple" → True

2. 代码示例

# 列表：判断元素是否存在
lst = [1,2,3,4,5]
print(3 in lst)  # 输出：True# 字符串：判断子字符串是否存在
s = "hello world"
print("hello" in s)  # 输出：True# 字典：判断键是否存在（判断值用.values()）
d = {"name":"张三", "age":18}
print("name" in d)  # 输出：True（判断键）
print("张三" in d.values())  # 输出：True（判断值）

十、运算符优先级：复杂表达式的正确姿势

运算符优先级决定了表达式的执行顺序。掌握优先级可以避免逻辑错误，但复杂表达式建议用括号（提高可读性）。

1. 简化版优先级（从高到低）

1. 括号（()）：最高优先级，改变运算顺序。
2. 幂运算（**）：如2**3=8。
3. 正负号（+x, -x）：如-5。
4. 算术运算：*, /, //, %（乘、除、整数除、取余）；+, -（加、减）。
5. 位运算：<<, >>（左移、右移）；&（按位与）；^（按位异或）；|（按位或）。
6. 比较运算：==, !=, >, >=, <, <=；is, is not；in, not in。
7. 逻辑运算：not；and；or。
8. 赋值运算：=, +=, -=, *=, 等。

2. 示例说明

# 算术运算：乘除优先于加减
print(3 + 5 * 2)  # 输出：13（3+10）
print((3 + 5) * 2)  # 输出：16（括号改变顺序）# 比较运算优先于逻辑运算
print(3 > 2 and 2 < 4)  # 输出：True（3>2为True，2<4为True）# 逻辑运算：not > and > or
print(not 3 > 2 and 2 < 4)  # 输出：False（not True and True → False）# 赋值运算最后执行
a = 3 + 5  # 先计算3+5=8，再赋值给a
print(a)  # 输出：8

十一、总结

本文覆盖了Python运算符与布尔值的核心知识点，重点总结：

1. 布尔值：True对应1，False对应0，空容器、None、0为假值。
2. 逻辑运算符：短路求值提高效率，and前假不执行后，or前真不执行后。
3. 比较运算符：支持连续判断，写法更简洁。
4. 位运算符：处理二进制位，bin()函数查看二进制。
5. 增强赋值运算符：简写形式，效率更高。
6. 同一运算符：is比较地址，==比较值，整数缓存影响is结果。
7. 成员运算符：判断元素是否在容器中，字典判断键。
8. 运算符优先级：复杂表达式用括号，提高可读性。

如果本文对你有帮助，欢迎点赞、收藏，评论区留言交流~ 😊