python运算符详解

Python运算符

Hello,大家好，我是你们的老朋友景天，今天我们来一起聊聊python中的运算符。
Python中提供了各种各样的运算符帮助我们解决各种实际问题。Python中的运算符主要包括算术运算符、比较运算符、位运算符、逻辑运算符和赋值运算符。下面将一一介绍这些运算符的具体种类和使用方法。

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

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

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

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

#*
var1 = 7
var2 = 10
res = var1 * var2
print(res)

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

#// 地板除
//整除 9//4 结果为2 去除小数部分 返回不大于结果的一个最大的整数，意思就是除法结果向下取整

"""被除数 ? 除数 = 商"""
"""注意点:如果被除数或者除数是小数,那么得到正常结果之后,数值后面带上.0变成小数"""
var1 = 10.0
var2 = 3.0
#var2 = 3.0
res = var1 // var2
print(res)

相除后，取不大于结果的最大整数，负数的话要注意

#% 取余
var1 = 7
var2 = 4
res = var1 % var2
res = -7 % 4 # -3 + 4 = 1
res = 7 % -4 # 3 + (-4) = -1
res = -7 % -4 # -3 (被除数和除数都是负的,正常结果加负号)
两个负数相除，余数仍为负数

取余 -10 /3 按正数来算余1 由于是负数，被除数有负号，就在余数上加负号，-1 然后再加上除数 -1 +3 = 2 所以取余是2

除数有负号， 余数加上除数 1 + -3 = -2 所以取余是-2

res = 81 % 7 # 4
res = 81 % -7 # -3
res = -81 % 7 # 3
res = -81 % -7 # -4
print(res)

#幂运算  a **b  = a的b次方
res = 2 ** 3
print(res)

(2)比较运算符: > < >= <= == !=

"""比较运算符的结果要么是True , 要么是False 只有两个值"""
res = 10 > 5
res = 10 >= 10
# ==这个符号是在做比较,比较==两边的数值是否一样  相等返回True ,不相等返回False
res = 5 == 9
res = 5 != 9 
print(res)

纯英文字母字符串，可以比较大小，以ascii码大小作比较
#单个字母就直接比较，多个字母就从第一个开始比较，前面相同就向后比较

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

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

var1 = 10
var2 = 5
# += 
"""var1 = var1 + var2"""
# var1 += var2
# print(var1)

# -=
"""var1 = var1 - var2"""
# var1 -= var2
# print(var1)

# %=
"""var1 = var1 % var2"""
var1 %= var2
print(var1)

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

“”“字符串判断时,必须是连续的片段”“”
strvar = “今天天气要下雨,赶紧回家收衣服”

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

#针对于列表,元组,集合
container = ["赵沈阳","赵万里","赵世超"]
container = ("赵沈阳","赵万里","赵世超")
container = {"赵沈阳","赵万里","赵世超"}
# res = "赵沈阳" in container
# res = "赵万里" not in container
res = "赵世超1223232" not in container
print(res)
 
# 针对于字典 (判断的是字典的键,不是值)
container = {"zsy":"赵沈阳","zwl":"赵万里","zsc":"赵世超"}
res = "赵沈阳" in container # False
res = "zsy" in container
print(res)

字典的值不能用成员运算符判断，只能用键来判断，针对多层容器中的字典，键也不能用来判断

单层容器用键可以

用值也是不可以

字典要想判断值，需要用到字典的values方法

(5)身份运算符 is 和 is not

(检测两个数据在内存当中是否是同一个值)

# 整型   所有整形，浮点型，bool,complex str tuple 只要数值一样，内存地址都相同
var1 = 100
var2 = 100
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)

#容器: 相同字符串 , 元组相同即可 剩下的所有容器（列表，集合，字典）即便数值相同，内存地址也不相同
元祖相同

字符串相同
集合不同

列表不同

字典不同

container1 = "你"
container2 = "你"
print(container1 is not container2)

container1 = [1,23,3]
container2 = [1,23,3]
print(container1 is not container2)

