Python运算符

 python运算符

| 注意点 |执行顺序：幂>算>位>比>身>成>逻>赋值
| ------------ | ------------------------------------------------------------ |
| 算数运算符 | +加，-减， *乘， /除（得小数）， % 取余 ， //地板除（得整数） ， ** 幂运算 |
| 比较运算符 | == 比较两个值是否相等 != 比较两个值是否不同 |
| 赋值运算符 | =变量赋值， +=增量赋值，链式赋值，交叉赋值，解压赋值|
| 成员运算符 | in 或 not in 判断某个值是否包含在(或不在)一个容器类型数据当中 |
| 身份运算符 | is 和 is not 用来判断内存地址是否相同 |
| 逻辑运算符 | 优先级 () > not > and > or |
| 位运算符 | 优先级 (<<或 >> ) > & > ^ > | 5 << 1 结果：10 , 5 >> 1 结果：2 |

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

# 算数运算符:  + - * / // % **
var1 = 10
var2 = 5

# +
res = var1 + var2
print(res)

# -
res = var1 - var2
print(res)

# *
res = var1 * var2
print(res)

# / (结果永远是小数)
res = var1 / var2 
print(res)

# // 地板除 10 除以 5 10被除数,5是除数,得到值是商 (默认得到的是整数)
res = var1 // var2
print(res)

# 被除数或除数是一个小数,结果就是小数
res = 10 // 5.0
res = 14 // 8
print(res)

# % 取余
res = 17 % 3  # 2
res = 11 % 7  # 4
res = -11 % 7 # 3  =>   -4 + 7 = 3 
res = 11 % -7 # -3 =>    4 + (-7) = -3
res = -11 % -7# -4 =>   -4

# res = 81 % 5  # 1
res = -81 % 5   # 4
res = 81 % -5   # -4
res = -81 % -5  # -1
print(res)

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

注意：“+”有个字符串拼接的功能（但是执行效率低，不推荐使用）

 

# 字符串拼接
a = "my name "
b = "is lsj"
c = a + b
print(c)
# my name is lsj

# +号左右都是str类型，否则报错
d = 18
e = c + d
print(e)
#     e = c + d
# TypeError: can only concatenate str (not "int") to str

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

# 比较运算符:  > < >= <= == !=   结果只有两种 (True 真的 False 假的) 
res = 5 > 6
res = 6 < 1000
res = 90 <= 90
print(res)

# ==  等于
"""一个等号是赋值操作,两个等号在做比较操作"""
res = 100 == 100
print(res)

# !=  不等于
res = 100 != 100
print(res)

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

# 赋值运算符   = += -= *= /= //= %= **=

# = 变量赋值
var1 = 10
var2 = 20
var1 = var2
print(var1,var2)

# += 增量赋值
var1 = 10
var2 = 20
# var1 = var1 + var2
var1 += var2
# var1 = var1 + 1  
var1 += 1
print(var1)

# -= 减量赋值
var1 = 5
var2 = 10
# var1 = var1 - var2
var1 -= var2
print(var1)

# %=
var1 = 7
var2 = 4
# var1 = var1 % var2
var1 %= var2
print(var1)

# 链式赋值
# x = 10
# y = x
# z = y
# print(x,y,z)   # 10 10 10
# print(id(x),id(y),id(z))  # 8791232534464 8791232534464 8791232534464
# 使用链式赋值优化
x = y = z = 10
print(x,y,z)   # 10 10 10
print(id(x),id(y),id(z))  # 8791232534464 8791232534464 8791232534464

 

# 交叉赋值
x = 10
y = 20
print("交换前x=",x,",y=",y)
# 如何将x,y值进行交换
# 方案一：使用第三方变量
# z = x
# x = y
# y = z
# print("交换后x=",x,",y=",y)
# 方案二：
x,y = y,x
print("交换后x=",x,",y=",y)

 解压赋值：把列表中的多个值取出来依次赋值给多个变量名

# 解压赋值：针对列表，字典
# list = [1,"lsj",18,"男"]
# 取出元素分别赋值给不同的变量名。
# 方案一：
# a = list[0]
# b = list[1]
# c = list[2]
# d = list[3]
# print("变量名a =",a," 变量名b =",b," 变量名c =",c," 变量名d =",d)

