运算

1.1Pytthon运算符
Python运算符包括:
1:算数运算符.( + 加法, - 减法, * 乘法, / 除法, // 地板除, % 取余, ** 幂)
2:比较运算符.( > 大于, < 小于, >= 大于等于, <= 小于等于, == 等于, !=不等于)
3:赋值运算符.( = , += , -= , *= , /= , //= ,%= **= )
4:成员运算符.( in 在什么里面, not in 不在什么里面)
5:身份运算符.( is 是同一个地址 , is not 不是同一个地址 )
6:逻辑运算符.( and 逻辑与, or 逻辑或 , not 逻辑非 )
7:位运算符.( & 按位与 , | 按位或 , ~ 按位非 , ^ 按位异或 , << 左移 , >> 右移)

1:算数运算符.( + 加法, - 减法, * 乘法, / 除法, // 地板除, % 取余, ** 幂)
(1) 加法 +
var1=6
var2=4
res=var1+var2
print(res)
结果是10

(2) 减法 -
var1=6
var2=4
res=var1-var2
print(res)
结果是2

(3) 乘法 *
var1=6
var2=4
res=var1*var2
print(res)
结果是24

(4) 除法 /
#结果永远是小数,如果除整,在后面加上点零( .0 ).
var1=6
var2=4
res=var1/var2
print(res)
结果是1.5

var1=6
var2=2
res=var1/var2
print(res)
结果是3.0

(5) 地板除 //
#如果除数或者被除数都是整数,结果只保留整数部分,不可以四舍五入.
#如果除数或者被除数存在小数,那么结果在只保留整数部分的情况下,在加上点零( .0 ),表达一个浮点型.
var1=6
var2=4
res=var1//var2
print(res)
结果是1

var1=7
var2=3.0
res=var1//var2
print(res)
结果是2.0

(6) 取余 %
#如果被除数和除数都是正数,直接取余就可以了.
#如果被除数是一个负数,除数是一个正数,那么相当于在正常情况下(被除数和除数都是正数)的余数前面套上一个负号,与后面的除数相加的和是最后的余数.
#如果被除数是一个正数,除数是一个负数,那么相当于在正常情况下(被除数和除数都是正数)的余数与后面的除数相加的和是最后的余数.
#如果被除数和除数都是负数,那么相当于在正常情况下(被除数和除数都是正数)的余数前面套上一个负号是最后的余数.
res= 81 % 11
结果是 4
res= -81 % 11
结果是 -4 + 11 =7
res= 81 % -11
结果是 4 + ( -11 ) = -7
res= -81 % -11
结果是 -4

(7) 幂 **
res=3**2
结果是9

2:比较运算符.( > 大于, < 小于, >= 大于等于, <= 小于等于, == 等于, !=不等于)
#只会产生两种结果,要么True,要么False.
(1) 大于 >
res= 100 > 90
结果是True

(2) 小于 <
res= 100 < 190
结果是True

(3) 大于等于 >=
res= 100 > 100
结果是True

(4) 小于等于 <=
res= 100 < 100
结果是True

(5) 等于 ==
#一个=是赋值,将右侧的值赋值给左侧.
#两个==是比较,比较等号两边的值是不是相等,相等返回True.
res= 100 == 100
结果是True

(6) 不等于 !=
res= 100 != 99
结果是True

3:赋值运算符.( = , += , -= , *= , /= , //= ,%= **= )
(1) =
#从右向左看,将右侧的值赋值给左侧变量.
var=5 将5赋值给var

(2) +=
var1 += var2
相当于 :
var1 = var1 + var2

(3) -=
var1 -= var2
相当于 :
var1 = var1 - var2

(4) *=
var1 *= var2
相当于 :
var1 = var1 * var2

(5) /=
var1 /= var2
相当于 :
var1 = var1 / var2

(6) //=
var1 //= var2
相当于 :
var1 = var1 // var2

(7) %=
var1 %= var2
相当于 :
var1 = var1 % var2

(8) **=
var1 **= var2
相当于 :
var1 = var1 ** var2

4:成员运算符.( in 在什么里面, not in 不在什么里面)
#针对于容器类型数据.(str,list,tuple,set,dict).

在字符串(str)中的 in 和 not in使用情况:
#字符串必须是一个连续的片段,不能隔着取.
例如:
strvar=“今天阳光明媚”
res1= “今” in strvar
res2= “二” not in strvar
res3= “今媚” in strvar
print(res1,res2)
结果都True
print(3)
结果是Fales

在列表(list)中的 in 和 not in使用情况:
lst=[“小米”,‘小刘’,“校长”]
res =“小米” in lst
结果是True

在元组(tuple)中的 in 和 not in使用情况:
tup=(“小米”,‘小刘’,“校长”)
res =“小米” in tup
结果是True

在集合(set)中的 in 和 not in使用情况:
#集合无序且自动去重.
setvar={“小米”,‘小刘’,“校长”}
res =“小米” in setvar
结果是True

在字典(dict)中的 in 和 not in使用情况:
#字典的键一般推荐用变量的字符串.
#在字典中, in 和 not in 只判断键, 不判段值.
dic={ “ww”:“小米” , “ll”:‘小刘’, “kk”:“校长”}
res1=“小米” in dic
res2=“ww” in dic
print(res1)
结果是False
print(res2)
结果是True

5:身份运算符.( is 是同一个地址 , is not 不是同一个地址 )
#检测两个数据在内存中是不是同一个值,同一个地址.
#检测是不是同一个地址.

python3.6版本中:
(1)相同的值,整型在 -5 到 正无穷区间内地址一致.
(2)相同的值,浮点型在非负数范围内地址一致.
(3)相同的值,布尔型地址一致.
(4)相同的值,复数型在 实数+虚数情况下,地址永远不一致.(只有虚数没有实数的相同值地址一致)
(5)相同的值,在字符串中地址一致.
(6)空元组地址一致.
(7)列表,集合,字典,元组任何情况下都不一样.(除空元组)

例如:
var1=6
var2=6
res=var1 is var2
print(res)
结果是True

6:逻辑运算符.( and 逻辑与, or 逻辑或 , not 逻辑非 )
(1) 逻辑与 and
#全真则真,一假则假.
res=True and True
结果是True
res=True and False
结果是False
res=False and True
结果是False
res=False and False
结果是False

(2) 逻辑或 or
#全假则假,一真则真.
res=True or True
结果是True
res=True or False
结果是True
res=False or True
结果是True
res=False or False
结果是False

(3) 逻辑非 not
#真变假,假变真.(优点类似于原码补码取反)
res= not True
结果是 False

逻辑短路
#如果出现短路效果,后面的代码就不执行了.

逻辑短路的两种表达方式:
第一种:True or 表达式
第二种:False and 表达式

第一种:True or 表达式 :
res= True or print(111)
结果是True
原因是:逻辑或是一真则真,前面是真的,后面没必要运行,直接短路,print(111)不会执行,111不会被打印.

res= True and print(111)
结果是111

第二种:False and 表达式 :
res=False and print(111)
结果是False
原因是:逻辑与是一假则假,前面是假的,后面没必要运行,直接短路,print(111)不会执行,111不会被打印.

举例:
res= 5 or 6
prinr(res)
结果是5
解释:首先判断5是不是真的,5转换成布尔型是真的,一真则真,则直接被短路不执行.

res= 0 or 6
prinr(res)
结果是6
解释:首先判断0是不是真的,0转换成布尔型是假的,没有形成一真则真,后面就要运行,6会被打印.

res= 5 and 6
prinr(res)
结果是6
解释:首先判断5是不是真的,5转换成布尔型是真的,没有形成一假则假,后面就要运行,6会被打印.

res= 0 and 6
prinr(res)
结果是0
解释:首先判断0是不是真的,0转换成布尔型是假的,一假则假,则直接被短路不执行.

所以:
res=True1 and True2
结果是True 2
res=True1 and False2
结果是 False2

res=False1 or True 2
结果是True2
res=False1 or False2
结果是False2

print(111) or True
#print是内置函数,函数内部返回的是None,功能是打印.
首先确定 print(111)是不是真的,print(111)在转换成布尔型时,结果为None,None or True 没有形成一假则假,后面就要运行,结果为True.
print(111)转换成布尔型:
res=bool(print(111))
print(res)
结果是None

#自动转换的优先级:bool < int < float < complex (从低精度向高精度转换)

逻辑运算的优先级:
() > not > and > or

例如:
res= 1 > 2 or 3 < 4 and 5 > 10 or 11 < 12 and 13 > 16
==> False or True and False or True and False
==>False or False or False
==>False or False
==>False
print(res) 结果是False

7:位运算符.( & 按位与 , | 按位或 , ~ 按位非 , ^ 按位异或 , << 左移 , >> 右移)
#位运算符针对的方向是做二进制.
#1代表True,0代表Flase.
#位运算时,里面的二进制符号位也要跟着变.

(1) 按位与 &
#遵循逻辑与的规律.全真则真,一假则假.
例如:
var1=19
var2=15
print( var1 & var2 )
结果是3

过程:
首先转换成二进制:
19的二进制:
000…10011
15的二进制:
000…01111

000…10011
000…01111
000…00011 ==>3

(2) 按位或 |
#遵循逻辑或的规律.全假则假,一真则真.
例如:
var1=19
var2=15
print( var1 | var2 )
结果是31

过程:
首先转换成二进制:
19的二进制:
000…10011
15的二进制:
000…01111

000…10011
000…01111
000…11111 ==>31

(3) 按位异或 ^
#两者之间不一样的返回真,一样返回假.
例如:
var1=19
var2=15
print( var1 ^ var2 )
结果是28

过程:
首先转换成二进制:
19的二进制:
000…10011
15的二进制:
000…01111

000…10011
000…01111
000…11100 ==>28

(4) 左移 <<
#左移相当于做乘法: 5<<2相当于5 * 2的 2次幂.
#5<<3 相当于5 *2的3次幂
例如:
res= 5 << 2
print( res )
结果是20

过程:
首先转换成二进制:
5的二进制:
000…101
向左移两位:(低位用零补齐)
000…10100 ==>20

(5) 右移 >>
#右移相当于做除法:5 // 2的 n 次幂. (5是可变的,2是固定不变的,符号用地板除)
例如:
res= 5 >> 1
print( res )
结果是2

过程:
首先转换成二进制:
5的二进制:
000…101
向又移一位位:(高位用零补齐)
000…010 ==>2

(6) 按位非 ~
#针对于补码进行操作.按位取反,包括符号位.
#公式为: - ( n + 1 )
#遵循逻辑非的规律.真变假,假变真.
例如:
var= ~19
print(var)
结果是 -20

过程:
首先转换成二进制:
19的二进制:
原码:000…10011
反码::000…10011
补码::000…10011

#按位非针对于补码进行操作.按位取反,包括符号位.
补码: 000…10011
按位非: 111…01100 ==>补码为负数,不等于原码,要转成原码.

给补码求原码:
按位非补码: 111…01100
按位非反码: 100…10011
按位非原码: 100…10100 ==> - 20

var= ~ ( - 19 )
print(var)
结果是 18

过程:
首先转换成二进制:
-19的二进制:
原码:100…10011
反码:111…01100
补码::111…01101

#按位非针对于补码进行操作.按位取反,包括符号位.
补码: 111…01101
按位非: 000…10010 ==> 18 补码为正数,等于原码,不用再转.

总结:
(1) 个别运算符
优先级最高的是 ** 幂运算
优先级最低的是 = 赋值运算
括号()可以提升运算的优先级

(2) 整体来讲
一元运算符 > 二元运算符
一元运算符:同一时间,只操作一个值. 有负号 ( - ) , 按位非 ( ~ )
二元运算符:同一时间,操作两个值. 例如: 加( + ) , 减 ( - ) , 乘 ( * ) , 除 ( / ) 等 .

(3) 同一层级
逻辑运算中 : 括号 () > 逻辑非 not > 逻辑与 and > 逻辑 or
算数运算中: 乘除 > 加减
位运算中: ( 左移 << , 右移 >>) > 按位与 & > 按位异或 ^ > 按位或 |

(4) 其他情况
算数运算符 > 位运算符 > 比较运算符 > 身份运算符 > 成员运算符 > 逻辑运算符

(5) 逻辑非 not 不是一元运算符.

(6) 赋值运算符用来将算好的值赋值给等号左侧变量,做收尾工作.