算数运算符
算数运算符主要用作于计算机的算数运算
种类 符号 作用 + 加法、字符串的拼接 - 减法 * 乘法、字符串的重复 / 除法 // 地板除（除法） % 取余（除法） ** 幂运算 +# 数字类型的加法运算 print(1 + 1) # 2 print(False + 1) # 1 print(0j + 1) # (1+0j) # 字符串的拼接 var1 = 'hello' var2 = 'motherland' print(var1 + ' ' + var2) # hello motherland*
# 数字类型的乘法运算 print(1 * 1) # 1 print(False * 1) # 0 print(0j * 1) # 0j # 字符串的重复 var1 = 'hello' print(var1) # hello print(var1 * 2) # hellohello print(var1 * 3) # hellohellohello/
# 数字类型的除法运算，结果总是小数，至少返回一位小数 print(1 / 1) # 1.0 print(False / 1) # 0.0 # print(False / False) # 除数不能为0 print(10 / 5) # 2.0 print(10 / 3) # 3.3333333333333335 print(10 / 2.25) # 4.444444444444445//
# 数字类型的除法运算 # // 的运算结果只有在除数或者是被除数为小数的时候才是小数，并且永远是一位小数，小数位为0 print(1 // 1) # 1 print(100 // 5) # 20 print(10.9 // 1) # 10.0 print(10 // 1.5) # 6.0 print(10.5 // 1.1) # 9.0 print(10.0 // 3) # 3.0%
# 不会将数除尽，求出除法中的余数 print(10 % 3) # 1 # 如果被除数和除数都是负数，余数是正常余数取反 # 如果除数是负数，余数是正常余数+除数 # 如果被除数是负数，余数就是第二种情况的取反 print(10 % 3) # 1 print(-10 % -3) # -1 print(10 % -3) # -2 print(-10 % 3) # 2 print(11 % 4) # 3 print(-11 % -4) # -3 print(11 % -4) # -1 print(-11 % 4) # 1 print(15 % 6) # 3 print(-15 % -6) # -3 print(15 % -6) # -3 print(-15 % 6) # 3**
# 求一个数的幂次方 print(2 ** 1) # 2 print(2 ** 2) # 4 print(2 ** 3) # 8 print(2 ** 4) # 16-
# 数字类型的减法运算 print(1 - 1) # 0 print(False - 1) # -1 print(0j - 1) # (-1+0j)
比较运算符
概念 比较两个值是否相同，结果只会是布尔值，条件成立返回True，反之False; 可以比较任何类型的数据； python没有向其它语言中一样区分等于和绝对等于的概念，等于就是绝对等于，是区分数据类型的； 种类 符号 作用 > 大于 < 小于 \>= 大于等于 <= 小于等于 == 等于 != 不等于print(1234 == '1234') # False print(1234 == 1234) # True
赋值运算符
概念 给某个数据赋予新的值 除了 = 之外的其它赋值运算符，都是在算数运算符的基础上添加了 = ，使用的方法则和原有的意义基本相同，是将算数出来的结果替换原有的数据 比较两个值是否相同，结果只会是布尔值，条件成立返回True，反之False; python没有其它语言的自增和自减概念； 种类 符号 作用 = 赋值 += 运算替换 -= 运算替换 *= 运算替换 /= 运算替换 //= 运算替换 %= 运算替换 **= 运算替换# 直接赋值 var = 'msr' print(var) # msr var = 'hello' print(var) # hello # 通过算数运算得出结果，然后替代原有的数据 var *= 3 print(var) # hellohellohello
成员运算符
作用用于针对容器型数据，查询某个数据是否是容器当中的元素；返回布尔值，条件成立返回True，反之False；
种类 符号 作用 in 查询的元素是否 在 容器当中 not in 查询的元素是否 不在 在容器当中字符串
# 只可以连续的元素，就是说不支持模糊查询
var = '你是Java的大神，他是PHP的开发者，我是Python的小白。'
print('Java的大神' in var) # True
print('Python的小白' not in var) # False
字典
# 在字典当中只会判断键，不会判断值
var = {'及时雨': '宋江', '玉麒麟': '卢俊义'}
print('及时雨' in var) # True
print('宋江' in var) # False
身份运算符
作用检测两个数据在内存当中是否是同一个值，返回布尔值
种类 符号 作用 is 是 同一地址 is not 不是 同一地址 Python的内存优化 整型：-5 ~~ 正无穷的范围内的数内存地址相同 浮点型：非负数的内存的地址相同 布尔型：同值内存地址相同 复数：实数+虚数的的格式永不相同 容器类型：只有字符串和空元组的情况相同intvar = 100 strvar = 'hello' # 利用id()函数检查是否是同一地址 res = id(intvar) == id(strvar) print(res) # False # 使用身份运算符 res = intvar is strvar print(res) # fasle
逻辑运算符
作用判断运算符两边的布尔值，返回布尔值
种类 符号 作用 特点 and 逻辑与：两遍的数据都为真，返回True 全真为真，一假则假 or 逻辑或：两遍的数据有一个为真，返回True 全假为假，全假为假 not 逻辑非：将后面的数据的逻辑值反转 真为假，假为真and——逻辑与
运算符两遍的值都为真，返回真，其余情况返回假
# 为真的概率低 res = True and True # True res = True and False # False res = False and True # False res = False and False # False
or——逻辑与
运算符两遍的值都为假，返回假，其余情况返回真
# 为假得概率低 res = True or True # True res = True or False # True res = False or True # True res = False or False # False
not——逻辑非
将左侧的进行反转，真的转为假，假的转为真
res = not True # False res = not False # True
布尔值为假的十种情况还记得吗？？？
0 0.0 0j False "" [] () set() {} None
逻辑短路 True or 表达式 False and 表达式在逻辑表达式中，or的特点是一真则真，所以True or首先是发现前面已经有了真，所以or就无需再检查后面的数据是真是假，直接返回前面的真，导致不在执行后面的代码，造成逻辑短路。
False and同理，and一假则假，所以当and前面出现假的时候，就不在需要知道后面的数据是真是假，直接返回假，造成逻辑短路。
# 逻辑短路，不会执行后面的print函数
True or print('hello world')
False and print('hello world')
# 没有短路
False or print('hello world')
True and print('hello world')
逻辑运算符的优先级
() > not > and > or
和数学的运算一样，要先运算括号内的数据。
在多逻辑运算符的算数中，按照优先级计算。
0 or 6 and not 9 and (1 or 3) # 按照优先级依次运算，得出结果为False
位运算符
作用位运算符用二进制数补码进行运算
种类 符号 作用 & 按位与 | 按位或 ~ 按位非 ^ 按位异或 << 左移位 \>> 右移位 &（按位与）将数字的补码中，同位数都为真的保留下来，组合成新数字
19的补码： 0000 ... 10011 15的补码： 0000 ... 01111 同位数都为真的保留下来： 0000 ... 00011 => 3
print(15 & 19)|（按位或）
将数字的补码中，同位数只要有一个为真就保留下来，组合成新数字
19的补码： 0000 ... 10011 15的补码： 0000 ... 01111 同位数一个为真的保留下来： 0000 ... 11111 => 31
print(15 | 19)^（按位异或）
将数字的补码中，同位数相同返回假，不同返回真，组合成新数字
19的补码： 0000 ... 10011 15的补码： 0000 ... 01111 同位数不同的返回真： 0000 ... 11100 => 28
print(15 ^ 19)<<（左移位）
整个数字向左移位，原位补0，组合成新数字
左移位相当于做乘法，左移n位，就相当于乘 2 的n次幂
19的补码：0001 0011 左移1位： 0010 0110 => 38
print(19 << 1)>>（右移位）
整个数字向右移位，原位补0，溢出消失，组合成新数字 右移位相当于做除法，左移n位，就相当于除以 2 的n次幂
19的补码：0001 0011 右移1位： 0000 1001 => 9
print(19 >> 1)~ 按位非
按位取反，包括符号位。 公式：-(n + 1)
十进制数：19
原码： 0001 0011 反码： 0001 0011 补码： 0001 0011 （先得到一个数的补码） 按位非：1110 1100 （按位非，包括符号位在内的全部取反） 补码： 1110 1100 （结果还是补码） 取反： 1001 0011 原码： 1001 0100 （根据这个补码还原的原码）
十进制数：-20 -(19 + 1) = -20
print(~19)
运算符总结：
运算符种类 算术运算符： + - * / // % ** 比较运算符： > < >= <= == != 赋值运算符： = += -= *= /= //= %= **= 成员运算符： in 、 not in 身份运算符： is 、 is not 逻辑运算符： and 、 or 、 not 位运算符： & | ^ ~ << >> 运算符优先级权重从小之下
当多种运算符混合使用： 算数 > 位 > 比较 > 身份 > 成员 > 逻辑 > 赋值
一元运算符 > 二元运算符 一元运算符：同一时间只操作一个值，比如按位非（~19）、逻辑非（not True） 二元运算符：同一时间操作两个值，多数是这样的，比如幂运算（2 ** 3）、逻辑与（True and False）
算数运算符： 幂运算 > 乘除 > 加减
位运算符： 按位非 > 左右移 > 按位与 > 按位异或 > 按位或
逻辑运算符： () > not > and > or
赋值运算符： = 最小 小经验这是我的一点心得：
写出机器看得懂的代码是行业门榄，质量高的代码是行业的水准，让人看得懂的代码是行业的标杆。一个优秀的编程工作者写的代码会看起来更加的直观。
在编写复杂的运算式的时候要注意尽量的让代码直观，比如可以使用括号。下面的两行运算式的结果一样，但是给人的截然不同。
# 你也可以试着根据运算符优先级 推算一下结果 res = 5 + 5 << 6 // 3 is 40 and True print(res) res = (5+5) << (6//3) is 40 and True print(res)