算术运算符

python支持的算数运算符与数学上计算的符号使用是一致的（x = 5 , y = 2）：

x = 5 
y = 2 
print(f"x + y = {x + y}") 
print(f"x - y = {x - y}") 
print(f"x * y = {x * y}") 
print(f"x / y = {x / y}") 
print(f"x // y = {x // y}") 
print(f"x % y = {x % y}") 
print(f"x ** y = {x ** y}") 
# x + y = 7 
# x - y = 3 
# x * y = 10 
# x / y = 2.5 
# x // y = 2 
# x % y = 1 
# x ** y = 25

比较运算符

比较运算用来对两个值进行比较，返回的是布尔值（x = 5，y = 2）：

x = 5
y = 2
print(f"x == y = {x == y}")
print(f"x != y = {x != y}")
print(f"x > y = {x > y}")
print(f"x >= y = {x >= y}")
print(f"x < y = {x < y}")
print(f"x <= y = {x <= y}")

# x == y = False
# x != y = True
# x > y = True
# x >= y = True
# x < y = False
# x <= y = False

赋值运算符

python语法中除了有=号这种简单的赋值运算外，还支持增量赋值、链式赋值、交叉赋值、解压赋值，这些赋值运算符存在的意义都是为了让我们的代码看起来更加精简。

增量赋值

x = 5 
x += 2 
print(f"x += 2 = {x}")  # 7 
x = 5 
x -= 2 
print(f"x -= 2 = {x}")  # 3 
x = 5 
x *= 2 
print(f"x *= 2 = {x}")  # 10 
x = 5 
x /= 2 
print(f"x /= 2 = {x}")  # 2.5 
x = 5 
x //= 2 
print(f"x //= y = {x}") # 2 
x = 5 
x %= 2 
print(f"x %= y = {x}")  # 1 
x = 5 
x **= 2 
print(f"x **= y = {x}") # 25

链式赋值

如果我们想把同一个值同时赋值给多个变量名可以这么做：

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

链式赋值指的是可以用一行代码搞定这件事：

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

交叉赋值

如果我们想交换两个变量的值可以这么做：

x = 10 
y = 20 
print(f"x = {x}, y = {y}")  
# x = 10, y = 20 

temp = x 
x = y 
y = temp 
print(f"x = {x}, y = {y}")  # x = 20, y = 10

交叉赋值指的是一行代码可以搞定这件事：

x = 10 
y = 20 
print(f"x = {x}, y = {y}")  # x = 10, y = 20 

x, y = y, x 
print(f"x = {x}, y = {y}")  # x = 20, y = 10

解压赋值

如果我们想把列表中的多个值取出来依次赋值给多个变量名可以这么做：

numbers = [1, 2, 3] 
a = numbers[0] 
b = numbers[1] 
c = numbers[2] 
print(a, b, c)  # 1 2 3

解压赋值指的是一行代码可以搞定这件事：

numbers = [1, 2, 3] 
a, b, c = numbers 
print(a, b, c)  # 1 2 3

解压赋值时等号左边的变量名个数必须与右面包含值的个数相同，否则会报错：

numbers = [1, 2, 3] 
# 变量个数少了 
a, b = numbers 
# Traceback (most recent call last): 
#   File "/Users/fqyy/Downloads/Code/Learn/Python/demo.py", line 3, in <module> #     a, b = numbers 
# ValueError: too many values to unpack (expected 2) 

# 变量个数多了 
a, b, c, d = numbers 
# Traceback (most recent call last): 
#   File "/Users/fqyy/Downloads/Code/Learn/Python/demo.py", line 11, in <module> 
#     a, b, c, d = numbers 
# ValueError: not enough values to unpack (expected 4, got 3)

如果我们只想取头尾的几个值可以用*变量名进行匹配，此时Python会将没有对应关系的值存成列表然后赋值给紧跟其后的变量名：

numbers = [1, 2, 3, 4, 5, 6] 
# 取前面两个 
a, b, *_ = numbers print(a, b)     # 1 2 

# 取后面两个 
*_, a, b = numbers print(a, b)     # 5 6

注意：这里的 _ 是变量名，一般自己定义变量的时候不要使用下划线（ _ ）开头和结尾，或者直接使用下划线（ _ ），从Python的规范上来说它们都有特殊的用处，所有自己定义的变量不要去用。比如这里直接使用下划线（ _ ）接受数据表示该变量一般不会使用，仅仅做为占位符。

除了列表外，字符串、字典、元组、集合类型都支持解压赋值：

# 列表 
l = [1, 2, 3] 
a, b, c = l 
print(a, b, c)  # 1 2 3 

# 元祖 
t = (4, 5, 6) 
a, b, c = t 
print(a, b, c)  # 4 5 6 

# 集合 
s = {7, 8, 9} 
a, b, c = s 
print(a, b, c)  # 8 9 7 

# 字符串 
a, b, c = "abc" 
print(a, b, c)  # a b c 

# 字典  获取的是key值 
a, b, c = {"name": "Tom", "age": 18, "gender": "男"} 
print(a, b, c)  # name age gender

逻辑运算符

逻辑运算符用于连接多个条件进行关联判断，会返回布尔值：

# 逻辑与 
print(1 and 2)  # 2 
print(1 and 0)  # 0 
print(0 and 0)  # 0 

# 逻辑或 
print(1 or 2)   # 1 
print(1 or 0)   # 1 
print(0 or 0)   # 0 

# 逻辑非 
print(not 1)    # False 
print(not 0)    # True

可以用and连接多个条件，会按照从左到右的顺序依次判断，一旦某一个条件为False，则无需再往右判断，可以立即判定最终结果就为False；只有在所有条件的结果都为True的情况下，最终结果才为True：

# 多个and 
# 有一个是False就为False 
print(1 and 0 and 2)    # 0 
# 全部是True的时候才是True 
print(1 and 2 and 3)    # 3

同样也可以用or连接多个条件，此时会按照从左到右的顺序依次判断，一旦某一个条件为True，则无需再往右判断，可以立即判定最终结果就为True；只有在所有条件的结果都为False的情况下，最终结果才为False：

# 多个or 
# 有一个是True就是True 
print(1 or 0 or 2)  # 1 
# 全部是False的时候才是False 
print(0 or 0 or 0)  # 0

注意：三者的优先级关系not > and > or，同一优先级默认从左往右计算。最好使用括号来区别优先级，其实意义与上面的一样。

逻辑运算的结果一旦可以确定，那么就以当前处计算到的值作为最终结果返回，这种现象叫做短路运算：

# 因为or只要有一个为True就是True，因此当获取到1后不会在执行后面的 
print(1 or 0 or 2)    # 1 
# 因为or只要有一个为False就是False，因此当获取到0后不会在执行后面的 
print(0 and 1 and 2)    # 0

成员运算符

# 字符串 
print('a' in 'Hello')       # False 
print('a' not in 'Hello')   # Ture 

# 字典 默认判断是的key 
print('a' in {"name": "age"})   # False 
print('a' not in {"name": "age"})   # True 

# 集合 
print('a' in {'a', 'b'})    # True 
print('a' not in {'a', 'b'})    # False 

# 列表 
print('a' in ['a', 'b'])    # True 
print('a' not in ['a', 'b'])    # False 

# 元祖 
print('a' in ('a', 'b'))    # True 
print('a' not in ('a', 'b'))    # False

注意：虽然两种判断可以达到相同的效果，但推荐使用not in，因为它的语义更加明确。

身份运算符

x = "Hello World" 
y = "Hello World" 
z = x 
print(x is y)  # False 
print(x is not y)  # True 
print(x is z)      # True 
print(x is not z)  # False