前言

本文系统介绍 Python 中的各类运算符，涵盖算术运算符、比较运算符、逻辑运算符以及其他运算符（位运算符、成员运算符、身份运算符）。通过学习本文，您将掌握：

1.各类运算符的基本语法和使用方法 2.运算符的优先级和结合性规则

3.运算符在实际编程中的应用场景 4.常见运算符的注意事项和最佳实践

无论您是 Python 初学者还是希望巩固基础知识的开发者，本文都将帮助您建立对 Python 运算符的全面理解。

下面是今天要介绍的运算符：

1. 幂运算：**
2. 乘、除、取余、整除：*、/、%、//
3. 比较运算符：>、<、>=、<=、==、!=
4. 身份运算符：is、is not
5. 成员运算符：in、not in
6. 逻辑非：not
7. 逻辑与：and
8. 逻辑或：or
9. 赋值运算符：=、+=、-= 等

算数运算符

我们都学过数学中的运算符号 加、减、乘、除、幂次方、开方，等等，笔者将介绍在Python 中的算数运算，主要有这些运算符 / 除 // 整除 % 取余 * 乘 ** 幂次（加减不再介绍） 。 Python 中的算术运算符用于执行基本的数学运算。

 /  除       a / b  （结果是小数 float）
 // 整除     a // b  得到一个整数
 %  取余     a % b   得到一个余数
 *  乘       a * b   得到乘积
 ** 幂次方   a ** b  a的b次幂 
