2.7 Python-运算符

1. 运算符简介

运算符用于执行程序代码运算, 在 Python 程序中运算符按应用场景可分为:
* 1. 算术运算符
* 2. 增量赋值运算符
* 3. 比较运算符
* 4. 逻辑运算符
* 5. 成员运算符
* 6. 身份运算符
* 6. 按位运算符
...

* Python 是强类型语言, 不同类型之间是不可以操作的.
1
2
3
4
5
6
7
8
9
10
11

2. 算术运算符

* 整型 与 浮点型操作的结果是浮点型, 整型与整型做除法运算结果是浮点型.
1

# 加
print(1 + 1.1)  # 2.1

# 减
print(2 - 1.0)  # 1.0

# 乘
print(2 * 3.0)  # 6.0

# 除
print(3 / 3)  # 1.0

# 乘方
print(2 ** 4.0)  # 16.0

# 求余
print(9 % 2.0)  # 1.0

# 整除
print(9 // 2)  # 4.5 向下取值4
print(-9 // 2)  # -4.5 向下取值为5

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

对应内置方法:
.__add__()  加       返回 self+value.
.__radd__() 被加     返回 value+self.
.__pos__()  加上正号  返回 +self, 默认不显示.
.__sub__()  减       返回 self-value.
.__rsub__() 被减     返回 value-self.
.__neg__()  加上负号 返回 -self.
.__mul__()  乘       返回 self*value.
.__truediv__() 除    返回 self/value.
.__rtruediv__() 被除 返回 value/self.
.__mod__()  求余     返回 self%value.
.__floordiv__() 整除 返回 self//value.
1
2
3
4
5
6
7
8
9
10
11
12

3. 增量赋值运算符

a = 1
print(a)  # 1

a += 1 
print(a)  # 2

a -= 1
print(a)  # 1

a *= 2
print(a)  # 2

a /= 2
print(a)  # 1.0

b = 2
b **= 3
print(b)  # 8

b //= 2
print(b)  # 4

b %= 3
print(b)  # 1

print(n := 1)  # 1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

对应内置方法:
__iadd__ 加法赋值 返回 self+=value.
__imul__ 乘法赋值 返回 self*=value.
1
2
3

4. 比较运算符

4.1 比较运算符

比较运算的返回结果是布尔值 True / False.
1

4.2 数字比较

print(2 > 1)  # True

print(3 < 4)  # True

print(3 * 2 == 6 * 1)  # True

print(7 != 6)  # True

print(2 >= 2)  # True

print(3 <= 3)  # True

# 连续比较 等于 (3>2) and (2>1)
print(3 > 1 > 1)  # False

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

对应内置方法:
.__gt__()  大于        返回 self>值
.__ge__()  大于或等于  返回 self>=value
.__lt__()  小于        返回 self<值
.__le__()  小于或等于   返回self<值
.__eq__()  等于        返回self==value.
.__ne__()  不等于      返回 self!=value.
.__bool__() 不等于0    返回 self!=0.
1
2
3
4
5
6
7
8

4.3 字符比较

涉及字符串的比较, 则需要转为 Unicode 编码表对应的十进制数来比较.
1

常用字符对应的十进制数.
字符 | 十进制
0-9 : 30-39
A-Z : 65-90
a-z : 95-122
1
2
3
4
5

# 两个字符串按左往右的顺序一位一位的依次做比较, 比较出一次结果就直接返回.
str1 = 'ABC'
str2 = 'ABD'

print(str1 > str2)  # False

print(str1 < str2)  # True
1
2
3
4
5
6
7

5. 逻辑运算符

5.1 短路运算

可以使用逻辑运算符进行短路运算.
短路运算的原理: 当多个表达式中, 左边的表达式值可以确定结果时, 
直接返回最后一个参与运算的值, 不继续往后运算.
1
2
3

# x 为 False 返回 x 的值
print(0 and 0)  # 0
print(0 and 1)  # 0
# x 为 True 返回 y 的值
print(1 and 0)  # 0
print(1 and 1)  # 1

1
2
3
4
5
6
7

# x 的值为False , 返回 y 的值.
print(0 or 0)  # 0
print(0 or 1)  # 1
# x 的值为 True, 返回 x 的值
print(1 or 0)  # 1
print(1 or 1)  # 1

1
2
3
4
5
6
7

# 取反
print(not 0)  # True
print(not 1)  # False

1
2
3
4

5.2 练习1

# 连续运算
print(1 and 2 and 3)  # 3

print(1 and 0 and 2)  # 0
#           ↑ 到这里已经能确定结果了, 直接返回这个值.

print(1 and None and 2)
#            ↑ None 到这里已经能确定结果了, 直接返回这个值.

print(1 or 2 or 3)
#     ↑ 1 到这里已经能确定结果了, 直接返回这个值.

1
2
3
4
5
6
7
8
9
10
11
12

5.3 练习2

# 比较大小结果是布尔值
print(7 > 2 or 1)
#         ↑ True

print(7 + 2 or 1)
#         ↑ 9

print(1 and 2 or 0)
#           ↑  2

print(not 1 or 2)
#              ↑ 2

1
2
3
4
5
6
7
8
9
10
11
12
13

5.4 练习3

当表达式较长时, 加括号区分优先级.
7 + 2 > 0 and 7 > 6 + 1 or 1 == 1

and优先级最低, 在两变加括号.
(7 + 2 > 0) and (7 > 6 + 1) or (1 == 1)

* 这种代码几乎不会出现, 一般出现在面试题中.
1
2
3
4
5
6
7

print((7 + 2 > 0) and (7 > 6 + 1) or (1 == 1))
#                                        ↑ True

1
2
3

6. 成员运算符

判断某个个体是否在否个群体当中.
1

str1 = 'abc'
l1 = ['a', 'b', 'c']

# 字符'a' 在  str1中
print('a' in str1)  # True
# 字符'a' 在  l1中
print('a' in list1)  # True

# 字符'q' 不在  str1中
print('q' not in str1)  # True
# 字符'q' 不在  l1中
print('q' not in list1)  # True

1
2
3
4
5
6
7
8
9
10
11
12
13

7. 身份运算符

简单来说就是判断两个对象的id值是否相对, id相等就意味着引用相等, 值肯定一样.
1

注意 is 与比较运算符 == 的区别:
is 用于判断两个变量的引用是否为同一个对象,
== 用于判断变量引用的对象的值是否相等.
1
2
3

# 不可变类型
num1 = 1
num2 = 1

# 判断 id 是否相等.
print(num1 is num2)  # True
print(num1 is not num2)  # False

# 判断值知否相等
print(num1 == num2)  # True

# 不可变类型
list1 = [1, 2, 3]
list2 = [1, 2, 3]

# 判断 id 是否相等.
print(list1 is list2)    # False
print(list1 is not list2)  # True

# 判断值是否相等.
print(list1 == list2)  # True

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

8. 按位运算符

print(1 & 5)  # 1
"""
1 --> 0001
5 --> 0101
----------
1 <-- 0001
"""

print(1 | 5)  # 5
"""
1 --> 0001
5 --> 0101
----------
5 <-- 0101
"""

print(1 ^ 5)  # 4
"""
1 --> 0001
5 --> 0101
----------
4 <-- 0100
"""

# 规律：~x=-(x+1)
print(~1)  # -2

# 规律：~-x=(x-1)
print(~-1)  # 0

# 值 << 左移动的位数  等出4
print(1 << 2)  
"""
1 --> 0001
----------
4 <-- 0100
"""

# 值 << 右移动的位数  等出4
print(4 >> 2)  
"""
4 --> 0100
----------
1 <-- 0001
"""

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

对应内置方法:
.__and__()     按位与      返回 self&value.
__or__()       按位或      返回 self|value.
.__xor__()     按位异或    返回 self^value.
.__rxor__()    值按位异或  返回 value^self.
.__invert__()  按位取反    返回 ~self.
.__lshift__()  左移       返回 self<<value.
.__rshift__()  右移       返回 self>>value.
.__rrshift__() 值右移     返回 value>>self.
1
2
3
4
5
6
7
8
9

9. 运算符优先级

* 在编写的时候应该人为的规定好优先级, 使用括号进行区分.
1

10. 练习

1. 什么是左值? 什么是右值?
2. 什么是成员运算符, 什么是身份运算符?
3. 自己写表达式时, 如何提高代码的可读性?
4. 短路运算的原理是什么? 
1
2
3
4

---

文章的段落全是代码块包裹的, 留言0是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言1是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言2是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言3是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言4是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言5是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言6是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言7是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言8是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言9是为了避免文章提示质量低.

---