python运算符

(1)算数运算符:  + - * / // % **
(2)比较运算符:  > < >= <= == !=   
(3)赋值运算符:  = += -= *= /= //= %= **=
(4)成员运算符:  in 和 not in (针对于容器型数据)
(5)身份运算符:  is 和 is not (检测两个数据在内存当中是否是同一个值)  
(6)逻辑运算符:  and or not
(7)位运算符:    & | ~ ^ << >>

python运算符	注意点
算数运算符	% 取余 ， //地板除 ， ** 幂运算
比较运算符	== 比较两个值是否相等 != 比较两个值是否不同
赋值运算符	a += 1 => a = a+1
成员运算符	in 或 not in 判断某个值是否包含在(或不在)一个容器类型数据当中
身份运算符	is 和 is not 用来判断内存地址是否相同
逻辑运算符	优先级 () > not > and > or
位运算符	优先级 (<<或 >> ) > & > ^ > | 5 << 1 结果：10 , 5 >> 1 结果：2

(一).算数运算符: + - * / // % **

var1  = 6
var2  = 2

1): + 加法

res = var1 + var2

2): - 减法

print(6-2)

3): * 乘法

print(6*2)

4): / 除法

print(6/2)

5): // 地板除(整除):如果除数或者被除数存在小数,那么就在结果上.0

print(6//3.5)

6): % 取余

print (5%3)
print(6%2)
print(10%3)

7): 负数取余

print(-7 % 4) #-3+4 = 1
print(7 % -4)  # 3+(-4) = -1
print(-7 % -4) # -3把余数先算出来,然后前面带个负号即可

print (-86 % 3)
print(86 % (-3))
print((-86) % (-3))

8): ** 幂运算

print(3**3)
print(3**2)

(二).比较运算符: > < >= <= == != 只会产生bool类型 True 和False

var1 = 8
var2  = 10
print(var1 > var2)
print(var1 < var2)
print(var1 >= var2) #大于或者等于,有一个条件满足即可
print(var1 <= var2) #小于或者等于,有一个条件满足即可
print(var1 == var2) # 比较二个值是否相等
"""
赋值=,将右侧的值赋值给左侧var1
var1 = var2
==:比较二个变量的值是否相同,返回True或者False
var1 == var2
"""
print(var1 != var2) 

(三).赋值运算符: = += -= *= /= //= %= **=

var1 = 10
var2 = 2

#= 从右向左看,将右侧的值赋值给左侧变量
#var1 = var2
#print(var1,var2)

1) +=

var1 = var1 + var2 或者 var1 += var2

2) -=

var1 =var1 - var2 或者 var1 -= var2

3) *=

var1 = var1 * var2 或者 var1 *= var2

4) /=

var1 = var1 / var2 或者 var1 /= var2  

5) //=

var1 = var1 // var2 或者 var1 //= var2

6) %=

var1 = var1 % var2 或者 var1 %= var2

7) **=

var1 = var1 ** var2 或者 var1 **= var2

(四).成员运算符: in 和 not in (针对于容器型数据)

1) str 必须是一段连续的片段

strvar = strvar = "如果遇到你是一种错,那我宁愿一错再错"

print("如果" in strvar)
print("遇到" in strvar)
print("宁 错" in strvar)

2) list tuple set

list_var = ["taibai","wusir","alex",'wuchao']
tuple_var = ("taibai","","alex",'wuchao')
set_var = {"taibai","wusir","alex",'wuchao'}

res = "taibai" in list_var
print(res)

res = "wusir" in tuple_var
print(res)

res = "alex" in set_var
print(res)

3) dict ,in 或者not in 在字典当中判断的是键

dict_var = {1:"taibai",2:"wusir",3:"alex",4:'wuchao'}

(五).身份运算符:is 和is not (检测两个数据在内存当中是否是同一个内存地址)

1)整型 -5~正无穷

var1 = 10
var2 = 10
res =var1 is var2
print(res)
print(id(var1),id(var2))

2)浮点型 非负数

var1 = -6.7
var2 = -6.7
res = var1 is not var2
print(res)

3)布尔型 只要值相同即可

var1 = True
var2 = True

res = var1 is  var2
print(res)

4)complex 实数 + 虚数 永远不同,值有虚数列外

