Python3 运算符大解密：掌握运算法宝，事半功倍！

运算符是用于执行各种操作的符号或特殊符号。Python3 支持多种类型的运算符，包括算术运算符、赋值运算符、比较运算符、逻辑运算符等。

基本语法

算术运算符

运算符	描述	示例
+	加	x + y
-	减	x - y
*	乘	x * y
/	除	x / y
%	取模	x % y
**	幂	x ** y
//	取整除	x // y

赋值运算符

运算符	描述	示例
=	简单的赋值运算符	x = y + z
+=	加法赋值运算符	x += y
-=	减法赋值运算符	x -= y
*=	乘法赋值运算符	x *= y
/=	除法赋值运算符	x /= y
%=	取模赋值运算符	x %= y
**=	幂赋值运算符	x **= y
//=	取整除赋值运算符	x //= y

比较运算符

运算符	描述	示例
==	等于	x == y
!=	不等于	x != y
>	大于	x > y
<	小于	x < y
>=	大于等于	x >= y
<=	小于等于	x <= y

逻辑运算符

运算符	描述	示例
and	与	x and y
or	或	x or y
not	非	not x

位运算符

运算符	描述	示例
&	按位与	x & y
|	按位或	x | y
^	按位异或	x ^ y
~	按位取反	~x
<<	左移	x << y
>>	右移	x >> y

成员运算符

运算符	描述	示例
in	如果在指定的序列中找到值返回 True，否则返回 False	x in y
not in	如果在指定的序列中没有找到值返回 True，否则返回 False	x not in y

身份运算符

运算符	描述	示例
is	判断两个标识符是否引用自一个对象	x is y
is not	判断两个标识符是否引用自不同对象	x is not y

示例

下面是一些示例代码：