a = 10
b = 3
c1 = a + b
c2 = a ** b   
c3 = b ** a   
c4 = a // b
c5 = b // a
c6 = b % a
c7 = a % b
print(c1, c2, c3, c4, c5, c6, c7)
输出: 13 1000 59049 3 0 3 1
print(100 / 3)   # 33.333333333333336
print(100 // 3)  # 33
运算等级
() 高于 **，其次 * / // %，然后 + -
print(2 ** 3 // 2)   # 4
print(2 ** 3 / 3)    # 2.6666666666666665
print(2 ** (5 / 3))  # 3.1748021039363987
print(3 ** 2 % 3)    # 0
任意两数字余 2 结果为 1，0
m % n 为 0 时，m 是 n 的倍数
任意数字余 m 有 m 种结果，结果为  0 -> m-1

比较运算符

比较运算符用于比较两个值，返回布尔值 True 或 False。

print(5 > 3)   # True
print(5 < 8)   # True
print(5 >= 5)  # True
print(5 != 5)  # False
print(5 == 5)  # True
运算优先级
算术运算符(** + - % / // *) > 比较运算符(> < >= <= != ==) > 赋值运算符(=)
a = 5 > 3
print(a)  # True
print(5 + 3 < 8 + 4)  # True
1 == True, 0 == False
print(1 == True, 0 == False)  # True True
a = 1 == True
print(a)  # True
b = 1 == False
c = 1 != False
d = int(b)
print(b, c, d)  # False True 0
print(int(5 + 3 < 8 + 4))  # 1
Python 支持连续比较
print(5 > 4 > 3 > 2 > 1 > 0)  # True
字符串比较
print("abc" == "abc")  # True
print("abc" >= "abc")  # True
print("abc" != "abc")  # False
字符串比较是对字符的编码逐个比较
print("a" < "b")      # True
print("b" < "c")      # True
print("abc" > "ac")   # False
print("abc" > "aaa")  # True
print("abc" > "eee")  # False
ord() 查看字母对应的码值，chr() 查看码值对应的字母
print(ord("a"))  # 97
print(ord("A"))  # 65
print(chr(97), chr(65))  # a A

逻辑运算符

逻辑运算符 and、or、not 用于组合条件判断。

# and 并且，or 或者，not 取反
# and 优先级高于 or
and 的返回值规则：
左侧为真，返回右侧
左侧为假，返回左侧
print(100 and 1)       # 1
print(True and False)  # False
print(True and 100)    # 100
print(False and False) # False
print(0 and True)      # 0
print(0 and False)     # 0
print("" and True)     # 空
print(None and True)   # None
or 的返回值规则：
左侧为真，返回左侧
左侧为假，返回右侧
print(100 or 1)        # 100
print(True or False)   # True
print(True or 100)     # True
print(False or False)  # False
print(0 or True)       # True
print(0 or False)      # False
print("" or True)      # True
print(None or True)    # True
not 取反，只返回 True 或 False
print(not 0)      # True
print(not False)  # True
print(not True)   # False
优先级示例
print(2 or 10 and 1)           # 2     (10 and 1 → 1, 2 or 1 → 2)
print(True and False or True)  # True  (True and False → False, False or True → True)
print(100 and not 0)           # True  (not 0 → True, 100 and True → True)
邪修
or 运算顺序：从左向右依次判断
遇到第一个真值（True）立刻停止，直接返回该真值，不再往右计算
全程没有真值，全部为假时，返回最后最右侧的值
假值（视为 False）：0、""、[]、{}、None、False，其余全部为真值（视为 True）
print(3 or 0)              # 3
print("abc" or [])         # abc
print(0 or 5 or 9)         # 5
print(0 or "" or None)     # None
print(False or [] or 0)    # 0
and 运算顺序：从左往右找假值，找到假立刻短路返回该假
全部为真，返回最右侧值
print(3 and 0 and 9)       # 0
print(2 and 5 and 8)       # 8
注意：or/and 返回的是原始数据本身，不是单纯的 True/False
res = 4 or 10
print(res)  # 输出 4，不是 True
if 4 or 10:  # 内部判断时才视作 True
print("成立")  # 成立

逻辑运算符邪修速记

# 邪修
or 运算顺序：从左向右依次判断
遇到第一个真值（True）立刻停止，直接返回该真值，不再往右计算
全程没有真值，全部为假时，返回最后最右侧的值
假值（视为 False）：0、""、[]、{}、None、False，其余全部为真值（视为 True）
print(3 or 0)              # 3
print("abc" or [])         # abc
print(0 or 5 or 9)         # 5
print(0 or "" or None)     # None
print(False or [] or 0)    # 0
and 运算顺序：从左往右找假值，找到假立刻短路返回该假
全部为真，返回最右侧值
print(3 and 0 and 9)       # 0
print(2 and 5 and 8)       # 8
*****注意：or/and 返回的是原始数据本身，不是单纯的 True/False
res = 4 or 10
print(res)  # 输出 4，不是 True
if 4 or 10:  # 内部判断时才视作 True
print("成立")  # 成立

其他运算符

包括位运算符、成员运算符和身份运算符。

# 位运算符
& 按位与的运算逻辑：同 1 才 1，否则 0
0b110010
0b111100
0b110000 → 48
print(int("110000", base=2))  # 48
| 按位或的运算逻辑：有 1 则 1，全 0 才 0
0b110010
0b111100
0b111110 → 62
print(int("111110", base=2))  # 62
^ 按位异或的运算逻辑：相同为 0，不同为 1
0b110010
0b111100
0b001110 → 14
print(int("001110", base=2))  # 14
a = 50
b = 60
print(a & b)  # 48
print(a | b)  # 62
print(a ^ b)  # 14
print(bin(50), bin(60))  # 0b110010 0b111100
成员运算符
print("h" in "hello")               # True
print(100 in (100, 200, 300))       # True
身份运算符
a = 10
print(a is 10)  # True

总结

本文详细介绍了 Python 中的各类运算符，以下是核心要点回顾：

算术运算符：用于基本数学运算，包括加(+)、减(-)、乘(*)、除(/)、整除(//)、取余(%)、幂(**)。

比较运算符：用于比较两个值，返回布尔值 True 或 False，包括大于(>)、小于(<)、大于等于(>=)、小于等于(<=)、等于(==)、不等于(!=)。

逻辑运算符：用于组合条件判断，包括 and（与）、or（或）、not（非）。and 优先级高于 or，短路求值是重要特性。

其他运算符：位运算符：&（按位与）、|（按位或）、^（按位异或）；成员运算符：in、not in；身份运算符：is、is not。

运算符优先级顺序（从高到低）：

1. 括号：()
2. 幂运算：**
3. 乘、除、取余、整除：*、/、%、//
4. 加、减：+、-
5. 比较运算符：>、<、>=、<=、==、!=
6. 身份运算符：is、is not
7. 成员运算符：in、not in
8. 逻辑非：not
9. 逻辑与：and
10. 逻辑或：or
11. 赋值运算符：=、+=、-= 等

掌握这些运算符的用法和优先级，是编写高效、可读 Python 代码的基础。建议在实际编码中多练习，加深理解。