day03-python运算符的使用

常用运算符

算术运算符

运算符	说明	实例	结果
+	加	1+1	2
-	减	1-1	0
*	乘	1*3	3
/	除法（和数学中的规则一样，但是结果为浮点数）	4/2	2
//	整除（只保留商的整数部分）	7 // 2	3
%	取余，求模，即返回除法的余数	7 % 2	1
**	幂运算/次方运算，即返回 x 的 y 次方	2 ** 4	16，即 24

var1 = 7
var2 = 4

# +
res = var1 + var2
print(res)

# -
res = var1 -var2
print(res)

# *
res = var1 * var2
print(res)

# / (结果是一个小数)
res = var1 / var2
res = 8 / 8
print(res)

# // (取整数) 两个数在进行地板除的时候，有一个数是小数，就在最后的结果上加.0
res = var1 // var2
res = 8 // 8
res = 28.7 // 5
print(res)
res = 28 // 5.3
print(res)

# %
res = var1 % var2
res = 99 % 7
# -1 + 7 = 6 (余数)
res = -99 % 7 
# 1 + （-7） = -6 (余数)
res = 99 % -7
print(res)

# **   var1 * var1 * var1  7*7*7  **是所有运算符 优先级最高的一个
res = var1 ** 3
print(res)

课堂代码

# a = 4
# b = 7
#
# # 加法
# c = a+b
# print(c, type(c))
#
# # 乘法
# c = a * b
# print(c)
#
# # 除法
# # / 运算结果是浮点数
# c = b / a
# print(c) # 1.75
#
# c = 10 / 2
# print(c) # 5.0

# # 整除
# # c = 10 // 2
# # print(c, type(c))  # 5 
#
# b = 10 / 3
# print(b) # 3.3333333333333335
#
# c = 10 // 3
# print(c, type(c))  # 3 

"""在计算机中，因为有存储上限，所以所有的浮点数运算，都是一种近似值的运算，得到结果都是近似值"""
"""因为计算中CPU采用的是二进制，所以实际上数值在内部运算过程中，都会被转换成二进制，才进行运算"""
# ret = 7.1+0.8
# print(ret)  # 7.8999999999999995
#
# # 解决上面的隐患，所以一般要保留精度
# print("%.2f" % ret)  # 7.90


# 求余，所谓的余数就是整除运算过程中没有除开的剩余数值
# a = 10 % 3
# print(a)  # 1
#
# a = 10 % 5
# print(a)  # 0 余数为0，表示刚好整除

# a = -10 % 4
# print(a)  # 2
#
# a = -10 % -4
# print(a) # -2
#
# a = 10 % -4
# print(a) # -2


# ** 幂运算
# print(3**2) # 9
# print(3**3) # 27

# 水仙花数
print(1**1)
print(2**2)
print(3**3)
print(4**4)

赋值运算符

所谓赋值，就是代表的意思。让一个变量代表数据在后面代码中进行使用。

运算符	说 明	用法举例	等价形式
=	最基本的赋值运算	x = y	x = y
+=	加赋值	x += y	x = x + y
-=	减赋值	x -= y	x = x - y
*=	乘赋值	x *= y	x = x * y
/=	除赋值	x /= y	x = x / y
%=	取余数赋值	x %= y	x = x % y
**=	幂赋值	x **= y	x = x ** y
//=	取整数赋值	x //= y	x = x // y
&=	按位与赋值	x &= y	x = x & y
|=	按位或赋值	x |= y	x = x | y
^=	按位异或赋值	x ^= y	x = x ^ y
«=	左移赋值	x «= y	x = x « y，这里的 y 指的是左移的位数
»=	右移赋值	x »= y	x = x » y，这里的 y 指的是右移的位数

# = 所有运算符当中 等号的优先级最低
var1 = 9
var2 = 5
res = var1
# print(res)

# +=
# var1 += var2 
'''var1 = var1 + var2'''
# print(var1)

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

# *=
# var1 *= var2
'''var1 = var1 * var2'''
# print(var1)

# /=
# var1 /= var2
'''var1 = var1 / var2'''
# print(var1)

