前言
什么是运算符？
顾名思义，运算符就是用于某种运算关系的标识符，例如数学中常用的 + 、 - 、 * 、 / 、 > 、 < ....符号，不同预算关系的符号在编程中被定义为不同的运算类型。
Python 支持的运算类型有：算术运算符、关系运算符、赋值运算符、逻辑运算符、成员运算符、身份运算符。
下面将一 一给大家演示讲解：
算术运算符
| 运算符 | 描述 |
|---|---|
| + | 加运算 |
| - | 减运算 |
| * | 乘运算 |
| / | 除运算 |
| % | 取余(模)运算（返回对象相除后的余数部分） |
| ** | 幂次方运算 |
实例演示（脚本模式）：
#!/usr/bin/python3
# -*- coding: utf-8 -*-
a = 2
b = 5
c = 9
d = 0 # 定义 d 变量用于存放运算后的值
d = a + b # 加运算
print("2 + 5 =",d)
d = a - b # 减运算
print("2 - 5 =",d)
d = a * b # 乘运算
print("2 * 5 =",d)
d = a / b # 除运算
print("2 / 5 =",d)
d = c % a # 取模运算
print("2 % 5 =",d)
d = c // a # 取整运算
print("2 / 5 =",d)
d = a ** b # 幂运算
print("2 ** 5 =",d)实例输出：
2 + 5 = 7
2 - 5 = -3
2 * 5 = 10
2 / 5 = 0.4
2 % 5 = 1
2 / 5 = 4
2 ** 5 = 32
注：在 Python2.X 中，整数除整数（ / 运算）时，返回的结果同样是整数，如果需要返回的结果是浮点数，这时只需将相运算的两个数中的其中一个改为浮点数即可。
比较运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| > | 大于（返回x是否大于y） | （5 > 2） 返回 True |
| < | 小于（返回x是否小于y） | （5 < 2） 返回 False |
| == | 等于（比较对象是否相等） | （5 == 2） 返回 False |
| != 和 <> | 不等于（比较两个对象是否不相等） | （5 != 2） 返回 True |
| >= | 大于或等于（返回x是否大于等于y） | （5 >= 2） 返回 True |
| <= | 小于或等于（返回x是否小于等于y） | （5 <= 2） 返回 False |
注：返回的结果均为布尔类型（True 等效于 1 ， False 等效于 0 .）
实例演示（交互模式）：
>>> a = 10
>>> b = 6
>>> a > b
True
>>> a <b
False
>>> a == b
False
>>> a != b
True
>>> a >= b
True
>>> a <= b
False
>>>赋值运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 直接赋值运算符 | c = a + b 将 a + b 的运算结果赋值为 c |
| += | 加法赋值运算符 | c += a 等价于 c = c + a |
| -= | 减法赋值运算符 | c -= a 等价于 c = c - a |
| *= | 乘法赋值运算符 | c= a 等价于 c = c a |
| /= | 除法赋值运算符 | c /= a 等价于 c = c / a |
| %= | 取模赋值运算符 | c %= a 等价于 c = c % a |
| //= | 取整除赋值运算符 | c //= a 等价于 c = c // a |
| **= | 幂赋值运算符 | c= a 等价于 c = c a |
实例演示（脚本模式）：
#!/usr/bin/python3
# -*- coding: utf-8 -*-
a = 20
b = 10
c = 0
c = a + b
print("a + b 的值为：",c)
c += a
print("c += a 的值为：",c)
c -= a
print("c -= a 的值为：",c)
c *= a
print("c *= a 的值为：",c)
c /= a
print("c = a 的值为：",c)
c //= a
print("c //= a 的值为：",c)
c **= a
print("c **= a 的值为：",c)输出结果：
20 + 10 的值为： 30
c += a 的值为： 50
c -= a 的值为： 30
c *= a 的值为： 600
c = a 的值为： 30
c //= a 的值为： 1.0
c **= a 的值为： 1.0
位运算符
位运算符的所有运算都是按照二进制数的形式来进行运算的，为了更好的理解位运算赋的运算过程，最好将其操作数转为二进制的形式进行运算，这样会更直观。
| 运算符 | 描述 | |
|---|---|---|
| & | 按位与运算符：即将二进制位做乘法运算 | |
| \ | 按位或运算符：即将二进制位做加法运算 | |
| ^ | 按位异或运算符：当运算数两对应的二进位相异时，结果为1，否则为0 | |
| ~ | 按位取反运算符：将二进制的每一位进行取反运算 | |
| << | 左移动运算符：将运算数的各二进位全部左移若干位，移出的高位丢弃，低位补0 | |
| >> | 右移动运算符：将运算数的各二进位全部右移若干位，移出的低位丢弃，高位补0 |
例如：
运算过程：
实例演示（脚本模式）：
#!/usr/bin/python3
# -*- coding: utf-8 -*-
a = 43
b = 55
c = 0
# 注意 c值 的继承关系
c = a & c # c = 35
print("a & b =", c)
c = a | b # c = 63
print("a & b =", c)
c = a ^b # c = 28
print("a ^ b =", c)
c = ~a # c = -44
print("a ~ b =", c)
c = a << 2 # c = 172
print("a << b =", c)
c = a >>2 # c = 10
print("a >> b =", c)输出结果：
a & b = 35
a & b = 63
a ^ b = 28
a ~ b = -44
a << b = 172
a >> b = 10
逻辑运算符
逻辑运算符主要用于判断多个条件是否满足需求，如果满足则执行相应的功能，否则跳过该功能代码。
| 运算符 | 逻辑表达式 | 描述 |
|---|---|---|
| and | x and y | 布尔与只有x，y都为真，才返回True ,否则返回False |
| or | x or y | 布尔或只要 x 或 y 中有一方为真，则返回True ,否则返回False |
| not | not x | 布尔非如果 x 为 True，返回 False ；如果 x 为 False，返回 True |
实例演示（脚本模式）：
#!/usr/bin/python3
# -*- coding: utf-8 -*-
a = 0
b = 1
c = 2
d = 0
# and : 需同时为真,条件才成立.
if( a and b ): # 条件不成立,所以不执行内部代码
print("1. a and b 条件成立")
if( b and c ): # 条件成立,所以执行内部代码
print("2. b and c 条件成立")
# or : 只要其中一方为真，条件就成立
if( a or b ): # 条件成立,执行
print("3. a or b 条件成立")
if( a or d ): # 条件不成立,不执行
print("4. a or b 条件成立")
# not : 非0即为真，条件成立；非1即为假，条件不成立
if ( not a ): # 条件成立
print("5. not a 条件成立")
if( not b ): # 条件不成立
print("6. not a 条件成立")实例输出：
b and c 条件成立
a or b 条件成立
not a 条件成立
成员运算符
成员运算符主要用于判断某个元素a是否存在于序列b当中，常见的是判断某个元素是否在序列/元组/字典当中，使用效果类似逻辑运算符。
| 运算符 | 逻辑表达式 | 描述 |
|---|---|---|
| in | x in y | 如果对象y包含对象x,返回True,否则返回False |
| not in | x not in y | 只要对象y不包含对象x,返回True,否则返回False |
实例演示（脚本模式）：
#!/usr/bin/python3
# -*- coding: utf-8 -*-
a = 2
b = [1 ,2 ,3 ,4 ,5]
c = 'test'
if(a in b ): # 条件成立
print("1 -- 列表b中存在着与a相同的元素.")
if(c in b ): # 条件不成了
print("2 -- 列表b中存在着与c相同的元素.")
if(a not in b ): # 条件不成立
print("3 -- 列表b中不存在着与a相同的元素.")
if(c not in b ): # 条件成了
print("4 -- 列表b中不存在着与c相同的元素.")实例输出：
1 -- 列表b中存在着与a相同的元素.
4 -- 列表b中不存在着与c相同的元素.
身份运算符
身份运算符主要用于判断两个对象是否引用自同一个 is 对象或不是 not is 同一对象。类似于: id(x) == id(y) / id(x) != id(y).
实例如下（脚本模式）：
#!/usr/bin/python3
# -*- coding: utf-8 -*-
a = 10
b = 10
if (a is b):
print("1 -- a 和 b 有相同的标识")
else:
print("1 -- a 和 b 没有相同的标识")
if (a is not b):
print("2 -- a 和 b 没有相同的标识")
else:
print("2 -- a 和 b 有相同的标识")
# 修改变量 b 的值
b = 20
if (a is b):
print("3 -- a 和 b 有相同的标识")
else:
print("3 -- a 和 b 没有相同的标识")
if (a is not b):
print("4 -- a 和 b 没有相同的标识")
else:
print("4 -- a 和 b 有相同的标识")实例输出：
1 -- a 和 b 有相同的标识
2 -- a 和 b 有相同的标识
3 -- a 和 b 没有相同的标识
4 -- a 和 b 没有相同的标识
【注意】上面说到了 is 类似于 == , 但它们之间是有本质上的区别的，区别如下：is 用于判断两个变量引用对象是否为同一个， 而 == 用于判断引用变量的值是否相等。
完整学习教程请访问：Python3 入门教程——目录索引
