2.7 Python 运算符

1. 运算符简介

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

* Python 是强类型语言, 不同类型之间是不可以操作的.

2. 算术运算符

运算符	操作	示例
+ 加 (有特殊含义)	两个对象相加.	1 + 1 = 2
- 减	得到负数或两个数相减.	-1, 2 - 0 = 2
* 乘 (有特殊含义)	两个数相乘或重复n次.	2 * 2 = 4
/ 除	被除数 / 除数 = 商	5 / 2 = 2.5
% 模运算, 求余数	被除数 / 除数 = 商···余数	5 % 2 = 2···1
** 幂	底数 ** 指数 = 幂	2 ** 3 = 8
// 整除, 向下取整	被除数 / 除数 = 整商	9 // 4 = 2(向下取整)

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

# 加
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

对应内置方法:
.__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.

3. 增量赋值运算符

运算符	描述 (赋值符号左边的值称为’左值’, 其他的都为’右值’)	对等
= 赋值	将赋值符号 右边 的值赋值给 左边.
+= 加法赋值	n += x, 左值先与右值相加, 在把结果赋值给左值.	n = n + x
-= 减法赋值	n -= x, 左值先与右值相减, 在把结果赋值给左值.	n = n - x
*= 乘法赋值	n *= x, 左值先与右值相乘, 在把结果赋值给左值.	n = n * x
/= 除法赋值	n /= x, 左值先与右值相除, 在把结果赋值给左值.	n = n / x
%= 求余赋值	n %= x 左值先与右值求余数, 在把结果赋值给左值.	n = n % x
**= 幂赋值	n **= x 左值先与右值求幂, 在把结果赋值给左值.	n = n ** x
//= 整除赋值	n **= x 左值先与右值整除, 在把结果赋值给左值.	n = n // x
:= 海象运算符	可在表达式内部为变量赋值, Python3.8 版本新增.

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

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

4. 比较运算符

4.1 比较运算符

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

运算符	描述	示例
> 大于	判断左侧是否大于右侧.	a > b ( a 大于 b )
< 小于	判断左侧是否小于右侧.	a < b ( a 小于 b )
== 等于	判断值是否相等.	a= b ( a 等于 b )
!= 不等于	判断值是否不相等.	a != b ( a 不等于 b )
>= 大于或等于	判断左侧是否大于或等于右侧.	a >= b ( a 大于或等于 b )
<= 小于或等于	判断左侧是否小于或等于右侧.	a <= b ( a 小于或等于 b )

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

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

4.3 字符比较

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

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

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

print(str1 > str2)  # False

print(str1 < str2)  # True

5. 逻辑运算符

运算符	逻辑表达式	描述	示例
and 与	x and y	x 的值为 Flase , 返回 x 的值, x 的值为 True , 返回 y 的值.	1 and 1 值为 1
or 或	x or y	x 的值为 True, 返回 x 的值, x 的值为False , 返回 y 的值.	1 or 0 值为 1
not 非	not x	把 x 的值转为布尔值取反.	not False 值为 True

5.1 短路运算

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

# 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

# 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

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

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 到这里已经能确定结果了, 直接返回这个值.

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

5.4 练习3

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

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

* 这种代码几乎不会出现, 一般出现在面试题中.

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

6. 成员运算符

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

运算符	描述	示例
in	在指定序列中查找值, 找到返回True, 否则返回False.	x在y序列中返回True
not in	在指定序列中查找值, 没找到返回True, 否则返回False.	x不在y序列中返回True

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

7. 身份运算符

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

运算符	描述	实例
is	判断两个标识符的引用是否为同一个对象.	x is x,返回True
is not	判断两个标识符的引用是否为不同对象.	x is not x,返回False

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

# 不可变类型
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

8. 按位运算符

运算符	描述	示例
& 按位与	参与运算的两个值都为 1 结果为 1, 否则都为 0.	1 & 1 值为 1
❘ 按位或	参与运算的有一个值为 1 结果为 1, 否则都为 0.	1 ❘ 0 值为 1
^ 按位异或	参与运算的两个值不同时结果为1, 否则都为 0.	1 ^ 0 值为 1
~ 按位取反	按位取反, 把1变成0, 把0变成1. 规律：~x = -(x+1) , ~-x = (x-1).	~ 0 值为 1
<< 左移	二进制为全部左移n为, 高位丢弃, 低位补0.	num << 2
>> 右移	二进制为全部右移n为, 低位丢弃, 高位补0.	num >> 2

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
"""

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

9. 运算符优先级

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

优先级	符号	运算
1	**	幂, 最高优先级.
2	~ + -	按位取反, 一元运算符 加 减.
3	* / % //	乘 , 除, 求余, 整除.
4	>> <<	右, 左位移.
5	&	按位与.
6	^	按位异或.
7	❘	按位或.
8	<= < > >=	大于等于, 大于, 小于, 小于等于.
9	== !=	等于, 不等于.
10	= += -= *= /= %= //= **=	赋值, 先(加 减乘 , 除, 求余, 整除 , 幂)计算在赋值.
11	is ,is not	身份运算.
12	in not in	成员运算.
13	not and or	逻辑非, 逻辑与, 逻辑或.

10. 练习

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

---

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

---