这篇文章本应该是介绍其他数据类型，但是我觉得有必要先对昨天的内容做一些补充，我们可以回想一下，在生活中学完数字之后，紧接着学习的是运算方式。在昨天的代码示例中已经提到了几种运算，现在就来全面总结一下。

在Python中一共有7种运算符，如目录所示。

算术运算符

加法

减法

乘法

除法

整除

取余

幂

比较运算符

相等 

不等

大于

小于

赋值运算符 

简单赋值

算术赋值

位运算符 

按位与

按位或

按位异或

按位取反 

左移 

右移

逻辑运算符

布尔与

布尔或

布尔非

身份运算符

同一对象

 不同对象

成员运算符

存在

不存在

算术运算符

算术运算符一共有7种，分别是加法、减法、乘法、除法、整除、取余和幂运算。​​​​​​​

加法

加法符号“+”，适用于我们之前讲过的所有数字数据类型

a = 2
b = 3.0
c = 6j
d = a + b
e = b + c
print(d, type(d))
print(e, type(e))

需要注意的一点是，在不同数字类型的加法中，复数类型具有最高地位，不管是整型还是浮点型和复数相加，其结果都会变为复数类型，其次是浮点型，可以影响整型数据的运算结果。

a = 0
b = bool(0)
c = bool(1)
d = a + b
e = b + c
print(d, type(d))
print(e, type(e))

 另外bool型数据在运算时是按照整型数据来处理的，其结果也是整型数据。这两条规律不仅适用于加法运算，也可以拓展到全部算术运算中。

减法

减法符号“-”，与加法同理

a = 1
b = 4.0
c = 2+3j
d = bool(2)
e = b - a - d
f = c - d - a
print(e, type(e))
print(f, type(f))

 

乘法

乘法符号“*”，出现了更高一级的运算符号，同样满足正常的运算规律

a = 1
b = 4.0
c = 2j
e = a + b * c
f = a * (b + c)
print(e, type(e))
print(f, type(f))

除法

除法符号“/”，这里有一点需要注意，在没有复数类型数据参与的情况下，运算结果均为浮点型

a = 1
b = 4
c = 2j
e = b / a
f = a / c
print(e, type(e))
print(f, type(f))

整除

整除符号“//”，是整数除法的结果，不考虑小数的情况

a = bool(1)
b = 5
c = 2.5
e = a // b
f = b // c
print(e, type(e))
print(f, type(f))

需要注意的是，复数不参与该计算，会报错 。此外如果是两个整型数据整除，得到的结果也是整型数据，但是如果有浮点型数据参与计算，结果的类型则为浮点型。

取余

 取余符号“%”，同样是整数除法的结果，不过输出的不是商而是余数

a = bool(3)
b = 5
c = 2.2
e = a % b
f = b % c
print(e, type(e))
print(f, type(f))

 

输出的数据类型和整除遵循相同的规律。

幂

幂符号“**”，即我们常说的乘方，作为最高级算术运算符，同样遵循运算规律

a = bool(3)
b = 5
c = 2.2
x = 5j
e = a + b ** c
f = x ** a
print(e, type(e))
print(f, type(f))

幂运算包括所有的数字数据类型，自然也包括复数。

比较运算符

 比较运算符常用在循环之中，用来构成真假命题。 

相等 

相等符号“==”，这个符号的作用在前面介绍布尔值的时候提到过，返回的结果是真（true）或假（false）。

a = 5
b = 3
c = a == b
print(c, type(c))

 

这里需要注意的是，单个“=”意味着赋值，两个“==”才是判断相等关系，另外在一行代码中同时出现这两个符号，存在先后运行的优先级问题，通过输出结果我们能够知道，“==”的优先级是高于赋值的“=”，这一点在其他运算比较符中也成立。

不等

不等符号“!=”,是把==中的一个=换成了!，大家编程的时候注意不要打成中文的！。

a = 5
b = 3
c = a != b
print(c, type(c))

 

