python中的各种运算符

运算符

基本运算符

+加 -减 *乘 /除 %取余 //取整 **幂运算

n = n + 1可以简化为 n += 1
同理有：
n -= 2  # n = n - 2
n *= 3  # n = n * 3
n /= 4  # n = n / 4
n %= 5 # n = n % 5
n //= 6  # n = n // 6
n **= 7  # n = n ** 7

比较运算符

比较运算符会产出布尔类型的数据值，有：

>   <   >=     <=    ==等于     !=不等于      =是赋值符号不是比较运算符
print(2 >= 2)  # True

赋值运算符

除了常规的赋值运算符=，python还提供了很多便利的赋值语法。

1. 链式赋值

   a = b = c =10
   '''
   等效替代以下：
   a = 10					a = 10
   b = 10         或		b = a
   c = 10					c = b
   '''
   

2. 交叉赋值

   如何替换两个变量的值呢？这是小白在编程时容易犯错的地方

   m = 10
   n = 20  # 尝试交换m与n的值
   # 错误示范
   m = n
   n = m
   print(m, n)
   # 20 20  	因为m重新绑定了n的值20，所以10的绑定就断了，n无法通通过m找到10
   

   所以这时就要用到中间变量来存储原本m的值10

   temp = m
   m = n
   n = temp
   print(m, n)  # 20 10
   

   但是这样代码比较长，python为了方便提供了以下语法：

   m, n = n, m  # 即可以代替上述的三行代码
   

3. 解压赋值

   t1 = (111, 222, 333)
   a, b, c = t1
   # 等同于
   a = t1[0]
   b = t1[1]
   c = t1[2]
   

   解压赋值可以帮我们很快的从元组、列表中取出多个元素赋值给多个变量

   # 正常情况下，变量的个数和元组、列表的元素个数要相一致，多了或少了都会报错
   l1 = [111, 222, 333]
   a, b, c, d = l1  # not enough values to unpack (expected 4, got 3)
   a, b = l1  # too many values to unpack (expected 2)
   

   但是变量中有一个异类，*变量名可以接收所有没有被接收的变量并组合成列表

   l1 = [111, 222, 333, 444, 555]
   a, b, *c = l1
   print(a, b, c)  # 111 222 [333, 444, 555]
   # 不仅可以在最尾部接收还可以在中部
   a, b, *c, d = l1
   print(a, b, c, d)  # 111 222 [333, 444] 555
   

   即这个变量可以接收我们不需要的值，我们只取头部的值或者尾部的值都是可以的

   既然这个变量并不需要用，那么可以用*_来接取其余值，因为单下划线一般不做变量名。

逻辑运算符

我们常听到的与、或、非就是逻辑运算

Python中对应的关键字为and|or|not

• and-与

  and两侧的两个条件都成立则得出成立，即True属性

  # 注意下面的例子中，比较运算符是得到显性的bool值，
  # 而其他的条件则本身不是布尔值但是带有布尔属性
  print(222 and 3 > 2)  # True
  两个都是为真，输出真
  print(0 and 3 > 2)  # 0
  左边为假属性，直接绑定这个带假属性的值，所以绑定的是0
  print(2 < 3 and [1, 2])  # [1, 2]
  两个都是真属性，先判断左边，发现为真后，只取决于右边，绑定右边的值，为[1, 2]
  print(2 and 0 and 3 > 4)  # 0
  多个and串联，从左至右逐一判断，遇到假属性则直接为假，所以绑定第一个假属性，为0
  print(3 > 4 and 222 and 3 > 2)  # False
  多个and串联，从左到右判断，第一个就为False假，绑定False
  

• or-或

  or两侧的两个条件，只要一个是成立的，则成立，即True属性

  print(222 or 3 > 2)  # 222
  两个有一个为真就为真，先判断左边，所以绑定带真属性的222
  print(0 or 3 > 3)  # False
  两个都为假则为假，先判断左边为假，取决于右侧条件，比较得出False
  print(4 <= 3 or [1, 2])  # [1, 2]
  左侧判断为假，取决于右侧条件，判断为真，绑定列表[1, 2]
  print(2 or 0 or 3 > 4)  # 2
  多个or串联，第一个就为真，直接判断为真，绑定值 2
  print(3 > 4 or [] or 3 < 2)  # False
  多个or串联，3个都为假，判断到最后一个确定为假，绑定了最后一个条件产生的 False
  
  

• not-非

  非，即真假转换，成立前面加个not就是不成立

  print(not 2 >1)  # True
  print(not 1 < 2) # False
  

and\or\not混用时的优先级顺序，这个顺序是存在的，但是并不需要记忆，我们应该用括号来划分条件判断的优先级，不然这样的程序是难以识别的。

print((3 > 4 or ([] and 111)) and 3 < 2)
# 判断，首先最外层是and连接的两个条件，and左边括号中是or连接的两个条件，or右侧是and连接的两个条件，以此类推，得到[]的结果。

成员运算符

成员运算符in用于判断一个数据值是否存在于字符串、元组、列表、集合和字典中。

• 列表成员判断

  name_list = ['leethon', 'jay', 'tom', 'frank']
  print('kevin' in name_list)   # False
  print('kevin' not in name_list)  # True
  print('ja' in name_list)  # False
  # 同样也适用于元组和集合。
  # 最小的元素是列表中的元素，元素所含的字母不能做运算
  

• 字符串成员判断

  name = 'leethon'
  print('e' in name)   # True
  print('k' in name)  # False
  print('le' in name)  # True
  # 字符串的最小元素是一个字，也可以是字的组合
  

• 字典成员判断

  info_dict = {'name': 'leethon', 'age': 18}
  print('leethon' in info_dict)  # False
  print('name' in info_dict)  # True
  # 字典只有键参与成员运算，其键对应的值不参与成员运算
  

身份运算符

身份运算符is判断的是两侧的数据值是否存在一个地址中。

id()可以得到括号内变量的存放地址的映射值，可以反映一个变量的存放地址。
# 如
l1 = [1, 2, 3]
l2 = [1, 2, 3]
print(id(l2))  # 2706939965824
print(id(l1))  # 2706939966784
# 两者的地址不一样
print(l1 is l2)  # False

进阶：小整数池优化

当不同变量绑定的数据值相等，且这些数据比较小时，系统会识别优化，让所有的变量都绑定一个地址，这个地址存入这个相等的数据值。而不是每一个变量分别绑定不同的地址，每个地址存入这个相等的数据值。

i1 = 10
i2 = 10 
print(i1 is i2)  # True
# 说明，i1和i2两个变量绑定了同一个数据值。
"""
结论：
数据值相等，地址不一定相同
地址相同，数据值一定相等
"""