03. 运算符

一、运算符与表达式

  运算符 就是对字面量或者变量进行操作的符号；表达式 是指用运算符把字面量或者变量连接起来，符合 Python 语法的式子。不同运算符连接的表达式体现的是不同类型的表达式；Python 中的运算符主要包括 算术运算符、赋值运算符、比较（关系）运算符、逻辑运算符 和 位运算符。

二、算数运算符

  算术运算符是用来处理四则运算的符号。

算数运算符	运算	范例	结果
+	加	5 + 2	7
-	减	5 - 2	3
*	乘	5 * 2	10
/	除	5 / 2	2.5
%	取模（取余）	5  % 2	1
//	取整除，返回商的整数部分	5 // 2	2
**	幂，即返回 x 的 n 次方	5**2	25，即 $ 5^{2}$

a = 5
b = 2
print(a, "+", b, "=", (a + b))      # 5 + 2 = 7
print(a, "+", b, "=", (a - b))      # 5 - 2 = 3
print(a, "+", b, "=", (a * b))      # 5 * 2 = 10
print(a, "+", b, "=", (a / b))      # 5 / 2 = 2.5
print(a, "+", b, "=", (a % b))      # 5 /% 2 = 1
print(a, "+", b, "=", (a // b))     # 5 // 2 = 2
print(a, "+", b, "=", (a ** b))     # 5 ** 2 = 25

a = "hello"
b = "world"
print(a, b, "=", (a + b))           # hello + world = helloworld

在代码中，如果有小数参与运算，其结果可能是不精确的；

% 取模运算结果的正负与被模数一致，即：a%b 等价于 a-a/b*b，取模结果的正负与 a 的正负一致；

字符串之间也可以进行加法运算。如果将两个字符串相加，则会自动将两个字符串拼接为一个字符串；

如果将字符串和数字相乘，则会对字符串进行复制操作，即把字符串重复指定的次数并返回，例如："字符串"*m，表示将字符串复制 m 次；

使用除法运算符（/ 或 //）和取余运算符时，除数不能为 0，否则会报以下异常：ZeroDivisionError: division by zero

三、赋值运算符

  赋值运算符 用于将右侧表达式的值赋值给左侧变量。

赋值运算符	运算	范例	结果
=	赋值	a = 10	将 10 赋值给变量a
+=	加后赋值	a += b	将 a + b 的值给 a
-=	减后赋值	a -= b	将 a - b 的值给 a
*=	乘后赋值	a *= b	将 a * b 的值给 a
**=	幂运算后赋值	a **= b	将\(a^b\) 的值给 a
/=	除后赋值	a /= b	将 a / b 的值给 a
//=	整除后赋值	a //= b	将 a//b 的值给 a
%=	取余后赋值	a %= b	将 a % b 的值给 a

# 多个变量赋值时使用逗号分隔
a,b = 10,5

a += b
print("a = ",a)         # 15
print("b = ",b)         # 5
print()

a = 10
b = 5

a -= b
print("a = ",a)         # 5
print("b = ",b)         # 5
print()

a = 10
b = 5

a *= b
print("a = ",a)         # 50
print("b = ",b)         # 5
print()

a = 10
b = 5

a **= b
print("a = ",a)         # 100000
print("b = ",b)         # 5
print()

a = 10
b = 5

a /= b
print("a = ",a)         # 2.0
print("b = ",b)         # 5
print()

a = 10
b = 5

a //= b
print("a = ",a)         # 2
print("b = ",b)         # 5
print()

a = 10
b = 5

a %= b
print("a = ",a)         # 0
print("b = ",b)         # 5

四、关系运算符

  关系运算符 也被称为 比较运算符；它用于表达式的 比较，并返回一个 真值 或 假值。

关系运算符	运算	范例	结果
==	比较两个对象的值是否相等	4 == 3	False
!=	比较两个对象的值是否不相等	4 != 3	True
<	比较左侧值是否小于右侧值	4 < 3	False
>	比较左侧值是否大于右侧值	4 > 3	True
<=	比较左侧值是否小于等于右侧的值	4 <= 3	True
>=	比较左侧值是否大于等于右侧的值	4 >= 3	True

a = 4
b = 3

print(a, " == ", b, ": ", (a == b))     # False
print(a, " != ", b, ": ", (a != b))     # True
print(a, " <  ", b, ": ", (a < b))      # False
print(a, " <= ", b, ": ", (a <= b))     # False
print(a, " >  ", b, ": ", (a > b))      # True
print(a, " >= ", b, ": ", (a >= b))     # True

a = "1"
b = "2"
print(a, " < ", b, ": ", (a < b))       # True  

a = "abc"
b = "ab"
print(a, " > ", b, ": ", (a > b))       # True

a = 1
b = True
print(a, " == ", b, ": ", (a == b))     # True

  在 Python 中，关系运算符可以连的使用。

result = 1 < 2 < 3	# 相当于 1 < 2 and 2 < 3
print(result)

result = 10 < 20 > 15   # 相当于 10 < 20 and 20 > 15
print(result)

在 Python 中可以对字符串进行大于（等于）或小于（等于）的运算，当对字符串进行比较时，实际上比较的是字符串的 Unicode 编码，比较两个字符串的 Unicode 编码时，是逐位比较的；

如果不希望比较两个字符串的 Unicode 编码，则需要将其转换为数字然后进行再进行比较；

相等和不等比较的是对象的值，而不是 id

五、逻辑运算符

  逻辑运算符 用于根据表达式的值返回 真值 或 假值。对于非布尔值进行逻辑运算，会将数据转换为布尔值，然后再进行逻辑运算。

  在 Python 中，所有的对象都可以进行真值测试，其中只有下面列出的几种情况得到的值为假。

• False 或 None
• 数值中的零，包括 0、0.0、虚数0
• 空序列，包括 字符串、空元组、空列表、空字典
• 自定义对象的实例，该对象的 __bool__ 方法返回 False 或者 __len__ 方法返回 0

逻辑运算符	功能
and	逻辑与，全真为真，有假为假
or	逻辑或，有真为真，全假为假
not	逻辑非，非假为真，非真为假

  运算结果：

a	b	a and b	a or b	not a
True	True	True	True	False
True	False	False	True	False
Flase	True	False	True	True
False	False	False	False	True

a = True
b = True
c = False
d = False

print(a, " and ", b, ": ", (a and b))   # True
print(a, " and ", c, ": ", (a and c))   # False
print(c, " and ", d, ": ", (c and d))   # False
print()

print(a, " or ", b, ": ", (a or b))     # True
print(a, " or ", c, ": ", (a or c))     # True
print(c, " or ", d, ": ", (c or d))     # False
print()

print("not ", a, ": ", (not a))         # False
print("not ", c, ": ", (not c))         # True
print()

# 对于非布尔值进行逻辑运算，会先将数据转化为布尔值，然后再进行逻辑运算
a = 1
print("not ", a, ": ", (not a))         # False

  在 Python 中 与运算 和 或运算 都具有短路效果，即当左边的表达式能确定最终结果时，那么右边就不会参与运算了；

• 与运算符；与运算是找 False的，如果第一个值为 False，则不再看第二个值。
• 或运算符：或运算是找 True 的，如果第一个值为 True，则不再看第二个值。

print("与运算的短路运算")
True and print("我执行了")
False and print("我不会执行")
print()

print("或运算的短路运算")
True or print("我不会执行")
False or print("我执行了")

  当我们对非布尔值进行与或运算时，Python 会将其当作布尔值运算，最终会返回原值。与运算是找 False 的，如果第一个值是 False，则直接返回第一个值，否则返回第二个值。或运算是找 True 的，如果第一个值是 True，则直接返回第一个值，否则返回第二个值。

print("非布尔值的与运算")
# Ture and True
print("1 and 2: ", (1 and 2))        # 2
# True and False
print("1 and 0: ", (1 and 0))        # 0
# False and True
print("0 and 1: ", (0 and 1))        # 0
# False and False
print("0 and None: ", (0 and None))  # 0
print()

print("非布尔值的或运算")
# Ture or True
print("1 or 2: ", (1 or 2))        # 1
# True or False
print("1 or 0: ", (1 or 0))        # 1
# False or True
print("0 or 1: ", (0 or 1))        # 1
# False or False
print("0 or None: ", (0 or None))  # None

六、身份运算符

身份运算符	功能
is	判断两个表示是否引用同一个对象，若引用的是同一个对象则返回 True，否则返回 False
is not	判断两个表示是否引用同一个对象，若引用的不是同一个对象则返回 True，否则返回 False

a = 123
b = 123
c = -123
d = -123

print("id(a): ",id(a))
print("id(b): ",id(b))
print("id(c): ",id(c))
print("id(d): ",id(d))
print(f"a = {a},b = {b},c = {c},d = {d}")
print()

print("a is b: ", (a is b))             # True
print("a is c: ", (a is c))             # False
print()

print("a is not b: ", (a is not b))     # False
print("a is not c: ", (a is not c))     # True
print()

print("a is b: ",(a is b))
print("c is d: ",(c is d))

在 Python 解释器启动的那一刻开始，就会在内存中实现申请好一系列内存空间存放好常用的整数，范围为 [-5,256]。

如果用 Pycharm 等 IDE，会自动优化；

七、成员运算符

成员运算符	功能
in	在指定序列中找到值时返回 True，否则返回 False
not in	在指定序列中没有找到值时返回 True，否则返回 False

a = "s"
b = "a"
c = "Sakura"

print("a = ", a,", b  = ", b,", c = ", c)
print()

print("a in c: ", (a in c))                 # False
print("a not in c: ", (a not in c))         # True
print()

print("b in c: ", (b in c))                 # True
print("b not in c: ", (b not in c))         # False

八、位运算符

  位运算符是直接对整数的二进制进行的运算； 所有数字在计算机底层都以二进制形式执行；所有的整数值底层都以补码的方式存储；

• 正数：三码合一，符号位为 0；
• 负数：符号位为 1
  • 原码：直接将数值转成二进制数，最高位是符号位；
  • 反码：对原码按位取反，符号位不变；
  • 补码：其反码加 1；

位运算符	运算	范例
<<	左移，空位补0，被移除的高位舍弃	3 << 2 = 12
>>	右移，空位使用符号位填充，被移除的低位舍弃	3 >> 1 = 1
&	与运算，二进制位进行与运算，全1为1，有0为0	6 & 3 = 2
|	或运算，二进制位进行或运算，有1为1，全0为0	6| 3 = 7
^	异或运算，二进制位进行异或运算，相同为0，不同为1	6 ^ 3 = 5
~	按位取反，二进制位进行取反运算，非0为1，非1为0	~6 = -7

print("3 << 2: ", (3 << 2))        # 12
print("3 >> 1: ", (3 >> 1))        # 1
print("-3 >> 1: ", (-3 >> 1))      # -2
print("6 & 3: ", (6 & 3))          # 2
print("6 | 3: ", (6 | 3))          # 7
print("6 ^ 3: ", (6 ^ 3))          # 5
print("~6: ", (~6))                # -7

<<：在一定范围内，每向左移一位，相当于乘以2；

>>：在一定范围内，每向右移一位，相当于除以2；

九、三元运算符

  三元运算符的格式如下：

语句1 if 条件表达式 else 语句2

  它的执行流程如下：

• 条件运算符在执行时，会先对条件表达式进行求值判断
  • 如果判断结果为 True，则执行语句1，并返回执行结果
  • 如果判断结果为 False，则执行语句2，并返回执行结果

num = int(input("请输入一个数："))
print("你输入的数比10大") if num > 10 else print("你输入的数不大于10")

a = 10
b = 20

max = a if a > b else b
print(max)

三元运算符一定可以改成 if-else 语句，反之不成立；

如果程序既可以使用三元运算符又可以使用 if-else 语句，优先使用三元运算符；

十、运算符的优先级

  我们可以使用小括号来提升运算符的优先级；

优先级	运算符	名称或含义	使用形式	结合方向	说明
1	(expressions...)	圆括号	(表达式)	左到右
	[expressions...]	列表	[表达式]	左到右
	{key:value}	字典	{键:值}	左到右
	{expressions...}	集合	{表达式}	左到右
2	[index]	索引	[常量]	左到右
	[start:end:step]	切片	[起始索引:结束索引:步长]	左到右
	x(arguments...)	方法调用	方法名(形参列表)	左到右
	x.attribute	属性访问	对象.属性	左到右
3	**	乘方	表达式**表达式	左到右
4	+	正号运算符	+表达式	右到左	单目运算符
	-	负号运算符	-表达式		单目运算符
	~	按位取反	~表达式	左到右
5	*	乘	表达式 * 表达式	左到右	双目运算符
	/	除	表达式 / 表达式		双目运算符
	//	整除	表达式 // 表达式		双目运算符
	%	取余	表达式 % 表达式		双目运算符
6	+	加	表达式 + 表达式	左到右	双目运算符
	-	减	表达式 - 表达式		双目运算符
7	<<	左移	变量 << 表达式	左到右	双目运算符
	>>	右移	变量 >> 表达式		双目运算符
8	&	按位与	表达式 & 表达式	左到右	双目运算符
9	^	按位异或	表达式 ^ 表达式	左到右	双目运算符
10	|	按位或	表达式 | 表达式	左到右	双目运算符
11	>	大于	表达式 > 表达式	左到右	双目运算符
	>=	大于等于	表达式 >= 表达式		双目运算符
	<	小于	表达式 < 表达式		双目运算符
	<=	小于等于	表达式 <= 表达式		双目运算符
	==	等于	表达式 == 表达式		双目运算符
	!=	不等于	表达式 != 表达式		双目运算符
	is	is 运算符	变量 is 变量	左到右	双目运算符
	is not	is not 运算符	变量 is not 变量		双目运算符
	in	in 运算符	元素 in 序列	左到右	双目运算符
	not in	not in 运算符	元素 not in 序列		双目运算符
12	not	逻辑非	not 表达式	左到右	单目运算符
13	and	逻辑与	表达式 and 表达式	左到右	单目运算符
14	or	逻辑与	表达式 and 表达式	左到右	单目运算符
15	if-else	三元表达式	语句1 if 条件表达式 else 语句2
16	=	赋值运算符	变量=表达式	右到左
	/=	除后赋值	变量/=表达式
	*=	乘后赋值	变量*=表达式
	%=	取模后赋值	变量%=表达式
	+=	加后赋值	变量+=表达式
	-=	减后赋值	变量-=表达式
	<<=	左移后赋值	变量<<=表达式
	>>=	右移后赋值	变量>>=表达式
	&=	按位与后赋值	变量&=表达式
	^=	按位异或后赋值	变量^=表达式
	|=	按位或后赋值	变量|=表达式