# 算术运算符示例
x = 10
y = 3
print(x + y)  # 输出：13
print(x - y)  # 输出：7
print(x * y)  # 输出：30
print(x / y)  # 输出：3.3333333333333335
print(x % y)  # 输出：1
print(x ** y) # 输出：1000
print(x // y) # 输出：3

# 赋值运算符示例
x += 5  # 等同于 x = x + 5
print(x)  # 输出：15

# 比较运算符示例
a = 10
b = 20
print(a == b)  # 输出：False
print(a != b)  # 输出：True
print(a > b)   # 输出：False
print(a < b)   # 输出：True

# 逻辑运算符示例
m = True
n = False
print(m and n)  # 输出：False
print(m or n)   # 输出：True
print(not m)    # 输出：False

应用场景

算术运算符

算术运算符用于执行基本的数学操作，如加、减、乘、除等，常用于数学计算和数据处理。

• 加法（+）：将两个数相加。
• 减法（-）：将右操作数从左操作数中减去。
• 乘法（*）：将两个数相乘。
• 除法（/）：将左操作数除以右操作数，得到一个浮点数。
• 取模（%）：返回两个数相除的余数。
• 幂（**）：返回左操作数的右操作数次幂。
• 取整除（//）：返回商的整数部分，丢弃小数部分。

示例

# 算术运算符示例
a = 10
b = 3

addition = a + b      # 加法
subtraction = a - b   # 减法
multiplication = a * b  # 乘法
division = a / b      # 除法
modulus = a % b       # 取模
exponentiation = a ** b  # 幂
floor_division = a // b  # 取整除

print("加法结果：", addition)
print("减法结果：", subtraction)
print("乘法结果：", multiplication)
print("除法结果：", division)
print("取模结果：", modulus)
print("幂结果：", exponentiation)
print("取整除结果：", floor_division)

赋值运算符

赋值运算符用于给变量赋值，常用于存储计算结果或更新变量的值。

• 简单的赋值运算符（=）：将右边的值赋给左边的变量。
• 加法赋值运算符（+=）：将左右操作数相加，并将结果赋给左操作数。
• 减法赋值运算符（-=）：将左操作数减去右操作数，并将结果赋给左操作数。
• 乘法赋值运算符（*=）：将左右操作数相乘，并将结果赋给左操作数。
• 除法赋值运算符（/=）：将左操作数除以右操作数，并将结果赋给左操作数。
• 取模赋值运算符（%=）：对左操作数进行取模运算，并将结果赋给左操作数。
• 幂赋值运算符（**=）：对左操作数进行幂运算，并将结果赋给左操作数。
• 取整除赋值运算符（//=）：对左操作数进行取整除运算，并将结果赋给左操作数。

示例

# 赋值运算符示例
x = 10

# 简单的赋值运算符
y = x
print("简单的赋值运算符：", y)

# 加法赋值运算符
x += 5  # 等同于 x = x + 5
print("加法赋值运算符：", x)

# 减法赋值运算符
x -= 3  # 等同于 x = x - 3
print("减法赋值运算符：", x)

# 乘法赋值运算符
x *= 2  # 等同于 x = x * 2
print("乘法赋值运算符：", x)

# 除法赋值运算符
x /= 4  # 等同于 x = x / 4
print("除法赋值运算符：", x)

# 取模赋值运算符
x %= 3  # 等同于 x = x % 3
print("取模赋值运算符：", x)

# 幂赋值运算符
x **= 2  # 等同于 x = x ** 2
print("幂赋值运算符：", x)

# 取整除赋值运算符
x //= 2  # 等同于 x = x // 2
print("取整除赋值运算符：", x)

比较运算符

比较运算符用于比较两个值之间的关系，常用于条件语句和循环控制。

• 等于（==）：如果两个操作数相等，则条件成立。
• 不等于（!=）：如果两个操作数不相等，则条件成立。
• 大于（>）：如果左操作数大于右操作数，则条件成立。
• 小于（<）：如果左操作数小于右操作数，则条件成立。
• 大于等于（>=）：如果左操作数大于或等于右操作数，则条件成立。
• 小于等于（<=）：如果左操作数小于或等于右操作数，则条件成立。

示例

# 比较运算符示例
a = 10
b = 20

# 等于
print("等于：", a == b)

# 不等于
print("不等于：", a != b)

# 大于
print("大于：", a > b)

# 小于
print("小于：", a < b)

# 大于等于
print("大于等于：", a >= b)

# 小于等于
print("小于等于：", a <= b)

逻辑运算符

逻辑运算符用于对布尔值进行逻辑操作，常用于条件判断和逻辑运算。

• 与（and）：如果两个操作数都为 True，则条件成立。
• 或（or）：如果两个操作数中有一个为 True，则条件成立。
• 非（not）：如果操作数为 False，则条件成立。

示例

# 逻辑运算符示例
m = True
n = False

# 与
print("与：", m and n)

# 或


print("或：", m or n)

# 非
print("非：", not m)

位运算符

位运算符用于对二进制数进行位操作，常用于底层编程和位级运算。

• 按位与（&）：对两个数的每个位执行与操作。
• 按位或（|）：对两个数的每个位执行或操作。
• 按位异或（^）：对两个数的每个位执行异或操作。
• 按位取反（~）：对数的每个位执行取反操作。
• 左移（<<）：将左操作数的位向左移动指定的位数。
• 右移（>>）：将左操作数的位向右移动指定的位数。

示例

# 位运算符示例
x = 5  # 二进制表示为 0101
y = 3  # 二进制表示为 0011

# 按位与
print("按位与：", x & y)

# 按位或
print("按位或：", x | y)

# 按位异或
print("按位异或：", x ^ y)

# 按位取反
print("按位取反：", ~x)

# 左移
print("左移：", x << 1)

# 右移
print("右移：", x >> 1)

成员运算符

成员运算符用于判断一个值是否在序列中，常用于列表、元组等数据结构的查询操作。

• in：如果在序列中找到指定的值，返回 True，否则返回 False。
• not in：如果在序列中没有找到指定的值，返回 True，否则返回 False。

示例：

# 成员运算符示例
a_list = [1, 2, 3, 4, 5]

# in
print("in：", 3 in a_list)

# not in
print("not in：", 6 not in a_list)

身份运算符

身份运算符用于判断两个变量是否引用同一个对象，常用于对象比较和内存管理。

• is：如果两个变量引用同一个对象，则返回 True，否则返回 False。
• is not：如果两个变量引用不同的对象，则返回 True，否则返回 False。

示例：

# 身份运算符示例
x = [1, 2, 3]
y = [1, 2, 3]

# is
print("is：", x is y)

# is not
print("is not：", x is not y)

注意事项

运算符的优先级和结合性

在 Python 中，运算符具有不同的优先级和结合性，这影响了表达式中运算符的执行顺序。理解运算符的优先级和结合性有助于避免逻辑错误。

• 优先级：运算符的优先级决定了在表达式中先执行哪些运算符，高优先级的运算符会先被执行。
• 结合性：当有多个相同优先级的运算符出现时，结合性决定了运算符的执行顺序，是从左向右结合（左结合性）还是从右向左结合（右结合性）。

常见的优先级从高到低依次为：

1. 括号：()
2. 幂运算：**
3. 正负号：+x, -x
4. 乘、除、取模、取整除：*，/，%，//
5. 加、减：+，-
6. 按位左移、按位右移：<<，>>
7. 按位与：&
8. 按位异或：^
9. 按位或：|
10. 比较运算符、成员运算符、身份运算符：==, !=, >, <, >=, <=, in, not in, is, is not
11. 逻辑非：not
12. 逻辑与：and
13. 逻辑或：or

示

# 运算符优先级示例
result = 5 * 2 + 3 ** 2  # 先执行 3 ** 2，再执行 5 * 2，最后执行加法
print("优先级示例：", result)  # 输出结果为 19

正确使用比较运算符和逻辑运算符

在条件语句和循环控制中，正确使用比较运算符和逻辑运算符是确保程序正确性的关键。

• 比较运算符用于比较两个值之间的关系，返回布尔值 True 或 False。
• 逻辑运算符用于对布尔值进行逻辑操作，常用于组合多个条件。

在使用时，应确保比较运算符和逻辑运算符的组合符合预期逻辑，并注意运算符的优先级和结合性。

示例

# 比较运算符和逻辑运算符示例
x = 10
y = 20
z = 30

# 条件语句示例
if x < y and y < z:  # 组合使用比较运算符和逻辑运算符
    print("条件成立")

# 循环控制示例
for i in range(5):
    if i != 3 or i > 2:  # 组合使用比较运算符和逻辑运算符
        print("循环迭代：", i)

位运算的原理

位运算是对二进制数进行位操作的一种运算方式，常用于底层编程和位级运算。在进行位运算时，需要理解二进制数的表示和位操作的原理，避免产生意外的结果。

常见的位运算符包括按位与（&）、按位或（|）、按位异或（^）、按位取反（~）、左移（<<）、右移（>>）等。

示例

# 位运算示例
x = 0b1010  # 二进制数 1010，表示为 10
y = 0b1100  # 二进制数 1100，表示为 12

# 按位与
print("按位与：", bin(x & y))  # 输出结果为 0b1000，表示为 8

# 按位或
print("按位或：", bin(x | y))  # 输出结果为 0b1110，表示为 14

# 按位异或
print("按位异或：", bin(x ^ y))  # 输出结果为 0b0110，表示为 6

# 按位取反
print("按位取反：", bin(~x))  # 输出结果为 -0b1011，表示为 -11

# 左移
print("左移：", bin(x << 1))  # 输出结果为 0b10100，表示为 20

# 右移
print("右移：", bin(y >> 1))  # 输出结果为 0b110，表示为 6

在进行位运算时，要注意二进制数的表示方式以及位运算符的操作规则，确保得到预期的结果。

总结

Python3 中的运算符是执行各种操作的重要工具，通过灵活运用各种运算符，可以实现各种复杂的计算和逻辑操作。掌握运算符的基本语法、常见用法以及注意事项，有助于提高代码的效率和可读性，提升程序的性能和稳定性。