基本运算符

算数运算符

以下假设变量a为10，变量b为2：

a = 10
b = 2

print(a + b)  # 12
print(a - b)  # 8
print(a * b)  # 20
print(a / b)  # 5.0
print(a % b)  # 0
print(a ** b)  # 100
print(a // b)  # 5

比较运算符

以下假设变量a为10，变量b为20：

a = 10
b = 20

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

赋值运算符

增量赋值

a = 10
b = 20

a += b
print(a)  # 30

链式赋值

x = y = z = 10

print(x)  # 10
print(y)  # 10
print(z)  # 10

链式赋值一般情况下是不建议赋值给一个空列表

因为列表是可变类型，数据一修改则均被修改了

交叉赋值

x = 10
y = 20
x, y = y, x

print(x)  # 20
print(y)  # 10

解压赋值/解包

name, age = ["小满", 3]

print(name)  # 小满
print(age)  # 3

假如在赋值语句左侧添加小括号 (…)，你甚至可以一次展开多层嵌套数据：

attrs = [1, ("小满", 3)]
user_id, (user_name, age) = attrs

print(user_id)  # 1
print(user_name)  # 小满
print(age)  # 3

除了上面的普通解包外，Python 还支持更灵活的动态解包语法。只要用星号表达式（*variables）作为变量名，它便会贪婪[1]地捕获多个值对象，并将捕获到的内容作为列表赋值给 variables。

比如，下面 data 列表里的数据就分为三段：头为用户，尾为分数，中间的都是水果名称。通过把 *fruits 设置为中间的解包变量，我们就能一次性解包所有变量——fruits 会捕获 data 去头去尾后的所有成员：

data = ["小满", "apple", "orange", "banana", 3, 100]
name, *_, age, score = data

print(name)  # 小满
print(_)  # ['apple', 'orange', 'banana']
print(age)  # 3
print(score)  # 100

逻辑运算符

Python语言支持逻辑运算符，以下假设变量a为10，变量b为20：

a = 10
b = 20
 
print(a and b)  # 20
print(a or b)  # 10
print(not(a and b))  # False

连续问题

在连续多个 and 运算中，如果其中一个条件为 False，则整个表达式的结果为 False，即使后面的条件都为 True

一言以蔽之：有一个False 都为False

x, y, z = 10, 18, 5

#      False       True       False
print((x > y) and (y > z) and (x < z))
# 结果为False

在连续多个 or 运算中，如果其中一个条件为 True，则整个表达式的结果为 True，即使后面的条件都为 False。

一言以蔽之：有一个为True 都为True

x, y, z = 10, 18, 5

#       False       True       False
print((x > y) or (y > z) or (x < z))
# 结果为True

优先级

not > and > or

在逻辑运算中，not 的优先级最高，其次是 and，最后是 or。

当表达式中同时包含这三种运算符时，not 会首先被计算，然后是 and，最后是 or

      #      0                              0
      #                     0          1                             0
print(9 < 4 and 18 > 3 or 1 == 3 or 10 != 9 and "小满" == "小满" or 3 > 3)
# 结果为True

not的优先级最高，就是把紧跟其后的那个条件结果取反，所以not与紧跟其后的条件不可分割

如果语句中全部是用and连接，或者全部用or连接，那么按照从左到右的顺序依次计算即可

如果语句中既有and也有or，那么先用括号把and的左右两个条件给括起来，然后再进行运算

      #      0                              0
      #                     0          1                             0
print((9 < 4 and 18) > 3 or 1 == 3 or (10 != 9 and "小满" == "小满") or 3 > 3)
# 结果为True

短路运算

短路运算是一种逻辑运算符的行为，它在表达式中根据第一个操作数的值决定是否计算第二个操作数。当使用逻辑与运算符 and 时，如果第一个操作数为假，则整个表达式为假，不需要计算第二个操作数；当使用逻辑或运算符 or 时，如果第一个操作数为真，则整个表达式为真，不需要计算第二个操作数。

print((9 < 4 and 18 > 3) or 1 == 3 or (10 != 9 and "小满" == "小满") or (3 > 3 and 9 < 8) or False == 0 or 1 > 7)

# 结果为True

短路运算面试题

8 or 0
8

False and 1
False

0 and 2 and 1
0

False and True or 0.1
0.1

0 and 1 or 2 or 3 and 4
2

0 or False and 1
False

成员运算符

# in
hero_list = ["小满", "王昭君", "小乔"]

print("小满" in hero_list)  # True
print("大乔" in hero_list)  # False

# not in

hero_list = ["小满", "王昭君", "小乔"]

print("小满" not in hero_list)  # False
print("大乔" not in hero_list)  # True

身份运算符

比较的是内存地址

hero_list = ["小满", "王昭君", "小乔"]
name_list = ["小满", "王昭君", "小乔"]

print(hero_list is name_list)  # False

hero_list = ["小满", "王昭君", "小乔"]
name_list = hero_list

print(hero_list is name_list)  # True

name1 = "小满"
name2 = "小满"

print(name1 is name2)  # True

name1 = 1
name2 = 1

print(name1 is name2)  # True

运算符优先级

以下表格列出了从最高到最低优先级的所有运算符：