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还提供了很多便利的赋值语法。

链式赋值

a = b = c =10

'''

等效替代以下：

a = 10					a = 10

b = 10         或		b = a

c = 10					c = b

'''

交叉赋值

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

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  # 即可以代替上述的三行代码

解压赋值

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两个变量绑定了同一个数据值。

"""

结论：

数据值相等，地址不一定相同

地址相同，数据值一定相等

"""