Python中的运算符（保姆级教学）-CSDN博客

目录

一、什么是运算符？

二、运算符的分类

基本运算符

赋值运算符

比较运算符

逻辑运算符

其他运算符

三、优先级比较

总结

一、什么是运算符？

运算符是一种特殊的符号，它能够对一个或多个操作数（可以是变量、常量等）进行运算，并返回相应的结果。

二、运算符的分类

基本运算符

1. “ + ”，是加法运算符，用于对两个操作数进行加法运算。

a = 10
b = 20
result = a + b
print(result)

2.“ - ”，是减法运算符，用于对两个操作数进行减法运算

a = 10
b = 20
result = a - b
print(result)

3.“ * ”，是乘法运算符，用于对两个操作数进行乘法运算

a = 10
b = 20
result = a * b
print(result)

4.“ / ”，是除法运算符，用于对两个操作数进行浮点数除法运算，结果会是浮点数；

a = 10
b = 20
result = a / b
print(result)  # 0.5

5.“ // ” ，是整数除法运算符，用于对两个操作数进行除法运算，但结果会向下取整，得到一个整数；

print(4 // 2, 5 // 3)  # 2 1

6.“ ** ”是幂运算符，用于计算一个数的若干次方，比如2**3就是2的3次方，结果是8；

print(3 ** 2)     # 9
print(3 ** 3)     # 27
print(3 ** 4)     # 81

7.“ % ”是取余运算符，用于计算两个操作数相除后的余数，比如10%3的结果是1，因为10除以3的余数是1。

print(5 % 3, 20 % 3,3 % 5)     # 2  2  3     m % n ,m<n时，结果为m

注意：m % 2常用于判定奇偶性（m % n有n种情况，若m % n = =0 ,则m是n的倍数）

print(15 % 2,1 % 2,3 % 2,100 % 2)  #1,1,1,0

赋值运算符

1. = ：简单的赋值运算符，将右侧的值赋给左侧的变量。

a = 10

2. += ：加法赋值。

a = 10
a = a += 1      #  a = a + 1
print(a)        #  11

3. -=：减法赋值

a = 2 
a -= 5    # 等价于 a = a - 5
print(a)  # -3

4. *=：乘法赋值

a = 2
a *= 5  # 等价于 a = a * 5
print(a)    # 10

5. /=：除法赋值（结果为浮点数）

a = 10
a /= 5  # 等价于 a = a / 5
print(a)  # 2.0

6. //=：整数除法赋值（结果为整数）

a = 10 
a //= 5  # 等价于 a = a // 5
print(a)  # 2

7. %=：取余赋值(左右两侧有一个为浮点型，结果就为浮点型，全为整型结果才是整型)

a = 10
a %= 3  # 等价于 a = a % 3
print(a)   # 1

a = 10
a %= 3.0
print(a)   # 1.0

a = 10.0
a %= 3.0
print(a)    # 1.0

8. **=：幂赋值

a = 3
a **= 2  # 等价于 a = a ** 3
print(a)   # 9

比较运算符

==：等于，比较两个值是否相等

a = 5
b = 5
print(a == b)  # 输出 True

c = 6
d = '6'  
print(c == d)  # 输出 False   '6'为字符串类型

!=：不等于，比较两个值是否不相等。

a = 5
b = 10
print(a != b)  # 输出 True

>：大于，比较一个值是否大于另一个值。

a = 10
b = 5
print(a > b)  # 输出 True

<：小于，比较一个值是否小于另一个值。

a = 5
b = 10
print(a < b)  # 输出 True

>=：大于等于，比较一个值是否大于或等于另一个值。

a = 10
b = 10
print(a >= b)  # 输出 True

<=：小于等于，比较一个值是否小于或等于另一个值。

a = 5
b = 10
print(a <= b)  # 输出 True

逻辑运算符

and：逻辑与。

左右两个都是真，结果才是真。左右两侧有一个为假，结果就是假

返回值：左侧为假，返回左侧；
左侧为真，返回右侧。

a = 5
b = 10
print(a > 0 and b > 0)  # 输出 True
print(a > 0 and b < 0)  # 输出 False

or：逻辑或，组合两个布尔表达式，只要有一个表达式为True，结果就为True。

a = 5
b = 10
print(a > 0 or b > 0)  # 输出 True
print(a < 0 or b < 0)  # 输出 False

not：逻辑非，取一个布尔表达式的相反值，即如果表达式为True，结果为False，反之亦然。

a = 5
print(not a > 0)  # 输出 False
print(not a < 0)  # 输出 True

其他运算符

位运算

&：按位与

（相同位置全为1，结果才是1）

a = 10         #0b00001010   二进制以0b开头，补齐8位
b = 20         #0b00010100 
               #0b00000000
print(a & b)   # 0

|：按位或

（相同位置全为0，结果才是0）

a = 10         #0b00001010   
b = 20         #0b00010100 
     # a | b   #0b00011110
print(a | b )  # 30

^：按位异或

a = 10            #0b00001010   
b = 20            #0b00010100 
# a ^ b           #0b00011110
# print(a ^ b )   # 30

~：按位取反

a = 5  # 二进制：0101
print(~a)  # 输出 -6，二进制：1010（补码形式）

<<：左移

a = 5  # 二进制：0101
print(~a)  # 输出 -6，二进制：1010（补码形式）

>>：右移

a = 5  # 二进制：0101
print(a >> 1)  # 输出 2，二进制：0010

成员运算符

in：检查值是否在序列中

print(10 in [10, 20, 30])  # 输出 True
print("he" in "hello python")  # 输出 True

not in：检查值是否不在序列中

print(10 not in [10, 20, 30])  # 输出 False
print("he" not in "hello python")  # 输出 False

身份运算符

is：检查两个对象是否是同一个对象

a = [10, 20]
b = [10, 20]
print(a is b)  # 输出 False，因为a和b是两个不同的对象

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

a = [10, 20]
b = [10, 20]
print(a is not b)  # 输出 True，因为a和b是两个不同的对象

三、优先级比较

a = 10
b = 5
c = 3
d = 2

# 算术运算符优先级最高
result1 = a + b * c          # 先计算乘法，再计算加法
print("result1 =", result1)  # 输出：result1 = 25

# 比较运算符次之
result2 = (a + b) * c > d       # 先计算括号内的加法，再计算乘法，最后进行比较
print("result2 =", result2)     # 输出：result2 = True

# 逻辑运算符再次之
result3 = ((a + b) * c > d) and (a > b)  # 先计算比较运算符，再计算逻辑运算符
print("result3 =", result3)              # 输出：result3 = True

# 赋值运算符优先级最低
result4 = a
result4 += b * c             # 先计算乘法，再将结果赋值给 result4
print("result4 =", result4)  # 输出：result4 = 25

总的优先级顺序就是：算术运算符 > 比较运算符 > 逻辑运算符 > 赋值运算符