算数运算符、比较运算符、赋值运算符、成员运算符、身份运算符、逻辑运算符、位运算符

1、算数运算符（+、-、*、/、//、%、**）

（1）+、-、*、/   （注意：除法运算的出来的结果是float类型,除不尽的情况下保留15-18位小数）

# (1) + 运算
a = 10
b = 20
print(a+b) # 30

# (2) - 运算
print(a - b) # -10

# (3) * 运算
print(a*b) #　200

# (4) / 运算  注意：除法运算的出来的结果是float类型,除不尽的情况下保留15-18位小数
print(10/5) # 2.0
print(5/10) # 0.5
print(10/3) # 3.3333333333333335

（2）//（地板除，保留整数）、%（取余数）、**（次幂计算）  注意：在取余运算中，若除数或者被除数只要有一个是浮点数，则返回浮点数。当被除数小于除数时，结果直接取被除数就好

# (5) // 运算 （地板除，直接取结果的整数部分
res1 = 5//3.0
print(res1,type(res1)) # 1.0 <class 'float'>  
res2 = 5//4
print(res2,type(res2)) #　1 <class 'int'>
res3 = 5//6
print(res3,type(res3)) # 0 <class 'int'>

# (6) % 运算  （取余） 注意：当被除数小于除数时，结果直接取被除数就好
res4 = 5%4
print(res4,type(res4)) # 1 <class 'int'>
res5 = 5%5
print(res5,type(res5)) # 0 <class 'int'>
res6 = 5%6
print(res6,type(res6)) # 5 <class 'int'>
res7 = 5%10
print(res7,type(res7)) # 5 <class 'int'>

print(10%-3) #-2 1+(-3)=-2 #当除数或者被除数有一方为负数时
print(-10%3) #2 -1+3 =2

# (7) ** 运算
res8 = 7**2
print(res8) # 49
res9 = 4**-1
print(res9) # 0.25

（2）比较运算符：>、>=、<、<=、==、!=（比较运算符结果均为bool值）

# (1) > 运算
print(20>10) # True
print(20>20) # False

# (2) >= 运算
print(20>=20) # True
print(30>=20) # True

# (3) < 运算
print(10<20) # True
print(20<20) # False

# (4) <= 运算
print(20<=20) # True
print(10<20) # True

# (5) == 运算  判断两个值是否一样
print(20 == 20) # True
print(19 == 20) # False
print("值相等"=="值相等") # True

# (6) != 运算 判断两个值不一样
print(20!=19) # True
print(20!=20) #　False
print("我是1"!="我是2") # True

（3）赋值运算符：=、+=、-=、*=、/=、//=、%=、**=

# (1) = 赋值
a = 10 # 将10赋值给a

# (2) += 运算
a = 10
b = 20
a += b
print(a) # 30  将a和b相加后赋值给a

# (3) -= 运算
a = 10
b = 20
a -= b
print(a) # -10  将a减去b后再赋值给a

# (4) *=运算
a = 10
b = 20
a *= b
print(a) # 200  将a和b相乘后再赋值给a

# (5) /= 运算
a = 10
b = 20
a /= b
print(a) # 0.5 将a除b的结果再赋值给a

# (6) //= 运算
a = 10
b = 20
a //= b
print(a) #　0　将a除b的整数部分再赋值给a

# (7) %= 运算
a = 10
b = 20
a %= b
print(a) # 10

# (8) **=运算
a = 10
b = 2
a **= b
print(a) # 100 

（4）成员运算符：in、not in 成员运算符仅针对于容器类型（返回值均为bool值）

s1 = "我有一个大家庭"
list1 = ["我","一个","大","家庭"]
tuple1 = ("我","一个","大","家庭")
set1 = {"我","一个","大","家庭"}
dict1 = {"我":"一个","大":"家庭"}
print("有"in s1) # True
print("有"in list1) # False
print("家" in s1) # True
print("家" in tuple1) # False 对于list、tuple、set、dict来说，必须是连续的字符来判断
print("家庭" in set1) # True
print("家庭" in dict1) # False 对于字典来说，判断的值须是字典的key
print("我" in dict1) # True

