文章目录
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
- 1
Python 3.8（或更高）下：
出现报错
SyntaxWarning: "is" with a literal. Did you mean "=="?
1
解决方法：
将对应语句中is/is not用== 和 != 代替
- 1
- 2
- 3
- 4
原因：
从 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运行运行
扫一扫
419
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
