一篇文章让你掌握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 中用于比较两个值,并根据比较的结果返回 TrueFalse

比较运算符示例

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 中的成员运算符(innot 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 中使用 innot in 运算符来检查元素是否存在于列表、字符串或字典的键/值中。这些运算符在编程中非常有用,因为它们允许我们快速确定某个元素是否存在于某个集合中。

7. 身份运算符

身份运算符语法规则

is:检查两个对象是否相同(即,它们是否指向内存中的同一个对象)
is not:检查两个对象是否不相同

身份运算符示例

当然可以,以下是使用 Python 中的身份运算符(isis 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 中使用 isis not 运算符来检查两个变量是否指向内存中的同一个对象。这对于确定变量是否引用相同的对象(例如,当处理可变对象如列表或字典时)或检查变量是否为 None 时非常有用。

posted @ 2024-05-07 12:31  是先生了  阅读(68)  评论(0编辑  收藏  举报