# //=
# var1 //= var2
'''var1 = var1 // var2'''
# print(var1)

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

# **=
var1 **= var2
'''var1 = var1 ** var2'''
print(var1)

比较运算符

比较两边的数值，结果是布尔值。

比较运算符	说明
>	大于，如果>前面的值大于后面的值，则返回 True，否则返回 False。
<	小于，如果<前面的值小于后面的值，则返回 True，否则返回 False。
==	等于，如果==两边的值相等，则返回 True，否则返回 False。
>=	大于等于（等价于数学中的 ≥），如果>=前面的值大于或者等于后面的值，则返回 True，否则返回 False。
<=	小于等于（等价于数学中的 ≤），如果<=前面的值小于或者等于后面的值，则返回 True，否则返回 False。
!=	不等于（等价于数学中的 ≠），如果!=两边的值不相等，则返回 True，否则返回 False。

# > 
var1 = 15
var2 = 18
res = var1 > var2
print(res)
# <
res = var1 < var2
print(res)
# >=  只要满足一个条件即为真
res = var1 >= 15
print(res)
# <=
res = var1 <= 15
print(res)
# ==
res = var1 == var2
print(res)

# !=
res = var1 != var2
print(res)

成员运算符

仅针对与容器类型，从这点上来说，str也可以算是一种容器类型。

成员运算符	说明
in	判断一个值是否作为指定容器的成员存在，如果是则返回 True，否则返回 False。
not in	判断一个值是否不在指定容器中作为成员，如果不在则返回 True，否则返回 False。

strvar = "无论是缓存机制还是小数据池的驻留机制, 都是为了节省内存空间, 提升代码效率"
res = "缓存机制" in strvar
res = "驻留机制" not in strvar
res = "节省内存" in strvar
print(res)


# list tuple set
listvar = ["xiaoming","xiaobai","xiaohei"]
res = "xiaobai" in listvar
print(res)

tuplevar = "xiaoA","xiaoW","xiaoK","xiaoF"
res = "xiaoA" not in tuplevar
print(res)

setvar = {'xiaohong','xiaohui'}
res =  "xiaohui" in  setvar
print(res)

# dict  注意 ： 判断的是键 不是值
dictvar = {"zxy":"张学友","cyx":"陈奕迅","ldh":"刘德华"}
res = "刘德华" in dictvar
res = "zxy" not in dictvar
print(res)

身份运算符

仅针对变量的内存地址。

成员运算符	说明
is	判断两个变量所引用的内存空间是否相同，如果相同则返回 True，否则返回 False。
is not	判断两个变量所引用的内存空间是否不相同，如果不相同则返回 True，否则返回 False。

