运算符分类
算数运算符比较运算符逻辑运算符赋值运算符成员运算符身份运算符位运算符
1. 算数运算符
加减乘：
+ - *
浮点数除法：/
取整除：//
取模：%
求幂：**
算法运算符也叫基本运算符
# 加
>>> 1 + 2
3
# 减
>>> 2 - 1
1
# 乘
>>> 2 * 2
4
# 浮点除
>>> 10 / 2
5.0
# 整除（直接舍弃小数位）
>>> 5 // 2
2
# 取余数
>>> 8 % 3
2
# 求幂
>>> 10 ** 3
1000
- 浮点数除法
/运算结果为整数时也会保留一个小数位0- 整除
//运算对于小数位不会四舍五入，而是直接舍弃- 取模运算
%可以用来判断两个数之间能否被整除：余数为0
2. 比较运算符
相等：
==
不相等：!=
大于：>
小于：<
大于且等于：>=
小于且等于：<=
比较运算符通常用于流程控制语句中做条件判断
3. 逻辑运算符
与：
and前后条件都成立，结果才成立
或：or前后条件有一个成立，结果就成立
非：not对结果取反
逻辑运算符是指在多个条件组合判断时使用的运算符
>>> a = 1
>>> b = 2
# and，都满足时才为真
>>> a == 1 and b > a
True
>>> a > 2 and b == 2
False
# or，满足其一即可
>>> a < b or b == 1
True
>>> a > b or b == 1
False
# not，取反
>>> a > b
False
>>> not a > b
True
not > and > or
4. 赋值运算符
赋值：
=
加法赋值：+=
减法赋值：-=
乘法赋值：*=
浮点除赋值：/=
取整除赋值：//=
取模赋值：%=
幂赋值：**=
# 加法赋值运算符
>>> a = 1
>>> a += 1 # a = a + 1
>>> print("a:{}".format(a))
a:2
>>> str = 'abc'
>>> str += 'def' # str = str + "def"
>>> print("str:{}".format(str))
str:abcdef
# 减法、乘法、除法、取整除赋值运算符
>>> b = 2
>>> b -= 1 # b = b - 1
>>> print("b:{}".format(b))
b:1
>>> c = 3
>>> c *= 2 # c = c * 2
>>> print("c:{}".format(c))
c:6
>>> d = 4
>>> d /= 2 # d = d / 2
>>> print("d:{}".format(d))
d:2.0
>>> e = 4
>>> e //= 2 # e = e // 2
>>> print("e:{}".format(e))
e:2
# 取模、幂赋值运算符
>>> f = 5
>>> f %= 2 # f = f % 2
>>> print("f:{}".format(f))
f:1
>>> g = 6
>>> g **= 2 # g = g ** 6
>>> print("g:{}".format(g))
g:36
5. 成员运算符
in在指定的序列中找到值返回True，否则返回Fasle
not in在指定的序列中没有找到值返回True，否则返回Fasle
成员运算符通常用于判断某个值是否在指定列表中
# 判断'cat'是否在pets列表里
pets = ['dog', 'cat', 'pig']
if 'cat' in pets:
print("cat in the list") # 如果在则打印该语句
else:
print("cat not in the list") # 如果不在则打印该语句
# 判断'bird'是否不在pets列表里
if 'bird' not in pets:
print("bird not in the list") # 如果不在则打印此语句
else:
print("bird in the list") # 如果在则打印此语句
--run--
cat in the list
bird not in the list
6. 身份运算符
is判断两个变量是不是引用自一个对象
is not判断两个变量是不是引用自不同对象
>>> a = 5
>>> b = a
>>> c = 5.0
>>> print(a is b) # 内存地址比较，判断是否指向了同一块内存区域
True
>>> print(a == c) # 数值比较
True # 5和5.0数值大小是相等的
>>> print(a is c) # 虽然两者数值相等，但它们是不同数据类型，内存地址不一样
False
>>> print(a is not c) # 判断是否指向了不同内存区域
True
7. 位运算符
&
0 & 0 = 0
0 & 1 = 0
1 & 0 = 0
1 & 1 = 1
*注：在本章中，0表示False，1表示True
同 and，都为1时，结果才为1，否则为0 必须同时满足
两个数值与运算，是将这两个数的二进制数（二进制位数不一样则用0补齐），对应的每一个二进制位进行“相与”，再转换为十进制就是结果
>>> a = 60 # 二进制 111100
>>> b = 13 # 二进制 001101（补齐）
>>> a & b
12 # 二进制结果 001100
|
0 | 0 = 0
0 | 1 = 1
1 | 0 = 1
1 | 1 = 1
同 or，只要有一个为1，结果就为1 满足其一，或者都满足
两个数值或运算，是将这两个数的二进制数对应的每一位进行“相或”，再转换为十进制就是结果
>>> a = 60 # 二进制 111100
>>> b = 13 # 二进制 001101（补齐）
>>> a | b
61 # 二进制结果 111101
^
0 ^ 0 = 0
0 ^ 1 = 1
1 ^ 0 = 1
1 ^ 1 = 0
异或运算，仅一个为1时，结果才为1，若都为1或都为0时则为0 只能满足其一
两个数值异或运算，是将这两个数的二进制数对应的每一位进行“异或”，再转换为十进制就是结果
>>> a = 60 # 二进制 111100
>>> b = 13 # 二进制 001101（补齐）
>>> a ^ b
49 # 二进制结果 110001
~
~0 = 1
~1 = 0
结果取反 真为假，假为真
正数非运算：-(二进制数 + 1)，结果是原十进制数加1再变成负数
负数非运算：-(-二进制数 + 1)，结果是原十进制数加1（注意是负数加正1）再变成正数
>>> a = 60 # 二进制 111100
>>> b = -60 # 二进制 -111100
>>> ~a
-61 # 二进制结果 -111101
>>> ~b
59 # 二进制结果 111011
<<
左移若干位，右补0
对一个数字左移 # 位，是将该数字的二进制数往左移 # 位，然后在右边补 # 个0，再转换成十进制就是左移结果
>>> a = 60 # 二进制 111100
>>> a << 3 # 左移3位，相当于在右边加三个0
480 # 二进制结果 111100000
>>
右移若干位，左补0
对一个数字右移 # 位，是将该数字的二进制数从右往左删除 # 位，然后在左边补 # 个0，再转换成十进制就是右移结果
>>> a = 60 # 二进制 111100
>>> a >> 3 # 右移3位，相当于删除右边3位
7 # 二进制结果 111
附：十进制与二进制互转方法
采用"除2取余，逆序排列"法
具体做法是：用2整除十进制整数，可以得到一个商和余数；再用2去除商，又会得到一个商和余数，如此进行，直到商为小于1时为止，然后把先得到的余数作为二进制数的低位有效位，后得到的余数作为二进制数的高位有效位，依次排列起来
百科
从右往左，将二进制数的每一位乘以 2 ^ (当前位数 - 1)，然后结果求和
也可以利用规律来计算：
0000 0001 1 第1位
0000 0010 2 1在第2位
0000 0100 4 1在第3位
0000 1000 8 1在第4位
0001 0000 16 1在第5位
0010 0000 32 1在第6位
0100 0000 64 1在第7位
1000 0000 128 1在第8位
......
将二进制的每位1的十进制数相加
# 方法1：
1101001 = 1*2^0 + 0*2^1 + 0*2^2 + 1*2^3 + 0*2^4 + 1*2^5 + 1*2^6 = 105
# 方法2（利用规律）：
1101001 = 64 + 32 + 8 + 1 = 105