(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 = False or True   # True
res = True or False   # True 
res = False or False  # False
print(res)

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

#逻辑短路
“”"
无论后面的表达式是True 还是False 都已经无法改变最后的结果,那么直接短路,后面的代码不执行;
(1) True or print(“程序执行了 ~ 1111”) 遇到True就不再执行后面的代码

这种就不短路

(2) False and print(“程序执行了 ~ 2222”)

True or print("程序执行了 ~ 1111")
True or True => True
True or False => True
直接返回前者，后者就不再执行了

False and print("程序执行了 ~ 2222")
False and True  => False
False and False => False
不管后面是什么，都返回False，后面的不再执行

"""

"""
计算规律:
    先脑补计算当前表达式的布尔值是True还是False
    如果出现了 True or 表达式  或者 False and 表达式的情况,直接返回前者,后面代码不执行
    如果没有出现短路效果,直接返回后者
"""
逻辑为假的十种情况，其他情况都为真
 0 , 0.0 , False , 0j  '' []  ()  set()  {}  None


res = 5 and 6 # 6      真 and 一个值还要继续往后执行，不能短路。所以执行结果是6
"""
True and True =>True
True and False => False
"""
res = 5 or 6  # 5    真 or  一个值，不管后面是真是假，结果都为真，出现短路，所以结果为5
res = 0 and 999    假 and 一个值， 不管后面是真是假，结果都为假，出现短路 结果为0
res = 0 or "abc"
print(res)

#逻辑运算符的优先级
优先级从高到低: () > 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 # not 5 and 7 => False and 7 => False
res = 1<2 or 3>4 and 5<100 or 100<200 and not (700>800 or 1<-1) =>True

not (False or False) => True
res = 1<2 or 3>4 and 5<100 or 100<200 and not (700>800 or 1<-1)
res = True or False and True or True and True =>True
res = True or False or True =>True
res = True or True => True

print(res)

(7)位运算符: & | ^ << >> ~

Python 位运算按照数据在内存中的二进制位（Bit）进行操作，它一般用于底层开发（算法设计、驱动、图像处理、单片机等），在应用层开发（Web 开发、Linux 运维等）中并不常见
存储和计算时，都用补码进行操作

var1 = 19
var2 = 15

# & 按位与
& 按位与运算符
按位与运算符&的运算规则是：只有参与&运算的两个位都为 1 时，结果才为 1，否则为 0。例如1&1为 1，0&0为 0，1&0也为 0，这和逻辑运算符&&非常类似。
计算方法，先将数字转换成二进制的补码，用补码进行按位与运算，符号位参与运算，之后将补码转换成原码显示

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

# | 按位或
| 按位或运算符
按位或运算符|的运算规则是：两个二进制位有一个为 1 时，结果就为 1，两个都为 0 时结果才为 0。例如1|1为 1，0|0为0，1|0 为1，这和逻辑运算中的||非常类似。

res = var1 | var2
"""
000 ... 10011
000 ... 01111
000 ... 11111
"""
print(res)

# ^ 按位异或
"""两个值不相同=>True 反之返回False"""
^按位异或运算符
按位异或运算^的运算规则是：参与运算的两个二进制位不同时，结果为 1，相同时结果为 0。例如0^1为 1，0^0为 0，1^1为 0。

res = var1 ^ var2
"""
000 ... 10011
000 ... 01111
000 ... 11100
"""
print(res)

#<< 左移 (相当于乘法)

<<左移运算符
Python 左移运算符<<用来把操作数的各个二进制位全部左移若干位，高位丢弃，低位补 0。
例如，9<<3可以转换为如下的运算：
<< 0000 0000 – 0000 0000 – 0000 0000 – 0000 1001 （9 在内存中的存储）
0000 0000 – 0000 0000 – 0000 0000 – 0100 1000 （72 在内存中的存储）
所以9<<3的结果为 72。

又如，(-9)<<3可以转换为如下的运算：
<< 1111 1111 – 1111 1111 – 1111 1111 – 1111 0111 （-9 在内存中的存储）
1111 1111 – 1111 1111 – 1111 1111 – 1011 1000 （-72 在内存中的存储）
所以(-9)<<3的结果为 -72



如果数据较小，被丢弃的高位不包含 1，那么左移 n 位相当于乘以 2 的 n 次方。 -9 * 2**3 = -72



"""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
“”"

#>> 右移 (相当于除法)
右移运算符
Python 右移运算符>>用来把操作数的各个二进制位全部右移若干位，低位丢弃，高位补 0 或 1。如果数据的最高位是 0，那么就补 0；如果最高位是 1，那么就补 1。
例如，9>>3可以转换为如下的运算：

0000 0000 – 0000 0000 – 0000 0000 – 0000 1001 （9 在内存中的存储）
0000 0000 – 0000 0000 – 0000 0000 – 0000 0001 （1 在内存中的存储）
所以9>>3的结果为 1。

又如，(-9)>>3可以转换为如下的运算：

1111 1111 – 1111 1111 – 1111 1111 – 1111 0111 （-9 在内存中的存储）

1111 1111 – 1111 1111 – 1111 1111 – 1111 1110 （-2 在内存中的存储）
所以(-9)>>3的结果为 -2

如果被丢弃的低位不包含 1，那么右移 n 位相当于除以 2 的 n 次方（但被移除的位中经常会包含 1）。

“”“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
“”"
print(res)

#~ 按位非 (针对于补码进行操作,按位取反,包含每一位)
~按位取反运算符
按位取反运算符为单目运算符（只有一个操作数），右结合性，作用是对参与运算的二进制位取反。例如1为0，~0为1，这和逻辑运算中的!非常类似。

""" -(n+1) """
# res = ~22
res = ~19
print(res)
"""
原码:000 ... 10011
反码:000 ... 10011
补码:000 ... 10011

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

给你补码->原码
补码:111 ... 01100
反码:100 ... 10011
原码:100 ... 10100 => -20
"""

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

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

给你补码->原码 (因为是正数 ,原反补相同)
000 ... 10010 => 18
"""

总结:
个别运算符:
运算符优先级最高的: **
运算符优先级最低的: =
()可以提升优先级

一元运算符 > 二元运算符 (优先级)
一元运算符 : 同一时间,操作一个值 ~ -
二元运算符 : 同一时间,操作两个值 + - * / …

同一种类运算符:
算数运算符 : 乘除 > 加减
逻辑运算符 : () > not > and > or
位运算符 : ( << >> ) > & > ^ > |

整体排序:
算数运算符 > 位运算符 > 比较运算符 > 身份运算符 > 成员运算符 > 逻辑运算符 >赋值
赋值运算符用来做收尾
算位比身成逻

res = 5+5 << 6 // 3 is 40 and False

Python 3.8（或更高）下：
出现报错

SyntaxWarning: "is" with a literal. Did you mean "=="?
1
解决方法：
将对应语句中is/is not用== 和 != 代替

原因：
从 python 3.8 开始，使用 is 和 is not 运算符时，会抛出 SyntaxWarning 语句警告信息

“”"
res = 10 << 2 is 40 and False
res = 40 is 40 and False
res = True and False
res = False
“”"
print(res)

优先级不是每个人都要熟记于心，为了便于新人理解，可用括号提升下优先级，这样就看起来比较直白
res = (5+5) << (6//3) is 40 and False