# 方案二：
# a,b,c,d = list
# print("变量名a =",a," 变量名b =",b," 变量名c =",c," 变量名d =",d)

# *的作用是将没有对应关系的值存入列表并赋值给*号后面的符号,*号后面的符号为任意字母.
# 假如我想取出前三个值
# a,b,c,*a = list
# print("变量名a =",a," 变量名b =",b," 变量名c =",c)
# # 输出：变量名a = 1  变量名b = lsj  变量名c = 18
# print(a)
# 输出：['男']
# 假如我想取出后三个值
# *_,a,b,c = list
# print("变量名a =",a," 变量名b =",b," 变量名c =",c)
# # 输出：变量名a = lsj  变量名b = 18  变量名c = 男
# print(_)
# 输出：[1]

# *主要是取得列表两头的数据，也可以取出中间部分的数据但是不推荐
# 取出首尾两头数据，中间数据以列表形式赋值给名为"_"的变量中
# a,*_,b = list
# print("变量名a =",a," 变量名b =",b)
# # 输出：变量名a = 1  变量名b = 男
# print(_)
# # 输出：['lsj', 18]

# 解压赋值：字典:默认解压出来的是字典中的键key
dict_info = {
    "name":"lsj",
    "age": 18,
    "sex": "男",
    "hobby": "美女"
}
# a,b,c,d = dict_info
# print("变量名a =",a," 变量名b =",b," 变量名c =",c," 变量名d =",d)
# 输出：变量名a = name  变量名b = age  变量名c = sex  变量名d = hobby
a,b,c,*_ = dict_info
print("变量名a =",a," 变量名b =",b," 变量名c =",c)
# 输出：变量名a = name  变量名b = age  变量名c = sex
print(_)
# 输出：['hobby']
print(dict_info[a])
# 输出：lsj

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

# 成员运算符:  in 和 not in (针对于容器型数据)
# 针对于字符串
"""要求字符串是一个连续的片段"""
strvar = "好看的皮囊千篇一律,有趣的灵魂200多斤"
res = "皮" in strvar
res = "千篇一律" in strvar
res = "灵多" in strvar
print(res)

# 针对于 list tuple set
listvar = ["john","大江东去","繁星","dosir"]
res = "大江东去" in listvar

tuplevar = ("john","大江东去","繁星","dosir")
res = "dosir" not in tuplevar

setvar = {"john","大江东去","繁星","dosir"}
res = "john1234" not in setvar
print(res)

# 针对于字典 dict
"""针对于字典中的键来进行判定"""
dictvar = {"fx":"聪明","xx":"美丽","stone":"风流倜傥","fei":"睿智"}
res = "美丽" in dictvar
res = "xx" in dictvar
res = "abc" not in dictvar
print(res)

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

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

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

# 浮点型 非负数范围内
var1 = -9.13
var2 = -9.13
res = var1 is var2
print(res)

# 容器类型数据,除了空元组和相同的字符串,剩下所有的容器类型数据id地址都不相同
var1 = ()
var2 = ()
var1 = [1,2]
var2 = [1,2]
res = var1 is not var2
print(res)

(6)逻辑运算符

　　连接多个条件，进行关联判断，会返回布尔值True或False，

　　一种是显式的布尔值

# 显式的布尔值
is_beautiful = True
print(is_beautiful)

 　　一种是隐式的布尔值，所有的值都可以当做条件去用。

# 隐式的布尔值
a = 5 < 6
print(a)

# and 逻辑与 用来判断and左右两边条件。
"""全真则真,一假则假"""
res = True and True   # True
res = True and False  # False
res = False and True  # False
res = False and False # False
print(res)

# or  逻辑或 用来判断0r左右两边的条件
"""全假则假,一真则真"""
res = True or True  # True
res = True or False # True
res = False or True # True
res = False or False# False
print(res)

# not 逻辑非 ，把not紧跟后面的那个条件结果取反。紧跟后面的那个条件是一个不可分割的整体。
"""真变假,假变真"""
res = not True
res = not False
print(res)