var1 = 1j
var2 = 1j
print(var1 is var2)

5)判断类型

# int float complex bool str list tuple set dict
res = isinstance(15,int)
res = isinstance(3.56,list)
# 把可能的类型放在元组里,有一个满足条件,即返回真.
res = isinstance([1,2,3] ,(int,float,str,list) )
print(res)

(六).逻辑运算符: and or not

1)and 逻辑 与

"""全真则真,一假则假"""
res = True and True  # 真
res = True and False # 假
res = False and True # 假
res = False and False# 假
print(res)

2)or 逻辑 或

"""全假则假,一真则真"""
res = True or True  # 真
res = True or False # 真
res = False or True # 真
res = False or False# 假
print(res)

3)not 逻辑 非

"""真变假,假变真"""
res = not True
print(res)
res = not False
print(res)

4)逻辑短路:如果出现短路,后面的代码不执行

(1)True or 值
(2)False and 值

res = print(123)
print(res) #None等于没有返回值,是系统自定义的

#如果出现短路,后面的代码不执行
True or print(3333) # 1
False and print(88888) # 2

res = 5 or 6
print(res)

res = 5 and 6
print(res)

res = 0 and 8
print(res)

5)逻辑运算符的优先级

() > not > and > or
#案例1 
#True or 表达式 直接短路 直接返回前面的值
res = 5 or 6 and 7 # 5 or 7 = 5
print(res)


res = (5 or 6) and 7 #5 and 7 =7
print(res)

res = not (5 or 6 ) and 7 #not (5) and 7 =False
print(res)

#在确定不了是否短路时候,通过优先级先算and 再算or
res = False and 7 or 9 and 10 #False or 10
print(res)

#案例2
res = 5 > 8 and 7 < 9
# res = False and  True =  False
res = 6 < 10 or 7 > 10
res = 7>90 and 5>3 or 11<19 and 20<80 or 1>-9
# False and True or True and True or True
# False or True or True => True
print(res)

(七)位运算符: & | ~ ^ << >> 针对的是二进制

1)按位与 &

var1 = 19
var2 = 15
print(var1 & var2)
"""
分解过程:
000 ... 10011
000 ... 01111
000 ... 00011   
"""

2)按位或 |

var1 = 19
var2 = 15
print(var1 | var2)
"""
分解过程:
000 ... 10011
000 ... 01111
000 ... 11111
"""

3)按位异或 ^ 两者如果不相同则为真,相同则为假

var1 = 19
var2 = 15
print(var1 ^ var2)
"""
分解过程:
000 ... 10011
000 ... 01111
000 ... 11100
"""

4)<< 左移 5 * 2的2次幂

res =  5 << 2
print(res)
"""
分解过程:
000 ... 101
000 ..10100
"""

5)>> 右移 5 // 2的1次幂

res = 5 >> 1
print(res)
"""
分解过程:
000 ... 101
000 ... 010
"""

6) 按位非 ~ [针对于补码进行操作 每一位取反,包括符号位]

var1 = ~19
print(var1)
"""
原码:000 ... 10011
反码:000 ... 10011
补码:000 ... 10011


补码:000 ... 10011
按位非:111 ... 01100

补码:111 ... 01100
反码:100 ... 10011
原码:100 ... 10100 -20
"""

var1 = ~(-19)
print(var1)
"""
原码:100 ... 10011
反码:111 ... 01100
补码:111 ... 01101

补码:  111 ... 01101
按位非:000 ... 10010

# 正数的原码 == 反码 == 补码
000 ... 10010 => 18
"""

总结:

(1) 个别运算符:
    优先级最高的 ** 幂运算 
    优先级最低的 = 赋值运算
    () 括号可以提升运算的优先级
    
(2) 整体一元运算符 > 二元运算符
    一元运算符:同一时间,操作一个值.[- , ~]
    二元运算符:同一时间,操作两个值.[+ , -]
    
(3) 注意点
    乘除 > 加减
    () > not > and > or
    ( << >> ) > & > ^ > |

(4) 其他情况
    算数运算符 > 位运算符 > 比较运算符 > 身份运算符 > 成员运算符 > 逻辑运算符
    赋值运算符 用来将算好的值 赋值给左侧变量. 用来收尾;

原文地址：https://www.cnblogs.com/CrownYP/p/11341243.html