（5）身份运算符：is、is not  （判断两个值的id是否一样，返回值均为bool值）

a = 20
b = 20
print(a is b,id(a),id(b)) # True 1554285264 1554285264

a = -10
b = -10
print(a is b,id(a),id(b)) # False 2903910697712 2903910697456

a = "我是一个字符串"
b = "我是一个字符串"
print(a is not b,id(a),id(b)) # False 2157711342296 2157711342296

（6）逻辑运算符：not、and、or

   6.1) 运算优先级顺序：() > not > and > or

# (1) not 运算：非运算
a = 10
print(not a) # False

# (2) and 运算：与运算，须式子里的条件都为真，都真为真，一假为假
print(8 and 9) # 9
print(0 and 9) # 0
print(3<4 and 5<4) # False
print(3<4 and 5<6) # True

# (3) or 运算：或运算，式子中有一个条件为真则是真，一真为真，都假为假
print(8 or 9) # 8
print(0 or 9) # 9
print(3<4 or 5<4) # True
print(3>4 or 5>6) # False

res = 3 < 4 and False or 7 > 8 and True and (3 and 8)
# True and False or False and True and True
#False or False
# False
print(res) # False

  6.2) 短路原则：

        如果在and运算中，and前面的条件已经为False了，则值一定为False。在or运算中，如果or前面的条件为True，则结果一定为True

        出现了短路运算，后面的代码就不执行了

（7）位运算符：&、|、^、~、<<、>>

# (1) & 按位与运算：将参与运算的值转为二进制，如果两个值对应的数都为1，则结果对应的值为1，否则为0
a = 5 # 二进制为 000...00101
b = 3 # 二进制为 000...00011
        #   a&b 000...00001
print(a&b) # 1

# (2) | 按位或运算：只要对应的两个二进制有一个是1时，结果位就为1，否则为0
a = 5 # 二进制为 000...00101
b = 3 # 二进制为 000...00011
         #a|b    000...00111
print(a|b) # 7

# (3) ^ 按位异或运算符：当两个值对应的二进制一样时，结果为0，否则为1
a = 5 # 二进制为 000...00101
b = 3 # 二进制为 000...00011
         # a^b  000...00110
print(a^b) # 6

# (4) << 左移：值的二进制左移若干位，高位丢弃，低位补0，左移相当于做乘法，值*2的n次幂
a = 5<<4
"""
5的二进制为 000...00101，向左移4位，000...01010000得到80，按照公式5*2^4=80
"""
print(a) # 80

# (5) >> 右移 值的二进制右移若干位，右移相当于除法，值//2的n次幂
a = 5>>2
"""
5的二进制为 000...00101，向右移2位，000...00001得到1，按照公式5//2^2
"""
print(a) #　1

# (6) ~ 按位非运算符，针对于原值的补码操作，按照原值的补码取反，包括符号位得到按位非的原码。公式 -（n+1）
a = ~5
"""
5的二进制为 000...00101，
按位非码为  111...11010
按位非反码  111...11001,
按位非原码  100...00110
得-6
"""
print(a)

a = ~(-5)
"""
-5的二进制为100...00101,-5的反码为111...11010，-5的补码为111...11011
得按非位的补码为000...00100
得按非位的反码为000...00100
得按非位的原码为000...00100
得4
"""
print(a) # 4

（8）总结

个别运算符：优先级最高的是**运算

                     优先级最低的是=赋值运算

                   （）可以提升优先顺序

整体：一元运算符>二级运算符

        一元运算符：同一时间只操作一个运算符

       二元运算符：同一时间操作两个运算符

同一层级：

               算术：乘除>加减

               逻辑：()>not>and>or

               位运算:(<<、>>)>&>^>|

其他情况：算术>位>比较>身份>成员>逻辑（算位比身成逻）