输出结果同样是一个布尔值。

大于

大于符号“>”,大于等于符号“>=”，注意与其他运算关系符不同，不是两个>>。

a = 5
b = 3
c = a > b
d = b >= a
print(c, type(c))
print(d, type(d))

 

小于

小于符号“<”,小于等于符号“<=”，同样是单独的一个<。

a = 5
b = 3
c = a < b
d = b <= a
print(c, type(c))
print(d, type(d))

 

赋值运算符 

简单赋值

赋值符号“=”，和前文提到的一样，在同一行运算符中优先级最低，在赋值符号后面的语句全部运行完之后才开始工作。

a = 5
b = 3
c = bool(a == b) + a * 5
d = b <= a / 3
print(c, type(c))
print(d, type(d))

在这里我们就能进行一个简单的排序，优先级：算术运算符>比较运算符>赋值运算符。

算术赋值

是算术运算符和赋值运算符的叠加，具体类别如下表所示。

符号	含义	书写格式	等效意义
+=	加法赋值运算符	b += a	b = b + a
-=	减法赋值运算符	b -= a	b = b - a
*=	乘法赋值运算符	b *= a	b = b * a
/=	除法赋值运算符	b /= a	b = b / a
//=	取整除赋值运算符	b //= a	b = c // a
%=	取模赋值运算符	b %= a	b = b % a
**=	幂赋值运算符	b **= a	b = b ** a

a = 7
b = 3.0
b += a
print(b, type(b))
b -= a
print(b, type(b))
b *= a
print(b, type(b))
b /= a
print(b, type(b))
b //= a
print(b, type(b))
b %= a
print(b, type(b))
b **= a
print(b, type(b))

算术赋值的优先级和简单赋值一样，都排在三者最后。 

a = 7
b = 3.0
b += a * b != a
print(b, type(b))

 

位运算符 

这里首先要介绍一下进制的换算，我们日常生活中使用的是十进制，而计算机使用的是二进制。也就是说计算机中的“0000 0101”表示数字5，“0001 0000”表示数字16，二进制对应的数位从大到小分别是128、64、32、16、8、4、2、1，加起来正好是2的8次幂256，这里以8个数为一组是因为计算机中的字节即计算机中数据处理的基本单位，一般由8个二进制数组成。

按位与

按位与符号“&”，在数字键7上。高中数学学过逻辑用语的同学都知道，与代表两个命题都为真，总命题才成立，其他情况总命题都为假命题。如果我们用“1”代表真，“0”代表假就会得到如下的结果。

a = bin(5)
b = bin(8)
c = 5 & 0b101
print(a, type(a))
print(b, type(b))
print(c, type(c))

我们可以用bin函数将十进制数据转为二进制数据来进行查看，输出的结果前会加上0b用以区分，不过此时数据就变成了字符串格式，不能直接进行按位与操作。提示一点：这里不能在前面加上int来进行类型转换，这个方法是无法对二进制数据生效的。

 

查询输出的结果类型，可以看到又返回了十进制数据。

按位或

按位或符号“|”，有一句方便记忆的口诀：有1为1，全0为0。

a = bin(6)
b = bin(2)
c = bin(6 | 0b010)
print(a, type(a))
print(b, type(b))
print(c, type(c))

为了对齐，我将两个二进制数字统一成了三位，大家在判断的时候也可以在高位补零，这样看起来更直观。

按位异或

按位异或符号“^”，作用是两个二进制数，在同一位上相同的取1，不同的取0。

a = bin(6)
b = bin(2)
c = bin(6 ^ 0b010)
print(a, type(a))
print(b, type(b))
print(c, type(c))

按位取反 

按位取反符号“~”，这个符号和其他几个位运算符有所不同，不需要两个二进制共同参与运算。

a = bin(6)
b = ~6
c = bin(-7)
print(a, type(a))
print(b, type(b))
print(c, type(c))

  