# 逻辑短路
print("<=============>")
"""
短路: 后面代码不执行
(1)True or print("我就是我,不一样的烟火") [在单个表达式或者多个表达式中,可以直接判断短路]
(2)False and print("烟花一样的灿烂,是我逝去的青春") [只能在单个表达式当中判断是否短路]

# 不发生短路
True and print("仙女一样的姑娘，是我渴望已久的愿望")
"""

res = 5 or 6
res = 5 and 6
res = not 5

# 逻辑优先级
"""从高到低排列: () > not > and > or"""
# 如果单独只有一串and连接，或者or连接，按照从左到右的顺序依次运算（偷懒原则）
# 如果是混用则要考虑优先级
res = 5 or 6 and 7 # 5 or 7 => 5
res = 0 and 6 or 7 # 0 or 7 => 7
res = not 5 or 6 and 7 # False or 6 and 7  => False or 7 => 7
res = not (5 or 6) and 7 # not 5 and 7 => False and 7 => False
res = 1>2 and 3<4 or 5>6 and 7<8 and 100>99
"""
False and True or False and True and True
False or False and True
False or False
False
"""
print(res,"<===标注===>")

res = False and False # 返回的是第一个False
res = False or False  # 返回的是第二个False
res = False and "爱上了你"
res = False or "爱上了你"
res = "我爱你" or True
res = "我爱你" and True
print(res)

"""
额外解答:
    res = 100 or 200
    res = 0 or 200
    res = '' or 200
    print(res)

    例子:False or ? = 多少呢?
    False or True => True
    False or False => False
    False or 200 => 200
"""
# 针对复杂的逻辑先找出and的两边条件只剩下and或者or

# res=3>4 and not 4>3 or 1==3 and 'x' == 'x' or 3 >3
# print(res)

# #       False                 False              False
# res=(3>4 and (not 4>3)) or (1==3 and 'x' == 'x') or (3 >3)
# print(res)

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

# 位运算符  & |  ^ << >> ~

# 按位与 &
var1 = 19
var2 = 15
res = var1 & var2
print(res)
"""
先把19转换成二进制
10011
在把15转换成二进制
01111
结果
00011
把结果在转换成十进制 => 3
"""

# 按位或 |
var1 = 19
var2 = 15
res = var1 | var2
print(res)
"""
10011
01111
11111
11111 => 十进制31
"""

# 按位异或 ^ (两个值不一样,返回真1,两个值一样,返回假0)
var1 = 19
var2 = 15
res = var1 ^ var2
print(res)
"""
10011
01111
11100
"""


# << 左移 (做乘法 乘以2的n次幂)
res = 5 << 1
print(res)
"""
000101
向左边移动一位
001010
向左边移动二位
010100  => 20

000 0
001 1
010 2
011 3
100 4
101 5
110 6
111 => 7
"""

# >> 右移 (做除法 除以2的n次幂)
res = 20 >> 2
print(res)
"""
10100
向右边移动一位
01010  => 10
向右边移动二位
00101  => 5
"""


# ~ 按位非  -(n+1)
res = ~3
res = ~(-17)
res = ~0
print(res) 
# ~19 => -20
# ~18 => -19
# ~17 => -18

# ~(-19) => 18
# ~(-18) => 17
# ~(-17) => 16


# ### 运算符总结:
"""
优先级最高的符号是 ** 幂运算
优先级最低的符号是 = 赋值运算符

整体来说: 一元运算符 > 二元运算符 优先级
一元运算符 : 同一时间,只操作一个数字的就是一元 ( ~ , - )
二元运算符 : 同一时间,只操作两个数字的就是二元 ( + - * / ..)

逻辑运算符: () > not > and > or
位运算符  : (<< >>) > & > ^ > |
算数运算符: 先算乘除,再算加减

算数运算符 > 位运算符 > 比较运算符 > 身份运算符 > 成员运算符 > 逻辑运算符
赋值运算符做收尾,等所有运算结束之后,赋值给等号左侧;

算位比身成逻
赋值运算做收尾
"""

res = 5+5 << 6 // 3 is 40 and False
"""
10 << 2 is 40 and False
40 is 40 and False
True and False
False
"""
print(res) # False

# 通过() 提升运算的优先级
res = (5 + 5) << (6 // 3) is 40 and False