Python3基础篇（三）——运算符

前言：
阅读这篇文章我能学到什么？
  这篇文章将为你介绍Python3运算符的使用。

1 Python3运算符

  同其他语言一样，Python3也具有多种运算符。Python3的7类运算符如下：

运算符类别 运算符
算术运算符 +、-、*、/、%、**、//
关系运算符 ==、!=、>、<、>=、<=
赋值运算符 =、+=、-=、*=、/=、%=、**=、//=、:=
位运算符 &、|、^、~、<<、>>
逻辑运算符 and、or、not
成员运算符 in、not in
身份运算符 is、is not

2 算术运算符

算术运算符 描述
+ 求和
- 求差或求相反数
* 求积
/ 求商
% 取模
** 幂运算

代码示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
a = 10
b = 2

print(a + b)
print(a - b)
print(a * b)
print(a / b)
print(a % b)            #取模
print(a ** b)           #幂运算，10^2
print(a // b)           #求商且结果取整

print(-a)               #取a的负数
print(1 // 3)           #向下取整
print(-1 // 3)

运行结果为：

1
2
3
4
5
6
7
8
9
10
12
8
20
5.0
0
100
5
-10
0
-1

3 关系运算符

关系运算符 描述
== 判等
!= 判不等
> 大于
< 小于
>= 大于等于
<= 小于等于

代码示例：

1
2
3
4
5
6
7
8
9
a = 10
b = 2

print(a == b)
print(a != b)
print(a > b)
print(a < b)
print(a >= b)
print(a <= b)

运行结果为：

1
2
3
4
5
6
False
True
True
False
True
False

4 赋值运算符

赋值运算符 描述
= 直接赋值
+= 加法赋值
-= 减法赋值
*= 乘法赋值
/= 除法赋值
%= 取模赋值
**= 幂赋值
//= 取整除赋值
:= 海象赋值（Python3.8新增特性），使得Python3开始支持在表达式内赋值。（c/c++的=赋值符号就可以在表达式内赋值）

代码示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
a = 10
b = 3

a = b
print(a)
a += b
print(a)
a -= b
print(a)
a *= b
print(a)
a /= b
print(a)
a = 8
a %= b
print(a)
a **= b
print(a)
a //= b
print(a)

c = (n := a) * b                #海象运算符，是的可以在表达式内赋值
print(c)

运行结果：

1
2
3
4
5
6
7
8
9
3
6
3
9
3.0
2
8
2
6

5 位运算符

位运算符 描述
& 按位与运算
| 按位或运算
^ 按位异或运算
~ 按位取反运算
<< 左移位运算
>> 右移位运算
代码示例： 
1
2
3
4
5
6
7
8
9
10
11
12
a = 10
b = 9

print(bin(a))               #以二进制输出
print(bin(b))

print(bin(a & b))
print(bin(a | b))
print(bin(a ^ b))
print(bin(~a))
print(bin(a << 1))
print(bin(b >> 1))

运行结果：

1
2
3
4
5
6
7
8
0b1010
0b1001
0b1000
0b1011
0b11
-0b1011
0b10100
0b100

  解释下为什么10按位取反的二进制结果是-0b1011，是因为10是有符号数，其反码是负数，而负数在计算机中是以补码形式存储的的（补码就是反码再加1）。

6 逻辑运算符

逻辑运算符 描述
and 逻辑与，x and y 当x为真时结果为y，当x为假时结果为x
or 逻辑或，x or y 当x为真时结果为x，当x为假时结果为y
not 逻辑非，not x 当x为真时结果为False，当x为假时结果为True

代码示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
#以下类型在Python3中都判为逻辑假，其他为真
if 0:                      #整形0为假
    print(True)
else:
    print(False)

if 0.0:                    #浮点型0.0为假
    print(True)
else:
    print(False)

if None:                    #类似c/c++中的NULL，为假
    print(True)
else:
    print(False)

str = ""                    #空字符串为假
if str:
    print(True)
else:
    print(False)

Set = ()                    #空元组为假
if Set:
    print(True)
else:
    print(False)

Tuple = []                  #空列表为假
if Tuple:
    print(True)
else:
    print(False)

Set = set()                 #空集合为假
if Set:
    print(True)
else:
    print(False)

dic = {}                     #空字典为假
if dic:
    print(True)
else:
    print(False)

#逻辑与
#x为真，时输出y的值
x = 1
y = 3
print(x and y)               #x为真，输出y的值

x = 0
y = 2
print(x and y)               #x为0是假，输出x

x = ()
y = 2
print(x and y)               #x为空元组是假，输出x

#逻辑或
x = 1
y = 3
print(x or y)                #x为1是真，输出x的值

x = 0
y = 2
print(x or y)                #x为0是假，输出y的值

x = []
y = 2
print(x or y)                #x为空列表是假，输出y的值

x = 0
print(not x)                 #x为0是假，输出True

x = 1
print(not x)                 #x为1是真，输出False

运算结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
False
False
False
False
False
False
False
False
3
0
()
1
2
2
True
False

  Python3中将几类判定为假：0,0.0,None,"",(),[],set(),{}，其他为真。简单记忆就是数值为0时，None时，数据类型为空时为假。

7 成员运算符

成员运算符 描述
in 判定存在其中
not in 判定不存在其中 
1
2
3
4
5
6
7
8
9
Tuple = (1, 2, 3)
List = [1, 2, 3]
Set = {1, 2, 3}
Dictionary = {"1":1, "2":2, "3":3}

print(1 in Tuple)
print(1 in List)
print(1 in Set)
print("2" in Dictionary)            #判断字典中是否存在某个键値

运算结果：

1
2
3
4
True
True
True
True

8 身份运算符

身份运算符 描述
is 判断是否引用自一个对象
is not 判断是否不是引用自同一个对象
  说白了就是比较内存地址是否相同。==用于比较变量内存中的值是否用，is和is not用于比较变量的内存地址是否相同。用id()函数可以获取对象的地址。 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
'''
python解释器为了节省内存，进行了一些优化。小数字缓存池是事先创建好的（不管你用不用它都存在
，当变量值为区间[-5, 256]内时，变量的地址都是固定的小整数缓存池中固定的地址。所以当多个变量的
值相同且位于小整数区间[-5, 256]区间内时，他们的地址都是固定相同的。
'''
#观察地址
a = -6                  #多次运行地址会变
b = -5                  #多次运行地址不变
c = 256                 #多次运行地址不变
d = 257                 #多次运行地址会变
print(id(a))
print(id(b))
print(id(c))
print(id(d))

x = -5                  #小整数范围内
print(id(x))            #对应小整数缓存池内固定地址
x = -6                  #不在小整数范围内
print(id(x))            #改变变量内的值，变量地址变了
x = -7                  #再次改变变量值，不在小整数范围内
print(id(x))            #改变变量内的值，变量地址又变了

a = 0
b = 0
c = 1
print(a is b)           #地址相同，是引用自一个对象
print(a is c)           #地址不相同，不是引用自一个对象
print(a is not a)
print(a is not c)

运算结果：

1
2
3
4
5
6
7
8
9
10
11
1932188604144
140713282360800
140713282369152
1932218591312
140713282360800
1932188604144
1932188603952
True
False
False
True

9 运算符优先级

运算符优先级 描述
** 指数（最高优先级）
~ + - 这里的是一元运算符
* / % //
+ - 二元运算符
>> << 移位运算符
& 位与
^ | 位运算
>= <= > < 比较运算
== != 判等
= %= /= //= -= += *= **= 赋值运算
is、is not 身份运算符
in、not in 成员运算符
and or not 逻辑运算符（优先级最低） 
1
2
3
4
5
6
7
8
#建议尽量多加括号，不要太相信自己或别人对优先级的记忆，应尽量将表达式写得看起来没有歧义。
a = 1
b = 0
print(a + b << 1)           #等同于(a + b) << 1

c = 2
c *= b + a
print(c)                    #等同于c = c * (b + a)

运算结果：

1
2
2
2