第四章 运算符

1.算数运算符

# + - * / // % **
# +
var1 = 7
var2 = 90
res = var1 + var2
print(res)


# -
var1 = 7
var2 = 90
res = var1 -var2
print(res)


# / 结果永远为小数
var1 = 10
var2 = 5
res = var1 / var2
print(res,type(res))

# // 地板除
"""
被除数除以 除数 = 商
注意点：如果被除数或者除数是小数，那么得到正常结果之后，数值后面带上.0变成小数
"""

var1 = 10.0
var2 = 3.0
res = var1 // var2
print(res)

res = 10.8 // 3.6
print(res)

# % 取余
var1 = 7
var2 = 4
res = var1 %  var2
res1 = -7 % 4  #-3 +4 =1
res = 7 % -4   #3+(-4) = -1
res = -7 % -4 #-3(被除数和除数都是负数，正常结果加负号)
print(res1)

# **幂运算
res = 2**500
print(res)

2.比较远算符

# > < >= <= == !=
res = 10 > 5
res = 10 >= 10
res = 5 == 9
print(res)

res = 5 != 9
print(res)

3.赋值运算符

# = +=  -= *=  /= //= %= **=
# = 赋值运算符 将右侧的值赋值给左侧变量
a = 5 <= 3
print(a)

4.成员运算符

# in和not in （针对容器型数据）
"""字符串判断时，必须是连续的片段"""
strvar = "今天天气要下雨, 赶紧回家收衣服"

res = "今" in strvar
res = "天气" in strvar
res = "赶回" in strvar
print(res)

# 针对于列表，元组，集合
lst = ["小明","小红","小兰"]
lst = ("小明","小红","小兰")
lst = {"小明","小红","小兰"}
res = "小明" in lst
print(res)

# 针对于字典的判断是字典的键，不是值
dic = {"a":"b","c":"d"}

5.身份运算符

# is和 is not （检测俩个数据在内存当中是否是同一个值）

# 整型 -5 ~ 正无穷
var1 = -6
var2 = -6
print( var1 is var2)

# 浮点型 非负数
var1 = -9.1
var2 = -9.1
print(var1 is var2)


# bool 相同即可
var1 = True 
var2 = True
print(var1 is var2)

# complex 在实数+虚数不相同（只有虚数的情况下例外）
var1 = 6-8j
var2 = 6-8j
var1 = -10j
var2 = -10j
print(var1 is var2)


# 容器：相同字符串，空元组相同即可 剩下的所有容器都不相同
con1 = ()
con2 = ()
print(con1 is not con2)

con1 = "你"
con2 = "你"
print(con1 is not con2)

con1 = [1,2,3]
con2 = [1,2,3]
print(con1 is not con2)

6.逻辑运算符

# and or not
# and 逻辑与
res = True and True   #True
res = True and False  #False
res = False and True  #False
res = False and False #False
print(res)


# or 逻辑或
res = True or True   #True
res = True or False  #True
res = False or True  #True
res = False or False #False
print(res)

# not 逻辑非
res = not True
res = not False
print(res)

# 逻辑短路
"""无论后面的表达式是True还是False都已经无法改变最后的结果，那么直接短路，后面的代码不执行"""
True or print("123")  #True
True and print("123") #123

"""
先脑补计算当前表达式的布尔值是True还是False
如果出现了True or 表达式 或者False and 表达式的情况 ，直接返回前者，后面的代码不执行
如果没有出现短路效果，直接返回后者
"""
res1 = 5 and 6 #6
res2 = 5 or 6 #5
print(res1)
print(res2)

# 逻辑运算符的优先级
"""优先级从高到低：() > not > and > or"""
res = 5 or 6 and 7 # 5 or 7 => 5
res = (5 or 6) and 7 #5 and 7
res = not (5 or 6) and 7 
print(res)

7.位运算符

# & | ~ ^ 《》
var1 = 19
var2 = 15


# & 按位与
res = var1 & var2
"""
000 ... 10011
000 ... 01111
000 ... 00011 => 3
"""
print(res)


# | 按位或
res = var1 | var2
"""
000 ... 10011
000 ... 01111
000 ... 11111 => 31
"""
print(res)


# ^ 按位异或
""" 俩个值不相同 => True 反之返回False"""
res = var1^ var2
"""
000 ... 10011
000 ... 01111
000 ... 11100 => 3
"""
print(res)


# << 左移(相当于乘法)
"""5乘以2的n次幂"""
res = 5 << 1 #10
res = 5 << 2 #20
res = 5 << 3 #40
print(res)

"""
000 ...101 => 5
000 ..1010 => 10
000 ..10100 => 20
000 .101000 => 40
"""


# << 右移（相当于除法）
"""5地板除以2的n次幂"""
res = 5 >> 1 #2
res = 5 >> 2 #1
res = 5 >> 3 #0
"""
000 ... 101
000 ... 010 => 2
000 ... 001 => 1
000 ... 000 => 0
"""


# ~ 按位非 (针对于补码进行操作，按位取反，包含每一位)
"""-(n+1)"""
res = ~19 #-20
res = ~-19 #18
print(res)

"""
总结：
    个别运算符
        运算符优先级最高的：**
        运算符优先级最低的：=
        ()可以提升优先级
        
    一元运算符 > 二元运算符（优先级）
        一元运算符：同一时间，操作一个值 ~ -
        二元运算符：同一时间，操作一个值 + - * /
        
    同一种类运算符：
        算数运算符：乘除 > 加减
        逻辑运算符：() > not > and > or
        位运算符：（<< >>）> & > ^ > |
        
    整体排序：
        算位比身成逻
        算数运算符 > 位运算符 > 比较运算符 > 身份运算符 > 成员运算符 > 逻辑运算符
        赋值运算符用来做收尾
"""