此处用到了负数的二进制表示法，有兴趣的小伙伴可以参考这篇文章。

http://t.csdnimg.cn/lj0uj 

左移 

左移符号“<<”，使二进制运算数的每一位左移若干位，移动的位数由符号右边的数字指定，高位舍弃，低位补0。要注意和小于符号“<”区分。

a = 6
b = bin(a)
c = a << 2
d = bin(c)
print(a, type(a))
print(b, type(b))
print(c, type(c))
print(d, type(d))

 

右移

右移符号“>>”，作用同理，要和大于符号“＞”区分。

a = 6
b = bin(a)
c = a >> 2
d = bin(c)
print(a, type(a))
print(b, type(b))
print(c, type(c))
print(d, type(d))

 

逻辑运算符

相当于以整个数据作为命题的位运算，不在以单独二进制位上的0或1作为评判标准，而是不为0的数均为真，只有0才表示假。另外这里的运算符也不是传统意义上的代数符号，而是英文单词。

布尔与

布尔与符号“and”，逻辑和按位与相同，“全真为真，其余为假”。

a = 0
b = 2
c = (a and b)
print(c, type(c))

需要注意逻辑运算符的优先级要低于赋值运算符，所以需要用括号将命题括起来。 

 

有一点和按位与不同，当命题为真时，会输出and后面数据的值，如下列代码所示，结果为b的值2。

a = -1
b = 2
c = (a and b)
print(c, type(c))

 

当两个命题均是布尔值时，输出的结果也就变为了布尔值。

a = True
b = True
c = (a and b)
print(c, type(c))

 

布尔或

布尔或符号“or”，当第一个命题为真时输出第一个命题的结果，否则输出第二个命题的结果。命题均为布尔值时和布尔与同理。

a = -1
b = 2
c = 0
d = bool(1)
e = False
f = a or b
g = c or b
h = d or e
print(f, type(f))
print(g, type(g))
print(h, type(h))

布尔非

布尔非符号“not”，和按位取反同理，输出的结果均为布尔值。

b = 2
c = 0
d = bool(1)
f = not b
g = not c
h = not d
print(f, type(f))
print(g, type(g))
print(h, type(h))

 

身份运算符

和比较运算符相类似，判断两个变量的赋值情况。

同一对象

用“is”来判断两个标识符是不是引用自一个对象，和“==”的区别是，is 用于判断两个变量引用对象是否为同一个，即同一块内存空间； == 用于判断引用变量的值是否相等。

身份运算符的优先级也低于赋值运算符，因此需要用括号括起来。

a = 2
b = 0
c = a+0
d = (a is b)
e = (a is c)
print(a, id(a))
print(b, id(b))
print(c, id(c))
print(d, type(d))
print(e, type(e))

 

可以看到赋值相同的两个变量，引用的内存空间也相同，但在列表中则会出现不同情况，我们会在后续的学习中提到。

 不同对象

用“is not”进行判断，原理和“is”相仿。

a = 2
b = 0
c = a+0
d = (a is not b)
e = (a is not c)
print(a, id(a))
print(b, id(b))
print(c, id(c))
print(d, type(d))
print(e, type(e))

 

同样，输出的结果是布尔值。 

成员运算符

由于还没有复习到列表的知识，这里先简单介绍一下，这类运算符是用来判断一列数据中是否存在我们要找的某个数据。

存在

使用“in”来进行查找，返回的结果是一个布尔值，由于优先级较低，需要使用括号。

a = 2
b = [2, 3, 4]
c = (a in b)
print(c, type(c))

不存在

使用“not in”进行查找，和“in”同理，注意不要写成in not。

a = 2
b = [2, 3, 4]
c = (a not in b)
print(c, type(c))

 

以上就是Python中全部的七类运算符了，在使用的过程中要注意数字数据类型和优先级哦。如果还有疑问，可以参考菜鸟教程网站中的Python手册Python 运算符 | 菜鸟教程 (runoob.com)