var1 = 56
var2 = 56
res = var1 == var2  # (判断两个值是否相等)
res = var1 is var2  # (判断两个值得地址是否相等)
"""
# Number
# int -5 ~ 正无穷
var1 = 56
var2 = 56
res = var1 is var2
print(res)

# float 非负数
var1 = -99
var2 = -99
print(var1 is not var2)

# bool 
var1 = True
var2 = False
print(var1 is var2)

# 容器类型数据  () 相同的字符串 剩下所有的容器类型数据地址都不一样
var1 = ()
var2 = ()
print(var1 is  var2)
var1 = "机"
var2 = "机"
print(var1 is not var2)

逻辑运算符

逻辑运算符	含义	基本格式	说明
and	逻辑与运算	a and b	当 a 和 b 两个表达式都为真时，a and b 的结果才为真，否则为假。
or	逻辑或运算	a or b	当 a 和 b 两个表达式都为假时，a or b 的结果才是假，否则为真。
not	逻辑非运算	not a	如果 a 为真，那么 not a 的结果为假；如果 a 为假，那么 not a 为真。相当于对 a 取反。

# (1)and 逻辑与
'''全真则真,一假则假'''
res = True and True 
res = False and True
res = False and False
res = True 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
res = not False
print(res)

值得注意的是，与其他语言一样，python的逻辑运算符也会有短路现象的出现。

False and  print(123) #逻辑短路
True or print(456)  #逻辑短路
True and print(789)

print(2 and 1)
print(0 and 1)
print(0 or 1)
print(3 or 5)

位运算符

位（bit），就是位模式，实际就是计算机中的二进制运算。

位（bit）：计算机中，采用二进制来进行数据存储的，那么1个二进制数字就是1位（1bit），1byte = 8位

1个字节：0000 0000

2个字节：0000 0000 0000 0000

其中最左边的第一个位置就是当前二进制数值的正/负数符号

数字2的二进制表示：0000 0010

数字-1的二进制表示：1000 0001

数字1的二进制表示：0000 0001

因此，一个字节可以保存的有符号的数字：-127~127

原码

正负符号+二进制数值

2的原码：0000 0010[原]

-1的原码：1000 0001[原]

1的原码：0000 0001[原]

+0的源码：0000 0000[原]

-0的源码：1000 0000[原]

反码

反码是计算机中用于转换原码到补码的中间人（工具人），反码是经过原码进行取反的。

正数的反码和原码是一样。

负数的反码 = 原码取反，正负符号不变

2的反码：0000 0010[反]

1的反码：0000 0001[反]

-1的反码：1111 1110[反]

+0的反码：0000 0000[反]

-0的反码：1111 1111[反]

补码

我们平时看到的二进制基本都是原码，而计算机中真正存储的补码。

正数的补码：补码=反码=补码

负数的补码：反码+1

2的补码：0000 0010[补]

1的补码：0000 0001[补]

-1的补码：1111 1111[补]

0的补码：0000 0000[补]

位运算符	说明
&	按位与，参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0
|	按位或，只要对应的二个二进位有一个为1时，结果位就为1。
^	按位异或，当两对应的二进位相异时，结果为1
~	按位取反：对数据的补码每个二进制位取反,即把1变为0,把0变为1 。
<<	左移，运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0。
>>	右移，把">>"左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数

# 按位与 &
var1 = 19
var2 = 15
res = var1 & var2
print(res)
"""
    000000010011
    000000001111
    000000000011
"""
# 按位或 |
res = var1 | var2
print(res)
'''
    000000010011
    000000001111
    000000011111
'''

# 按位异或 ^ "如果两者不相同，返回真，两者相同返回假
res = var1 ^ var2
print(res)
'''
    000000010011
    000000001111  
    000000011100
'''

# <<  相当于 5 乘以 2的2次幂
res = 5 << 2
res = 4 << 3
print(res) # 20 
"""
    000000101
    000010100
"""

# >>  相当于 5 除以 2的1次幂
res = 5 >> 1
print(res)
"""
    0000101
    0000010
"""

# ~ 按位非 (针对于补码来进行操作 ，连符号位都要改变) 公式 -(n+1)
res = ~19
print(res)
"""
    000000000010011 (补码)
    111111111101100 (按位非)

    111111111101100  (给补码求原码)
    100000000010011  (反码)
    100000000010100  (原码)  => -20
"""

res = ~(-19)
print(res)
'''
    100000000010011  (原码)
    111111111101100  (反码)
    111111111101101  (补码)

按位非操作的是补码
    111111111101101  (补码)
    000000000010010  (按位非得值)

    000000000010010  (原码 == 反码 == 补码)
'''

运算符的优先级问题

从不来不会去背这个优先级的表格，而是在表达式里面，给优先想要运算的表达式加上小括号提升它的优先执行

总结

重点

1. 算术运算符
2. 浮点数运算过程中近似值的计算，是不精确的。也叫丢失精度。
3. 赋值运算符
   =
   +=
   -=
   *=
   /=
   //=
   %=
4. 比较运算符
5. == 与 is的区别
6. in 和 not in
7. is 和 not is
8. 逻辑运算符
   and
   or
   not
9. 使用小括号提升表达式的优先执行顺序
10. 先计算等号=右边的表达式，再赋值给左边变量

理解

1. 二级容器转换字典
2. 逻辑运算符的短路现象
3. 字符串之间的比较，是编码位置的比较
   ASCII码
   unicode万国编码
   utf8 与 utf8mb4
   gbk 国标码
   big5

了解

1. 位运算符
   6个运算符
   原码、反码、补码
2. 运算符的优先级