上QQ阅读APP看本书，新人免费读10天
设备和账号都新为新人
3.2 运算符及优先级
运算符是各类表达式运算的操作符，如算术表达式需要使用算术运算符。
运算符具有优先级，如在算术运算中的“先乘除，后加减”。
Python的各类运算符也有优先级，在表达式中还可以通过增加小括号“（）”来改变优先级的顺序。
1．算术运算符
算术运算符的种类及意义如表3-2所示。
表3-2 算术运算符
算术运算符也能对一些类型数据操作，如字符串、复数及复合数据类型。例如，Numpy中的array类矩阵数据、Pandas中的DataFrame数据类型。算术运算符代码示例3-11。
#算术运算符示例
import numpy as np
print（'345+678= ',345+678）
print（'\'345\'+\'678\'= ', '345'+'678'）
print（'100+58= ',100+58）
print（'2＊4= ',2＊4）
print（'\'abc\'＊3= ', 'abc'＊3）
print（'7/2= ',7/2）
print（'8/2= ',8/2）
print（'20%8= ',20%8）
print（'2＊＊5= ',2＊＊5）
print（'7//2= ',7//2）
data = [[1,2], [3,4], [5,6]]
print（'data=', data）
datax = np.array（data）
print（'\ndatax=np.array（data）=\n', datax）
print（'\ndatax＊2=\n', datax＊2）
命令执行结果：
345+678= 1023
'345'+'678'= 345678
100+58= 158
2＊4= 8
'abc'＊3= abcabcabc
7/2= 3.5
8/2= 4.0
20%8= 4
2＊＊5= 32
7//2= 3
data= [[1, 2], [3, 4], [5, 6]]
datax=np.array（data）=
[[1 2]
[3 4]
[5 6]]
datax＊2=
[[ 2 4]
[ 6 8]
[10 12]]
2．比较运算符
比较运算符的种类及意义如表3-3所示。
表3-3 比较运算符
比较运算符代码示例3-12。
#比较运算符示例
import numpy as np
print（'28==28 运算结果：',28==28）
print（'18==28 运算结果：',18==28）
print（'28! =28 运算结果：',28! =28）
print（'18! =28 运算结果：',18! =28）
print（'28>28 运算结果：',28>28）
print（'18>28 运算结果：',18>28）
print（'28<28 运算结果：',28<28）
print（'18<28 运算结果：',18<28）
print（'28>=28 运算结果：',28>=28）
print（'18<=28 运算结果：',18<=28）
print（'\'abc\'<\'bbb\' 运算结果：', 'abc'<'bbb'）
print（'\'abc\'==\'bbb\' 运算结果：', 'abc'=='bbb'）
print（'\'ccc\'==\'ccc\' 运算结果：', 'abc'=='bbb'）
print（'\'\'==None 运算结果：', ''==None）
#使用arange生成连续元素
a =np.zeros（（2,3））
b =np.zeros（（2,3））
c = np.ones（（2,3））
print（'a=\n', a）
print（'b=\n', b）
print（'c=\n', c）
print（'a==b运算结果：\n', a==b）
print（'a==c运算结果：\n', a==c）
命令执行结果：
28==28 运算结果： True
18==28 运算结果： False
28! =28 运算结果： False
18! =28 运算结果： True
28>28 运算结果： False
18>28 运算结果： False
28<28 运算结果： False
18<28 运算结果： True
28>=28 运算结果： True
18<=28 运算结果： True
'abc'<'bbb' 运算结果： True
'abc'=='bbb' 运算结果： False
'ccc'=='ccc' 运算结果： False
''==None 运算结果： False
a=
[[0. 0. 0.]
[0. 0. 0.]]
b=
[[0. 0. 0.]
[0. 0. 0.]]
c=
[[1. 1. 1.]
[1. 1. 1.]]
a==b运算结果：
[[ True True True]
[ True True True]]
a==c运算结果：
[[False False False]
[False False False]]
3．赋值运算符
赋值运算符的种类及意义见表3-4。
表3-4 赋值运算符
赋值运算符代码示例3-13。
a=3
print（'a=', a）
b=35
print（'b=', b）
c = a + b
print（'c=a + b 运算结果： c= ', c）
c += a
print（'c += a 运算结果： c= ', c）
c -= b
print（'c -= b 运算结果： c= ', c）
c ＊= a
print（'c ＊= a 运算结果： c= ', c）
c /= a
print（'c /= a 运算结果： c= ', c）
b %= a
print（'b %= a 运算结果： b= ', b）
b ＊＊= a
print（'b ＊＊= a 运算结果： b= ', b）
b //= a
print（'b //= a 运算结果： b= ', b）
命令执行结果：
a= 3
b= 35
c=a + b 运算结果： c= 38
c += a 运算结果： c= 41
c -= b 运算结果： c= 6
c ＊= a 运算结果： c= 18
c /= a 运算结果： c= 6.0
b %= a 运算结果： b= 2
b ＊＊= a 运算结果： b= 8
b //= a 运算结果： b= 2
4．逻辑运算符
逻辑运算又称布尔运算，逻辑运算符的种类及意义如表3-5所示。
表3-5 逻辑运算符
逻辑运算符代码示例3-14。
a=True
print（'a=', a）
b=False
print（'b=', b）
c=a and b
print（'c=a and b运算结果： c= ', c）
c=a or b
print（'c=a or b运算结果： c= ', c）
c= not a
print（'c=not a运算结果： c= ', c）
c= not b
print（'c=not b运算结果： c= ', c）
c=30>=20
print（'c= 30 >= 20 运算结果： c= ', c）
c= a and 15
print（'c= a and 15 运算结果： c= ', c）
c= 15 and a
print（'c= 15 and a运算结果： c= ', c）
c= b and 15
print（'c= b and 15 运算结果： c= ', c）
c= 15 and b
print（'c= 15 and b运算结果： c= ', c）
c= a or 15
print（'c= a or 15 运算结果： c= ', c）
c= 15 or a
print（'c= 15 or a运算结果： c= ', c）
c= b or 15
print（'c= b or 15 运算结果： c= ', c）
c= 15 or b
print（'c= 15 or b运算结果： c= ', c）
c= a and 'abc'
print（'c=a and \'abc\' 运算结果： c= ', c）
命令执行结果：
a= True
b= False
c=a and b运算结果： c= False
c=a or b运算结果： c= True
c=not a运算结果： c= False
c=not b运算结果： c= True
c= 30 >= 20 运算结果： c= True
c= a and 15 运算结果： c= 15
c= 15 and a运算结果： c= True
c= b and 15 运算结果： c= False
c= 15 and b运算结果： c= False
c= a or 15 运算结果： c= True
c= 15 or a运算结果： c= 15
c= b or 15 运算结果： c= 15
c= 15 or b运算结果： c= 15
c=a and 'abc' 运算结果： c= abc
5．位运算符
位运算符的种类及意义如表3-6所示。
表3-6位运算符
位运算主要指二进制数据的位运算。在Python中，二进制数前加上“0b”，如“0b1010”（不是字符串）是十进制的整数10。十进制数转换成二进制数用bin（x）函数，返回的是“x”的二进制字符串。
位运算符代码示例3-15。
a = 0b00111100 #60 = 00111100
b = 13 #13 = 00001101
print（'a=', a, ': 二进制’, bin（a）, 'b=', b, ': 二进制’, bin（b））
c = a & b #12 = 00001100
print（'c = a & b运算结果： c= ', bin（c））
c = a | b #61 = 00111101
print（'c = a | b 运算结果： c= ', bin（c））
c = a ^ b #49 = 00110001
print（'c = a ^ b 运算结果： c= ', bin（c））
c = ～a #-61 = 11000011
print（'c = ～a 运算结果： c= ', bin（c））
c = a << 2 #240 = 11110000
print（'c = a << 2 运算结果： c= ', bin（c））
c = a >> 2 #15 = 00001111
print（'c = a >> 2 运算结果： c= ', bin（c））
命令执行结果：
a= 60 : 二进制 0b111100 b= 13 : 二进制 0b1101
c = a & b运算结果： c= 0b1100
c = a | b 运算结果： c= 0b111101
c = a ^ b 运算结果： c= 0b110001
c = ～a 运算结果： c= -0b111101
c = a << 2 运算结果： c= 0b11110000
c = a >> 2 运算结果： c= 0b1111
6．成员运算符
除以上运算符之外，Python还支持成员运算符，其种类及意义如表3-7所示。能够进行成员运算的数据类型包括字符串、列表和元组。
表3-7 成员运算符
成员运算符代码示例3-16。
a = 10
l = [1, 2, 3, 4, 5 ] #列表
s =（10, 20, 30, 40, 50）#集合
print（'a= ', a）
print（'l= ', l）
print（'s= ', s）
c= a in l
print（'c= a in l运算结果： c= ', c）
c= a in s
print（'c= a in s运算结果： c= ', c）
c= a not in l
print（'c= a not in l运算结果： c= ', c）
c= a not in s
print（'c= a not in s运算结果： c= ', c）
b=[] #空列表
print（'b=[] #空列表’）
c= b not in l
print（'c= b in l运算结果： c= ', c）
c= b in s
print（'c= b in s运算结果： c= ', c）
命令执行结果：
a= 10
l= [1, 2, 3, 4, 5]
s= （10, 20, 30, 40, 50）
c= a in l运算结果： c= False
c= a in s运算结果： c= True
c= a not in l运算结果： c= True
c= a not in s运算结果： c= False
b=[] #空列表
c= b in l运算结果： c= True
c= b in s运算结果： c= False
7．身份运算符
身份运算符用于比较两个对象的存储单元地址是否相同。除了简单数值、字符串、逻辑变量之外，其他复合数据都是对象数据。对象数据比较的是变量所对应的对象地址，如果它们的对象地址相同，那么这些变量就是使用的同一份数据。如果对其中一个变量的数据进行操作，其他变量的数据也会发生改变。因此，当对这类对象变量进行操作时，为了防止更改原始数据，不能用简单赋值语句进行变量赋值，必须使用数据“copy”的方法。身份运算符的种类及意义如表3-8所示。
表3-8身份运算符
身份运算符示例3-17。
a = 20
b = 20
print（'a=', a, ' : id=', id（a）, '\nb=', b, ' : id=', id（b））
c= a is b
print（'c= a is b运算结果： c= ', c）
b=30
print（'a=', a, ' : id=', id（a）, '\nb=', b, ' : id=', id（b））
c= a is b
print（'c= a is b运算结果： c= ', c）
x=y=[1,2,3,4,5]
print（'x=', x, ' : id=', id（x）, '\ny=', y, ' : id=', id（y））
c= x is y
print（'c= x is y运算结果： c= ', c）
x.append（99） #修改了x数据，后面我们发现y的数据也改变了
print（'x.append（99）运算结果：x= ', x）
print（'x.append（99）运算结果：y= ', y）
print（）
z=x.copy（）
print（'z=x.copy（）运算结果：z= ', z）
print（'x=', x, ' : id=', id（x）, '\nz=', z, ' : id=', id（z））
c= x is z
print（'c= x is z运算结果： c= ', c）
print（）
x.pop（5）
print（'x.pop（5）运算结果：x= ', x）
print（'x.pop（5）运算结果：y= ', y）
print（'x=', x, ' : id=', id（x）, '\nz=', z, ' : id=', id（z））
c= y is not z
print（'c= y is not z运算结果： c= ', c）
命令执行结果：
a= 20 : id= 8791414134400
b= 20 : id= 8791414134400
c= a is b运算结果： c= True
a= 20 : id= 8791414134400
b= 30 : id= 8791414134720
c= a is b运算结果： c= False
x= [1, 2, 3, 4, 5] : id= 326381000
y= [1, 2, 3, 4, 5] : id= 326381000
c= x is y运算结果： c= True
x.append（99）运算结果：x= [1, 2, 3, 4, 5, 99]
x.append（99）运算结果：y= [1, 2, 3, 4, 5, 99]
z=x.copy（）运算结果：z= [1, 2, 3, 4, 5, 99]
x= [1, 2, 3, 4, 5, 99] : id= 326381000
z= [1, 2, 3, 4, 5, 99] : id= 326369864
c= x is z运算结果： c= False
x.pop（5）运算结果：x= [1, 2, 3, 4, 5]
x.pop（5）运算结果：y= [1, 2, 3, 4, 5]
x= [1, 2, 3, 4, 5] : id= 326381000
z= [1, 2, 3, 4, 5, 99] : id= 326369864
c= y is not z运算结果： c= True
8．运算符优先级
各种类型的运算符都具有优先级。例如，在if语句的条件判断表达式中，包含各种不同类型的运算表达式，如算术运算、成员运算、关系运算等，复杂的表达式甚至包含位运算、成员切片等，对这些不同类型的运算符（操作符）都具有优先级规范。优先级高的运算符先进行操作，优先级低的运算符后进行操作。
表3-9列出了从低到高优先级的所有运算符。
表3-9 运算符优先级
优先顺序规则如下：
（1）先计算小括号“（）”中的表达式，最中间的小括号中的表达式最先计算。例如，“4*（2+3）”的计算结果为20。
（2）函数调用。例如，“10*abs（2-8）”的计算结果为60。
（3）列表等下标和切片计算。例如，“5*'abcdefg'[3]”和“'abcdefg'[2:5]”的结果是字符串“ddddd”和“cde”。
（4）属性或方法的“.”运算。例如，“（' xy'+'abc '）.strip（）”的结果是字符串“xyabc”。
（5）指数（次幂）运算。
（6）一元算术运算，如～x, +x, -x。
（7）二元算术运算，先乘除，后加减。
（8）二进制运算，如移位运算、位与、位异或、位或。
（9）比较运算，如<, <=, >, >=, ! =, ==。
（10）身份测试、成员测试运算。
（11）逻辑（布尔）运算。
（12）lambda表达式。
上述规则中的概念在之后的学习中会用到，读者可先了解。
运算符优先级代码实例3-18。
#运算符优先级示例3-18
a = 20
b = 5
c = 6
d = 3
print（"a=%d b=%d c=%d d=%d" %（a, b, c, d））
e = a+b＊c/d
print（'e = a+b＊c/d = 20+8 运算结果： e= ', e）
e =（a + b）＊ c / d
print（'e =（a+b）＊c/d = 24＊6/3 运算结果： e= ', e）
f=a+b%c＊＊d
print（'f=a+b%c＊＊d=20+5%216 运算结果： f= ', f）
g=a+b＊c <<2
print（'g=a+b＊c <<2 =20+30 <<2 运算结果： g= ', g）
print（4＊（2+3））
print（10＊abs（2-8））
print（5＊'abcdefg'[3]）
print（'abcdefg'[2:5]）
print（（' xy'+'abc '）.strip（））
命令执行结果：
a=20 b=5 c=6 d=3
e = a+b＊c/d = 20+8 运算结果： e= 30.0
e =（a+b）＊c/d = 24＊6/3 运算结果： e= 50.0
f=a+b%c＊＊d=20+5%216 运算结果： f= 25
g=a+b＊c <<2 =20+30 <<2 运算结果： g= 200
20
60
ddddd
cde
xyabc