一篇文章让你掌握99%的Python运算符。干货很多，建议收藏！！！

Python 中的运算符是编程中的基础概念，用于执行各种操作和数据计算。以下是一些 Python 中的主要运算符的概述：

运算符

1. 算术运算符

算术运算符语法规则

+：加法

-：减法

*：乘法

/：除法（结果为浮点数）

//：整除（取整）

%：取模（求余数）

**：乘方

算术运算符示例

假设我们要编写一个程序，该程序会接收用户输入的两个整数，然后计算并输出这两个整数的和、差、积、商（浮点数除法）、整除结果和取余结果。

以下是使用 Python 编写的代码示例：

# 获取用户输入的两个整数
num1 = int(input("请输入第一个整数: "))
num2 = int(input("请输入第二个整数: "))  

# 计算和输出结果
print("两个数的和是:", num1 + num2)          # 使用加法运算符
print("两个数的差是:", num1 - num2)          # 使用减法运算符
print("两个数的积是:", num1 * num2)          # 使用乘法运算符
print("两个数的商是:", num1 / num2)          # 使用除法运算符（结果为浮点数）
print("两个数的整除结果是:", num1 // num2)   # 使用整除运算符
print("两个数的取余结果是:", num1 % num2)    # 使用取模运算符  

# 如果我们想要计算 num1 的 num2 次方，我们可以使用 ** 运算符
print("num1 的 num2 次方是:", num1 ** num2)  # 使用幂运算符

2. 比较运算符

比较运算符语法规则

==：等于

!=：不等于

>：大于

<：小于

>=：大于或等于

<=：小于或等于

当然，我可以为您提供一些详细的比较运算符的示例。比较运算符在 Python 中用于比较两个值，并根据比较的结果返回 True 或 False。

比较运算符示例

2.1 比较整数

a = 5
b = 10

print(a == b)     # 输出: False，因为 5 不等于 10
print(a != b)     # 输出: True，因为 5 不等于 10
print(a > b)      # 输出: False，因为 5 不大于 10
print(a < b)      # 输出: True，因为 5 小于 10
print(a >= b)     # 输出: False，因为 5 不大于或等于 10
print(a <= b)     # 输出: True，因为 5 小于或等于 10

2.2 比较字符串

str1 = "apple"
str2 = "banana"
str3 = "apple"

print(str1 == str2)   # 输出: False，因为 "apple" 不等于 "banana"
print(str1 != str2)   # 输出: True，因为 "apple" 不等于 "banana"
print(str1 < str2)    # 输出: True，根据 ASCII 码，"apple" 在 "banana" 之前
print(str1 > str2)    # 输出: False，因为 "apple" 不在 "banana" 之后
print(str1 == str3)   # 输出: True，因为 "apple" 等于 "apple"

2.3 比较列表（注意：列表之间比较的是元素的顺序和值）

list1 = [1, 2, 3]
list2 = [1, 2, 3]
list3 = [1, 3, 2]

print(list1 == list2)  # 输出: True，因为两个列表的元素相同且顺序也相同
print(list1 == list3)  # 输出: False，因为两个列表的元素虽然相同但顺序不同
print(list1 != list3)  # 输出: True，因为两个列表的元素顺序不同

# 注意：列表之间不能使用 < 或 > 进行比较，因为比较运算符没有定义列表之间的排序关系
# print(list1 < list3)  # 这会引发一个 TypeError

2.4 比较元组（与列表类似，但元组是不可变的）

tuple1 = (1, 2, 3)
tuple2 = (1, 2, 3)
tuple3 = (1, 3, 2)

print(tuple1 == tuple2)  # 输出: True，因为两个元组的元素相同且顺序也相同
print(tuple1 == tuple3)  # 输出: False，因为两个元组的元素虽然相同但顺序不同
print(tuple1 != tuple3)  # 输出: True，因为两个元组的元素顺序不同

# 同样，元组之间也不能使用 < 或 > 进行比较

2.5 比较字典（字典之间比较的是键值对的集合）

dict1 = {'a': 1, 'b': 2}
dict2 = {'a': 1, 'b': 2}
dict3 = {'a': 1, 'b': 3}

print(dict1 == dict2)  # 输出: True，因为两个字典的键值对相同
print(dict1 == dict3)  # 输出: False，因为两个字典的键值对不完全相同
print(dict1 != dict3)  # 输出: True，因为两个字典的键值对不完全相同

# 注意：字典之间也不能使用 < 或 > 进行比较，因为比较运算符没有定义字典之间的排序关系

这些示例展示了如何在 Python 中使用比较运算符来比较不同类型的数据。在比较时，重要的是要理解每种数据类型之间的比较是如何进行的，以及哪些比较是有效的。

3. 赋值运算符

赋值运算符语法规则

=：赋值

+=：加等于（例如 x += 1 相当于 x = x + 1）

-=：减等于

*=：乘等于

/=：除等于

//=：整除等于

%=：取模等于

**=：乘方等于

赋值运算符在 Python 中主要用于给变量赋值。但是，除了基本的 = 赋值运算符外，还有一些复合赋值运算符，它们可以在赋值的同时执行其他操作。

赋值运算符示例

3.1 基本赋值运算符 =

x = 10  # 将整数 10 赋值给变量 x

3.2 加等于 +=

x = 5
x += 3  # 相当于 x = x + 3，执行后 x 的值为 8

3.3 减等于 -=

x = 10
x -= 3  # 相当于 x = x - 3，执行后 x 的值为 7

3.4 乘等于 *=

x = 2
x *= 5  # 相当于 x = x * 5，执行后 x 的值为 10

3.5 除等于 /=

x = 10
x /= 2  # 相当于 x = x / 2，执行后 x 的值为 5.0（因为结果是浮点数）

3.6 整除等于 //=

x = 10
x //= 3  # 相当于 x = x // 3，执行后 x 的值为 3（因为执行的是整除操作）

3.7 取模等于 %=

x = 10
x %= 3  # 相当于 x = x % 3，执行后 x 的值为 1（因为 10 除以 3 的余数是 1）

3.8 幂等于 **=

x = 2
x **= 3  # 相当于 x = x ** 3，执行后 x 的值为 8（因为 2 的 3 次方是 8）

3.9 赋值运算符的复合使用

# 初始化变量
a, b = 5, 10

# 使用多个赋值运算符同时更新 a 和 b 的值
a += 3  # a 现在为 8
b -= 2  # b 现在为 8

# 使用复合赋值运算符进行更复杂的计算
a *= b  # a 现在为 64（因为 8 * 8 = 64）
b //= 2  # b 现在为 4（因为 8 整除 2 = 4）

print(a)  # 输出 64
print(b)  # 输出 4

通过上面的示例，您可以看到如何使用不同类型的赋值运算符在 Python 中更新变量的值。这些运算符在编写简洁、易读的代码时非常有用。

4. 逻辑运算符

逻辑运算符语法规则

and：逻辑与

or：逻辑或

not：逻辑非

当然，逻辑运算符在编程中用于组合布尔表达式，并基于这些表达式的真假值产生结果。以下是逻辑运算符的一些详细示例：

逻辑运算符示例

4.1 and 运算符

and 运算符用于连接两个布尔表达式，当且仅当两个表达式都为真时，结果才为真。

# 定义两个布尔变量
is_adult = True  # 假设年龄大于或等于18岁
has_driving_license = True  # 假设拥有驾驶执照

# 使用 and 运算符
can_drive = is_adult and has_driving_license
print(can_drive)  # 输出: True，因为两个条件都为真

# 如果其中一个条件为假
has_driving_license = False
can_drive = is_adult and has_driving_license
print(can_drive)  # 输出: False，因为至少有一个条件为假

4.2 or 运算符

or 运算符用于连接两个布尔表达式，当至少有一个表达式为真时，结果就为真。

# 定义两个布尔变量
is_rainy = False  # 假设今天不下雨
is_cloudy = True  # 假设今天多云

# 使用 or 运算符
should_bring_umbrella = is_rainy or is_cloudy
print(should_bring_umbrella)  # 输出: True，因为至少有一个条件为真

# 如果两个条件都为假
is_rainy = False
is_cloudy = False
should_bring_umbrella = is_rainy or is_cloudy
print(should_bring_umbrella)  # 输出: False，因为两个条件都为假

4.3 not 运算符

not 运算符用于对一个布尔表达式取反。

# 定义一个布尔变量
is_online = True  # 假设当前在线

# 使用 not 运算符
is_offline = not is_online
print(is_offline)  # 输出: False，因为 is_online 为真，取反后为假

# 再次取反
is_online_again = not is_offline
print(is_online_again)  # 输出: True，因为 is_offline 为假，取反后为真

4.4 逻辑运算符的复合使用

逻辑运算符可以复合使用，以构建更复杂的条件判断。

# 定义几个布尔变量
is_student = True  # 假设是学生
is_enrolled = True  # 假设已注册课程
has_paid_fees = False  # 假设尚未支付费用

# 使用逻辑运算符构建条件
can_attend_class = (is_student and is_enrolled) or has_paid_fees
print(can_attend_class)  # 输出: True，因为至少满足一个条件（学生且已注册）

# 如果学生未注册
is_enrolled = False
can_attend_class = (is_student and is_enrolled) or has_paid_fees
print(can_attend_class)  # 输出: False，因为两个条件（学生和已注册）都不满足，且未支付费用

在这个示例中，我们使用括号来明确表达式的计算顺序，因为 and 运算符的优先级高于 or 运算符。如果省略括号，表达式的计算顺序可能会不同，导致意外的结果。

5. 位运算符

位运算符语法规则

&：按位与

|：按位或

^：按位异或

~：按位取反

<<：左移

>>：右移

位运算符示例

位运算符在 Python 中主要用于对整数进行二进制位的操作

5.1 按位与（&）

按位与运算符（&）对两个整数的二进制表示进行逐位与操作。只有当两个相应的二进制位都为 1 时，结果位才为 1。

a = 90  # 二进制表示为 0101 1010
b = 60  # 二进制表示为 0011 1100
c = a & b  # 结果为 0001 1000，十进制为 8
print(bin(c))  # 输出: 0b1000

5.2 按位或（|）

按位或运算符（|）对两个整数的二进制表示进行逐位或操作。只要两个相应的二进制位中有一个为 1，结果位就为 1。

a = 90  # 二进制表示为 0101 1010
b = 60  # 二进制表示为 0011 1100
c = a | b  # 结果为 0111 1110，十进制为 126
print(bin(c))  # 输出: 0b1111110

5.3 按位异或（^）

按位异或运算符（^）对两个整数的二进制表示进行逐位异或操作。当两个相应的二进制位相异时，结果位为 1。

a = 90  # 二进制表示为 0101 1010
b = 60  # 二进制表示为 0011 1100
c = a ^ b  # 结果为 0110 0110，十进制为 98
print(bin(c))  # 输出: 0b1100110

5.4 按位取反（~）

按位取反运算符（~）对一个整数的二进制表示进行取反操作。所有 1 变为 0，所有 0 变为 1。注意，由于整数在计算机中通常使用补码形式表示，所以取反后的结果会是原数的负值（加 1 后再取反）。

（注意：按位取反通常用于无符号整数，但在 Python 中，整数是有符号的，所以结果会是负数的补码形式）

a = 90  # 二进制表示为 0101 1010（正数的补码形式）
b = ~a  # 结果的补码形式（对于负数），但直接打印会是十进制的负数
print(bin(a ^ 0xffffffff))  # 在 32 位系统上，取反可以通过异或全 1 来实现（假设是 32 位整数）
# 输出类似: 0b10100101111111111111111111111111（但注意 bin() 函数不会直接输出这么多位）
print(b)  # 输出: -91（取决于系统和 Python 的实现，可能是 -91 或其他负数）

注意：在上面的按位取反示例中，我使用了 a ^ 0xffffffff 来模拟 32 位无符号整数的按位取反。在 Python 中，int 类型没有固定的位数，但你可以通过异或全 1 的方式来模拟固定位数的按位取反。

5.5 左移（<<）

左移运算符（<<）将数字的二进制表示向左移动指定的位数。右侧用零填充。

a = 90  # 二进制表示为 0101 1010
b = a << 2  # 结果为 1011 0100，十进制为 360
print(bin(b))  # 输出: 0b10110100

5.6 右移（>>）

右移运算符（>>）将数字的二进制表示向右移动指定的位数。左侧用符号位（正数为 0，负数为 1）填充。

a = 90  # 二进制表示为 0101 1010
b = a >> 2  # 结果为 0001 0110，十进制为 22
print(bin(b))  # 输出: 0b10110

6. 成员运算符

成员运算符语法规则

in：检查某个元素是否存在于列表中，或某个子字符串是否存在于字符串中

not in：检查某个元素是否不存在于列表中，或某个子字符串是否不存在于字符串中

当然，以下是使用 Python 中的成员运算符（in 和 not in）的详细示例：

成员运算符示例

1. 检查元素是否在列表中

# 定义一个列表
fruits = ['apple', 'banana', 'cherry', 'date']

# 使用 in 运算符检查元素是否在列表中
if 'apple' in fruits:
    print("苹果在列表中。")

if 'orange' not in fruits:
    print("橙子不在列表中。")

# 遍历列表并检查每个元素
for fruit in fruits:
    if fruit in ['banana', 'cherry']:
        print(f"{fruit} 是在指定列表中的水果。")
    else:
        print(f"{fruit} 不在指定列表中。")

2. 检查子字符串是否在字符串中

# 定义一个字符串
sentence = "我喜欢吃苹果和香蕉。"

# 使用 in 运算符检查子字符串是否在字符串中
if '苹果' in sentence:
    print("句子中包含'苹果'这个词。")

if '梨' not in sentence:
    print("句子中不包含'梨'这个词。")

# 查找并打印所有水果（假设句子中只包含苹果和香蕉）
for fruit in ['苹果', '香蕉']:
    if fruit in sentence:
        print(f"句子中包含'{fruit}'这个词。")

3. 检查值是否在字典的键或值中

# 定义一个字典
inventory = {
    'apple': 10,
    'banana': 20,
    'quantity': 30
}

# 检查键是否在字典中
if 'apple' in inventory:
    print("字典中包含'apple'这个键。")

# 检查值是否在字典的键中（这通常不是很有用，但可以作为示例）
if 10 in inventory.keys():
    print("10 是字典中的一个键对应的值（但这样检查通常不直观）。")

# 检查值是否在字典的值中
if 20 in inventory.values():
    print("20 是字典中的一个值。")

# 检查某个值是否既不在键中也不在值中
if 'cherry' not in inventory and 'cherry' not in inventory.values():
    print("'cherry'既不在字典的键中也不在值中。")

这些示例展示了如何在 Python 中使用 in 和 not in 运算符来检查元素是否存在于列表、字符串或字典的键/值中。这些运算符在编程中非常有用，因为它们允许我们快速确定某个元素是否存在于某个集合中。

7. 身份运算符

身份运算符语法规则

is：检查两个对象是否相同（即，它们是否指向内存中的同一个对象）

is not：检查两个对象是否不相同

身份运算符示例

当然可以，以下是使用 Python 中的身份运算符（is 和 is not）的详细示例：

1. 比较两个变量是否指向同一个对象

# 创建两个指向同一个字符串对象的变量
a = "hello"
b = "hello"

# 由于字符串在 Python 中是不可变的，并且对于相同的字符串字面量，Python 会进行内部缓存（字符串驻留），
# 所以 a 和 b 实际上指向的是内存中的同一个对象
if a is b:
    print("a 和 b 指向同一个对象。")

# 创建两个独立的列表对象，即使它们的内容相同
c = [1, 2, 3]
d = [1, 2, 3]

# 由于列表是可变的，Python 不会为内容相同的列表进行内部缓存
# 因此 c 和 d 指向的是不同的对象
if c is not d:
    print("c 和 d 指向不同的对象。")

2. 比较变量与 None

# 创建一个变量并初始化为 None
x = None

# 使用 is 运算符检查变量是否为 None
if x is None:
    print("x 是 None。")

# 另一个常见的用法是在函数中检查返回值是否为 None
def get_value_or_none():
    # 根据某些条件返回一个值或 None
    return None

value = get_value_or_none()
if value is None:
    print("函数返回了 None。")

3. 比较整数和浮点数（通常不使用 is）

虽然技术上可以使用 is 来比较整数和浮点数，但这不是其常见用法，因为 Python 的整数和浮点数缓存机制与字符串不同。

# 创建两个整数变量
a = 256
b = 256

# 对于小的整数（通常是 -5 到 256），Python 会进行缓存，因此 a 和 b 可能指向同一个对象
# 但这并不是 `is` 的典型用法，因为这种行为依赖于 Python 的实现细节
if a is b:
    print("a 和 b 指向同一个整数对象（在某些 Python 实现中）。")

# 创建两个浮点数变量
c = 1.0
d = 1.0

# 浮点数通常不会进行缓存，因此 c 和 d 不会指向同一个对象
if c is not d:
    print("c 和 d 指向不同的浮点数对象。")

4. 使用 id() 函数查看对象的内存地址

为了更清晰地展示 is 运算符的工作原理，我们可以使用 id() 函数来查看对象的内存地址。

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

print(f"id(a): {id(a)}")
print(f"id(b): {id(b)}")  # 由于 b 是 a 的引用，它们指向同一个对象
print(f"id(c): {id(c)}")  # c 是另一个独立的列表对象

if a is b:
    print("a 和 b 指向同一个对象。")

if a is not c:
    print("a 和 c 指向不同的对象。")

这些示例展示了如何在 Python 中使用 is 和 is not 运算符来检查两个变量是否指向内存中的同一个对象。这对于确定变量是否引用相同的对象（例如，当处理可变对象如列表或字典时）或检查变量是否为 None 时非常有用。