常用运算符
算术运算符
| 运算符 | 说明 | 实例 | 结果 |
|---|---|---|---|
| + | 加 | 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 <class 'int'>
#
# b = 10 / 3
# print(b) # 3.3333333333333335
#
# c = 10 // 3
# print(c, type(c)) # 3 <class 'int'>
"""在计算机中，因为有存储上限，所以所有的浮点数运算，都是一种近似值的运算，得到结果都是近似值"""
"""因为计算中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. 运算符的优先级
