运算符

Python 学习笔记

一、算术运算符

什么是运算符？

运算符用于执行程序代码运算，会针对一个以上操作数项目来进行运算。 例如：2+3，其操作数是2和3，而运算符则是“+”。

算术运算符表现形式：+ - * /

# 算术运算符 表现形式 + - * /

# 如果是两个字符串相加，则会进行拼串操作
x = 1 + 2
x = 'Logic'+ ' '+'Python'
x = 5 - 2

# 如果是两个字符串相减，则会报错
x = 'h' - 'y'

# 如果将字符串和数字相乘，则会对字符串进行复制操作，将字符串重置制定次数
x = '-' * 20
x = 2 * 2

# 除法运算符总会返回一个浮点类型的值 
x = 6 / 2
x = 3 / 2
x = 7 / 3

# '//' 整除: 只会保留计算后的整数位，总会返回一个整型
x = 7 // 3

# '%'  取模: 求两个数相除的余数
x = 6 % 4
x = 6 % 3

# '**' 幂运算: 求一个值的几次幂
x = 2 ** 4

# 开平方: 也会返回一个浮点型
x = 25 ** 0.5 

---

二、赋值运算符

 x = 2
 x += 3   						 						  # 5 	 		相当于 x = x + 3 
 x -= 3   						 						  # 2	 		相当于 x = x - 3 
 x *= 3   						 						  # 6	 		相当于 x = x * 3 
 x /= 3   												  # 2.0 		 	相当于 x = x / 3 
 x //= 3  						 						  # 0.0 			相当于 x = x // 3 
 x = 5	
 x %= 3   						 						  # 1      		相当于 x = x % 3

---

三、比较运算符

3.1、比较运算符就是用来比较两个值之间的关系，总会返回一个布尔。

>： 比较左侧值是否大于右侧值
<： 比较左侧值是否小于右侧值
>=： 比较左侧值是否大于或者等于右侧值
<=： 比较左侧值是否小于或者等于右侧值

3.2、比较的是对象的 “值”

# 整数 与 整数 比较
  r = 10 > 20			 	 	 						  # False
  r = 30 > 20					 						  # True
  r = 30 < 20 	 				 						  # False
  r = 20 >= 20 					 						  # True

# 整数 与 布尔值 比较
  r = 3 > True 					 						  # 3 > 1

# 整数 与 字符串 比较
  r = 2 > '1' 							    			  # 报错 

# 字符串 与 字符串 比较
  r = '2' > '1' 			  		 					  # True
  r = '2'>'11'  				 						  # True

  r = 'a' > 'b' 		 		 						  # False
  r = 'c' < 'd' 		     	 						  # True

  r = 'ab' > 'b'				 						  # False 
  # 原因是什么？ 如果出现多个字符那么我们比较的方式是对位比较
  # 即，从第一位开始比，若出现结果，则结束比较。如下：

  r = 3 == 3 					 						  # True
  r = 'Python' == 'Python'   	 						  # True
  r = 'bcd' == 'abc' 			 						  # False
  r = 1 == True 				 						  # True False 可以看做是整数 0 == =

3.3、比较对象的 “id”，用 is 和 is not

• is： 比较两个对象是否是一个对象
• is not： 比较两个对象是否不是同一个对

  r = 0 == False				 						  # True  , 值相等
  r = 0 is False				 						  # False , id不相等
  
  r = 1 == True					 					 	  # True  , 值相等
  r = 1 is not True				 						  # True  , id不相等

---

四、逻辑运算符

4.1、not 逻辑 “非”

可以对符号右侧的值进行非运算
对于布尔值，非运算会对其进行取反操作。not True -> Fasle , not False -> True
对于非布尔值，会先将其转换为布尔值，然后在取反。 例如： 0、空、None 还有一些其他是空性的值会转换成 False, 剩下的都是 True

a = True
a = not a
a = None 												  # 对于非布尔值，会先将其转换为布尔值，然后在取反
a = not a

4.2、and 逻辑 “与”

and 逻辑与 可以对符号两侧的值进行与运算
只有在符号两侧都是 True 的情况下才会返回 True，只要有一个 Fasle 就会返 回 False。( 说白了与运算就是找 Fasle )

r = True and True 										  # True
r = True and False 										  # False
r = False and True 										  # False
r = False and False 									  # False

r = False and print('Hello') 							  # False , 因为只要有一个 Fasle 就会返 回 False .

4.3、or 逻辑 “或”

or 可以对符号两侧的值进行或运算
或运算两个值只要有一个 True , 就会返回 True, 或运算就是找 True

r = True or True 										  # True
r = True or False 										  # True
r = False or True 										  # True
r = False or False 										  # False

r = True or print('Hello')	 							  # True , 因为只要有一个 True 就会返 回 True .

4.4、非布尔值的 “与、或” 运算

当我们对非布尔值进行与或运算的时候，Python会将其当做布尔值进行运 算，最终会返回原值

非布尔值的 “与” 运算的规则：
与运算找 Fasle，如果第一个值是 Fasle，则直接返回第一个值，就不看第二个值；
如果第一个值是 True，则直接返回第二个值。

# True   False
r = 1 and 0 											  # 0

r = 0 and None 											  # 0
r = 1 < 2 < 3 											  # True , 相当于 1 < 2 and 2 < 3
r = 1 < 2 > 3 											  # False , 相当于 1 < 2 and 2 > 3

非布尔值的 “或” 运算的规则：
或运算就是找 True，如果第一个值是True，则直接返回第一个值，则不看第二个值；
如果第一个值是 False，则返回第二个值。

# True  True
r = 1 or 2 												  # 1

r = 1 or 0 											 	  # 1
r = 0 or 1												  # 1
r = None or 0											  # 0

---

五、条件运算符（三元运算符）

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

• 若表达式为 True，则返回 " 语句1 "
• 若表达式为 False，则返回 " 语句2 "

  a = 60
  b = 80
  print('a的值大')  if  (a > b)  else  print('b的值大')

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


# 现在有 a b c三个变量 请通过条件运算符获取三个值当中的最大值
  a = 80
  b = 50
  c = 90
# 条件运算符
## （方法 1）
  max = a  if  (a > b)  else  b
  max = max  if  (max > c)  else  c
  print(max)
## （方法 2, 一般不这么写）
  max = a  if  (a > b and a > c)  else  (b if (b > c) else c)
  print(max)

---

六、运算符的优先级

官网有表格，越往下优先级越高。
https://docs.python.org/3/reference/expressions.html#operator-precedence

a = 2 or 3 and 4

# 若：or 和 and 优先级一样, 从左往右运算. 则 => (2 and 4) => 结果 4
# 若：or 优先级高. 则 => (2 and 4) => 结果 4
# 若：and 优先级高. 则 => (2 or 4) => 结果 2

运行得出, 结果是 2. 所有 and 的优先级高

# 运算符的优先级可以根据表格来查询, 越往下优先级越高 .
# 规则:优先级越高越优先计算, 如果优先级一样就是从左往右计算 .

练习：
a = not (4 > 2) and (5 > 6) or (3 < 4) 					  # True
a = not (4 > 2 and 5 > 6 or 3 < 4) 						  # False