Python3 运算符

在 Python3 中，运算符就是一串符号，用来对变量或值进行计算、比较、判断、赋值等操作。下面将分别介绍 Python3 中的算术、比较、赋值、位运算符。

算术运算符

算术运算符就是用来做数学计算的符号，主要用于数字之间的加减乘除等运算。

在 Python3 中，提供的算术运算符如下表：

示例：演示算术运算符的用法。

# 定义两个数字
a = 10
b = 3

# 1. 加法 +
print("加法：", a + b)   # 13

# 2. 减法 -
print("减法：", a - b)   # 7

# 3. 乘法 *
print("乘法：", a * b)   # 30

# 4. 除法 / （结果是小数）
print("除法：", a / b)   # 3.3333333333333335

# 5. 整除 // （只取整数部分）
print("整除：", a // b)  # 3

# 6. 取余 % （求余数）
print("取余：", a % b)   # 1

# 7. 幂运算 ** （次方）
print("平方：", a ** 2)  # 100
print("立方：", a ** 3)  # 1000

比较运算符

比较运算符就是用来比较两个值的大小、是否相等的，比较结果只会是 True（真）或 False（假）。

在 Python3 中，提供的比较运算符如下表：

示例：

a = 10
b = 3

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

Python广告

赋值运算符

赋值运算符就是用来给变量赋值的符号，最基础的是 =，还有一系列简写的复合赋值，如 +=、*= 等等。

在 Python3 中，提供的赋值运算符如下表：

示例：

a = 10

a += 2   # a = 10 + 2 → 12
print(a)

a -= 3   # a = 12 - 3 → 9
print(a)

a *= 2   # a = 9 * 2  → 18
print(a)

a /= 3   # a = 18 / 3 → 6.0
print(a)

a //= 2  # a = 6 // 2 → 3
print(a)

a %= 2   # a = 3 % 2  → 1
print(a)

a **= 3  # a = 1 ** 3 → 1
print(a)

海象运算符（Walrus Operator）是在 Python 3.8 及更高版本中引入的一种新的语法特性，它使用 := 符号进行表示。这个运算符的主要目的是在表达式中同时进行赋值和返回赋值的值。

使用海象运算符可以在一些情况下简化代码，尤其是在需要在表达式中使用赋值结果的情况下。这对于简化循环条件或表达式中的重复计算很有用。

下面是一个简单的实例，演示了海象运算符的使用：

# 传统写法
n = 10
if n > 5:
 print(n)  # 输出：10

# 使用海象运算符
if (n := 10) > 5:  # 这里将 10 赋值给 n，并且返回 10，最后就是 10 > 5 比较运算
 print(n)  # 输出：10

位运算符

位运算就是直接对二进制位（0 和 1）进行操作的运算，速度非常快，主要用于底层操作、加密、状态判断等场景。

在 Python3 中，提供的位运算符如下表：

运算符	描述
&	按位与运算符：参与运算的两个值，如果两个相应二进制位都为 1，则该位的结果为1。否则为 0。如下图：
|	按位或运算符：只要对应的两个二进制位有一个为1时，结果位就为1。如下图：
^	按位异或运算符：当对应的二进制位相异时（即一个 1 、一个 0），结果位就为1。否则，结果位为 0。如下图：
~	按位取反运算符：对数据的每个二进制位取反，即把 1 变为 0，把 0 变为 1。~x 类似于 -x-1，如下图：
<<	左移动运算符：运算数的各二进位全部左移若干位，由“<<”右边的数指定移动的位数，高位丢弃，低位补 0。
>>	右移动运算符：把“>>”左边的运算数的各二进位全部右移若干位，“>>”右边的数指定移动的位数。

示例：

a = 60  # 0011 1100
b = 13  # 0000 1101

# 按位与
# 0011 1100
# 0000 1101 &
# -----------
# 0000 1100
# a & b = 12  -> 1100
print("a & b =", a & b)

# 按位或
# 0011 1100
# 0000 1101 |
# -----------
# 0011 1101
# a | b = 61  -> 0011 1101
print("a | b =", a | b)

# 按位异或
# 0011 1100
# 0000 1101 ^
# -----------
# 0011 0001
# a ^ b = 49 -> 0011 0001
print("a ^ b =", a ^ b)

# 按位取反
# 0011 1100 ~
# -----------
# 1100 0011
# ~a = -61 -> 1100 0011
print("~a =", ~a)

# 左移2位
# 0011 1100
# 1111 0000
# a << 2 = 240 -> 1111 0000
print("a << 2 =", a << 2)

# 右移2位
# 0011 1100
# 0000 1111
# a >> 2 = 15 -> 1111
print("a >> 2 =", a >> 2)

逻辑运算符

逻辑运算符用于对布尔值（True/False）进行逻辑运算，是编程中控制流程（如条件判断、循环）的核心工具。

在 Python3 中，提供的逻辑运算符如下表：

示例 1：布尔值逻辑运算

# 逻辑与（and）
a = True
b = False
print(a and b)  # 输出：False
print(True and True)  # 输出：True

# 逻辑或（or）
print(a or b)   # 输出：True
print(False or False)  # 输出：False

# 逻辑非（not）
print(not a)    # 输出：False
print(not b)    # 输出：True

# 组合运算（优先级：not > and > or，可加括号改变优先级）
print(not True and False)  # 先算 not True → False，再算 False and False → False
print(not (True and False)) # 先算括号内 → False，再算 not → True
print(True or False and False) # 先算 and → False，再算 or → True

示例 2：数字逻辑运算

# 逻辑与（and）：第一个值为真，返回第二个值；第一个为假，返回第一个值
print(10 and 20)   # 10是真 → 返回20
print(0 and 20)    # 0是假 → 返回0
print(-5 and 3.14) # -5是真 → 返回3.14

# 逻辑或（or）：第一个值为真，返回第一个值；第一个为假，返回第二个值
print(10 or 20)    # 10是真 → 返回10
print(0 or 20)     # 0是假 → 返回20
print("" or "hello") # 空字符串是假 → 返回"hello"

# 逻辑非（not）：返回纯布尔值
print(not 0)       # 0是假 → 返回True
print(not 100)     # 100是真 → 返回False

示例 3：字符串 / 列表参与运算

# 字符串
s1 = "Python"
s2 = ""
print(s1 and s2)  # s1真 → 返回s2（空字符串）
print(s1 or s2)   # s1真 → 返回s1（"Python"）
print(not s2)     # s2假 → 返回True

# 列表
lst1 = [1,2,3]
lst2 = []
print(lst1 and lst2)  # lst1真 → 返回lst2（空列表）
print(lst2 or lst1)   # lst2假 → 返回lst1（[1,2,3]）

成员运算符

除了以上的运算符之外，Python 还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

示例 1：判断子串是否存在于字符串中

text = "Python是一门优雅的编程语言，Python简单易学"
sub1 = "Python"  # 存在的子串
sub2 = "Java"    # 不存在的子串
sub3 = "优雅"    # 中文子串

# in 运算符（优先使用）
print(sub1 in text)  # True（子串存在）
print(sub2 in text)  # False（子串不存在）
print(sub3 in text)  # True（中文子串也支持）

# not in 运算
print(sub2 not in text)  # True（子串不存在）

示例 2：判断元素是否存在于列表中

lst = [10, 20, "Python", True, 3.14]

# in 运算
print(20 in lst)      	# 数字元素存在 → True
print("Python" in lst) 	# 字符串元素存在 → True
print(False in lst)   	# 布尔元素不存在 → False

# not in 运算
print(30 not in lst)  	# 数字元素不存在 → True
print(3.14 not in lst) 	# 浮点数元素存在 → False

# 嵌套列表（注意：判断的是外层元素）
lst2 = [1, 2, [3, 4]]
print([3,4] in lst2)  	# 嵌套列表是外层元素 → True
print(3 in lst2)      	# 3是内层元素，不在外层 → False

示例 3：判断元素是否存在于元组中

tup = (1, 2, 3, "a", "b")

print(3 in tup)         # 输出：True
print("c" not in tup)   # 输出：True
print("a" in tup)       # 输出：True

示例 4：判断元素是否存在于集合中

s = {1, 2, 3, "apple", "banana"}

print(2 in s)             # 输出：True
print("orange" not in s)  # 输出：True
print("apple" in s)       # 输出：True

示例 5：字典的成员运算默认针对键（key），而非值（value）；若要判断值，需用 values() 方法

dic = {
    "name": "小明",
    "age": 18,
    "city": "北京"
}

# 判断键是否存在（默认）
print("name" in dic)    	# 键存在 → True
print("gender" not in dic) 	# 键不存在 → True

# 错误：直接判断值，会判定为False（因为判断的是键）
print("小明" in dic)    	# False

# 正确：判断值是否存在（用values()）
print("小明" in dic.values()) 	# True
print(18 in dic.values())    	# True

# 同时判断键值对（用items()）
print(("age", 18) in dic.items()) 	# True
print(("city", "上海") in dic.items()) # False

身份运算符

Python3 的身份运算符用于判断两个变量是否指向内存中的同一个对象（即是否占用同一个存储单元），核心有两个：is（是同一个对象）和 is not（不是同一个对象）。如下表：

示例：

# 简单整数（小整数缓存机制，后面会讲）
a = 10
b = 10
print(f"a的内存地址：{id(a)}")  # 输出：比如 140708467221568
print(f"b的内存地址：{id(b)}")  # 输出：和a相同（140708467221568）
print(a is b)                   # True（指向同一个对象）
print(a == b)                   # True（值相等）

# 列表（即使值相同，也是不同对象）
lst1 = [1, 2, 3]
lst2 = [1, 2, 3]
print(f"lst1的内存地址：{id(lst1)}")  # 输出：比如 2425565991104
print(f"lst2的内存地址：{id(lst2)}")  # 输出：比如 2425565991232（不同）
print(lst1 is lst2)                   # False（不同对象）
print(lst1 == lst2)                   # True（值相等）

# 变量赋值（指向同一个对象）
lst3 = lst1  # lst3 直接引用 lst1 的内存地址
print(f"lst3的内存地址：{id(lst3)}")  # 和 lst1 相同
print(lst1 is lst3)                   # True

# is not 运算符
x = "Python"
y = "Java"
print(x is not y)  # True（不同对象）

Python广告

运算符优先级

以下表格列出了从最高到最低优先级的所有运算符，相同单元格内的运算符具有相同优先级。

运算符均指二元运算，除非特别指出。

相同单元格内的运算符从左至右分组（除了幂运算是从右至左分组）：

注意：Python3 已不支持 <> 运算符，可以使用 != 代替。

更多 Python3 知识，请继续学习后续章节。