python运算符优先级
通过本专栏《小白轻松学python》前面一些文章的介绍，我们知道了python中一些常用的运算符。当这些常用的运算符同时出现在同一个表达式中时，它们是有运算的优先顺序的。就像数学中的四则运算一样，乘除法会优先于加减法，有括号的先算括号中的内容。
python常用运算符优先级表
| ** | 幂运算 |
| *、/、%、// | 乘、除、取余、取整 |
| +、- | 加、减 |
| <、>、<=、>=、==、!=、is、is not、in、not in | 比较运算符、身份运算符、成员运算符 |
| not | 逻辑运算符 not |
| and | 逻辑运算符 and |
| or | 逻辑运算符 or |
| =、+=、-=、*=、/=、%=、//=、**= | 赋值运算符 |
以上常用的运算符优先级从上到下依次降低，运算优先级高的先计算，低的后计算。有括号时会优先运算括号中的内容，所以我们可以利用括号来打破运算优先级的限制。
优先级顺序
幂运算高于乘除运算
幂运算的运算优先级高于乘除运算，当幂运算与乘除运算在同一个表达式中时，会先计算幂运算再计算乘除运算。
number = 3 * 2 ** 2
print(number) # 12通过上面的代码，我们可以发现是先运算 2 ** 2 = 4 再运算 3 * 4 = 12，如果是先运算 3 * 2 = 6 再运算 6 ** 2 = 36。结果明显是12而不是36，所以幂运算高于乘法运算。
number = 8 / 2 ** 2
print(number) # 2.0通过上面的代码，我们可以发现是先运算 2 ** 2 = 4 再运算 8 / 4 = 2.0，如果是先运算 8 / 2 = 4.0 再运算 4.0 ** 2 = 16.0。结果明显是2.0而不是16.0，所以幂运算高于除法运算。
number = 7 % 2 ** 2
print(number) # 3通过上面的代码，我们可以发现是先运算 2 ** 2 = 4 再运算 7 % 4 = 3，如果是先运算 7 % 2 = 1 再运算 1 ** 2 = 1。结果明显是3而不是1，所以幂运算高于取余运算。
number = 7 // 2 ** 2
print(number) # 1通过上面的代码，我们可以发现是先运算 2 ** 2 = 4 再运算 7 // 4 = 1，如果是先运算 7 // 2 = 3 再运算 3 ** 2 = 9。结果明显是1而不是9，所以幂运算高于取整运算。
乘除运算高于加减运算
乘除运算的优先级高于加减运算，当乘除法与加减法在同一个表达式中时，会先计算乘除法再计算加减法。
number = 5 + 2 * 2
print(number) # 9通过上面的代码，我们可以发现是先运算 2 * 2 = 4 再运算 5 + 4 = 9，如果是先运算 5 + 2 = 7 再运算 7 * 2 = 14。结果明显是9而不是14，所以乘法运算高于加法运算。
number = 5 - 2 / 2
print(number) # 4.0通过上面的代码，我们可以发现是先运算 2 / 2 = 1.0 再运算 5 - 1.0 = 4.0，如果是先运算 5 - 2 = 3 再运算 3 / 2 = 1.5。结果明显是4.0而不是1.5，所以除法运算高于减法运算。
number = 5 - 2 % 2
print(number) # 5通过上面的代码，我们可以发现是先运算 2 % 2 = 0 再运算 5 - 0 = 5，如果是先运算 5 - 2 = 3 再运算 3 % 2 = 1。结果明显是5而不是1，所以取余运算高于减法运算。
number = 5 + 2 // 2
print(number) # 6通过上面的代码，我们可以发现是先运算 2 // 2 = 1 再运算 5 + 1 = 6，如果是先运算 5 + 2 = 7 再运算 7 // 2 = 3。结果明显是6而不是3，所以取整运算高于加法运算。
加减运算高于比较运算
这里要补充一个知识点：bool值True和False可以作为整数1和0参与到数字的运算中。
加减运算优先级高于比较运算，当加减运算与比较运算在同一个表达式中时，会先计算加减运算再计算比较运算。
number = 0
if 5 < 3 + 2:
number = 1
else:
number = 2
print(number) # 2通过上面的代码，我们可以发现是先运算 3 + 2 = 5 再运算 5 < 5 = False，条件为假执行else下面的代码 number = 2 ；如果是先运算 5 < 3 = False 再运算 False + 2 = 2 ，条件为真执行if下面的代码 number = 1 。结果明显是2，所以加法运算高于小于比较运算。
number = 0
if 1 > 3 - 2:
number = 1
else:
number = 2
print(number) # 2通过上面的代码，我们可以发现是先运算 3 - 2 = 1 再运算 1 > 1 = False，条件为假执行else下面的代码 number = 2 ；如果是先运算 1 > 3 = False 再运算 False - 3 = -3 ，条件为真执行if下面的代码 number = 1 。结果明显是2，所以减法运算高于大于比较运算。
number = 0
if 5 <= 3 + 1:
number = 1
else:
number = 2
print(number) # 2通过上面的代码，我们可以发现是先运算 3 + 1 = 4 再运算 5 <= 4 = False，条件为假执行else下面的代码 number = 2 ；如果是先运算 5 <= 3 = False 再运算 False + 1 = 1 ，条件为真执行if下面的代码 number = 1 。结果明显是2，所以加法运算高于小于等于比较运算。
number = 0
if 5 >= 3 - 1:
number = 1
else:
number = 2
print(number) # 1通过上面的代码，我们可以发现是先运算 3 - 1 = 2 再运算 5 >= 2 = True，条件为真执行if下面的代码 number = 1 ；如果是先运算 5 >= 3 = True 再运算 True - 1 = 0 ，条件为假执行else下面的代码 number = 2 。结果明显是1，所以减法运算高于大于等于比较运算。
number = 0
if 5 == 3 + 3:
number = 1
else:
number = 2
print(number) # 2通过上面的代码，我们可以发现是先运算 3 + 3 = 6 再运算 5 == 6 = False，条件为假执行else下面的代码 number = 2 ；如果是先运算 5 == 3 = False 再运算 False + 3 = 3 ，条件为真执行if下面的代码 number = 1 。结果明显是2，所以加法运算高于等于比较运算。
number = 0
if 5 != 3 - 1:
number = 1
else:
number = 2
print(number) # 1通过上面的代码，我们可以发现是先运算 3 - 1 = 2 再运算 5 != 2 = True，条件为真执行if下面的代码 number = 1 ；如果是先运算 5 != 3 = True 再运算 True - 1 = 0 ，条件为假执行else下面的代码 number = 2 。结果明显是1，所以减法运算高于不等于比较运算。
加减运算高于身份运算
加减运算优先级高于身份运算，当加减运算与身份运算在同一个表达式中时，会先计算加减运算再计算身份运算。
state = 1 + 1 is 2
print(state) # True通过上面的代码，我们可以发现是先运算 1 + 1 = 2 再运算 2 is 2 = True；如果是先运算 1 is 2 = False 再运算 1 + False = 1，那么state的值为1。结果明显是True而不是1，所以加法运算高于身份运算。
state = 1 - 1 is not 2
print(state) # True通过上面的代码，我们可以发现是先运算 1 - 1 = 0 再运算 0 is not 2 = True；如果是先运算 1 is not 2 = True 再运算 1 - True = 0，那么state的值为0。结果明显是True而不是0，所以减法运算高于身份运算。
加减运算高于成员运算
加减运算优先级高于成员运算，当加减运算与成员运算在同一个表达式中时，会先计算加减运算再计算成员运算。
state = 1 + 1 in [0, 1, 2]
print(state) # True通过上面的代码，我们可以发现是先运算 1 + 1 = 2 再运算 2 in [0, 1, 2] = True；如果是先运算 1 in [0, 1, 2] = True 再运算 1 + True = 2，那么state的值为2。结果明显是True而不是2，所以加法运算高于成员运算。
state = 1 - 1 not in [0, 1, 2]
print(state) # False通过上面的代码，我们可以发现是先运算 1 - 1 = 0 再运算 0 not in [0, 1, 2] = False；如果是先运算 1 not in [0, 1, 2] = False 再运算 1 - False = 1，那么state的值为1。结果明显是False而不是1，所以减法运算高于成员运算。
比较运算高于not
比较运算的优先级高于逻辑运算not，当比较运算与not运算在同一个表达式中时，会先计算比较运算再计算not运算。
state = not 6 <= 6
print(state) # False通过上面的代码，我们可以发现是先运算 6 <= 6 = True 再运算 not True = False；如果是先运算 not 6 = False 再运算 False <= 6 = True。结果明显是False而不是True，所以比较运算高于not运算。
身份运算高于not
身份运算的优先级高于逻辑运算not，当身份运算与not运算在同一个表达式中时，会先计算身份运算再计算not运算。
state = not 7 is not 6
print(state) # False通过上面的代码，我们可以发现是先运算 7 is not 6 = True 再运算 not True = False；如果是先运算 not 7 = False 再运算 False is not 6 = True。结果明显是False而不是True，所以身份运算高于not运算。
成员运算高于not
成员运算的优先级高于逻辑运算not，当成员运算与not运算在同一个表达式中时，会先计算成员运算再计算not运算。
state = not 7 in [False, 6, 7, 8]
print(state) # True通过上面的代码，我们可以发现是先运算 7 in [False, 6, 7, 8] = True 再运算 not True = False；如果是先运算 not 7 = False 再运算 False in [False, 6, 7, 8] = True。结果明显是False而不是True，所以成员运算高于not运算。
not高于and
逻辑运算not优先级高于逻辑运算and， 当not与and在同一个表达式中时，会先计算not再计算and。
state = True and not False
print(state) # True通过上面的代码，我们可以发现是先运算 not False = True 再运算 True and True = True；如果是先运算 True and not 会报错SyntaxError: invalid syntax。结果明显是True，所以逻辑运算not高于and。
and高于or
逻辑运算and优先级高于逻辑运算or， 当and与or在同一个表达式中时，会先计算and再计算or。
state = True or True and False
print(state) # True通过上面的代码，我们可以发现是先运算 True and False = False 再运算 True or False = True；如果是先运算 True or True = True 再运算 True and False = False 。结果明显是True而不是False，所以逻辑运算and高于or。
or高于赋值运算
逻辑运算or优先级高于赋值运算， 当or与赋值运算在同一个表达式中时，会先计算or再计算赋值运算。
number = 0
number += False or 5
print(number) # 5通过上面的代码，我们可以发现是先运算 False and 5 = 5 再运算 number += 5，此时number为5；如果是先运算 number += False 再运算 number or 5 ，此时number为0。结果明显是5而不是0，所以逻辑运算or高于赋值运算。
同级优先级
处于同一级别的运算符，它们的优先级又是怎样的呢？
乘除运算（从左往右）
乘除运算的同级优先顺序是从左往右看，谁靠左谁优先。
number = 9 / 3 * 3
print(number) # 9.0通过上面的代码，我们可以发现是先运算 9 / 3 = 3.0 再运算 3.0 * 3 = 9.0；如果是先运算 3 * 3 = 9 再运算 9 / 9 = 1.0 。结果明显是9.0而不是1.0，所以乘除运算的同级优先顺序是从左往右看，谁靠左谁优先。
加减运算（从左往右）
加减运算的同级优先顺序是从左往右看，谁靠左谁优先。
number = 2 + 5 - 3
print(number) # 4通过上面的代码，我们可以发现是先运算 2 + 5 = 7 再运算 7 - 3 = 4；如果是先运算 5 - 3 = 2 再运算 2 + 2 = 4 。从结果来看都一样，其实加减法就是这个德行不管先算谁都一样。但是加减运算同级优先的底层逻辑还是从左往右看，谁靠左谁优先。
比较、身份、成员（真·同级）
比较、身份、成员运算是真正的同级运算，当它们处于同一表达式中时，从逻辑中看不出优先顺序。感觉底层逻辑使用了一个and运算来把它们分开计算，都算出结果后在进行and运算。
state = 3 < 5 is 5 # 类似于 3 < 5 and 5 is 5
print(state) # True通过上面的代码，我们可以发现 3 < 5 is 5 被分成了两部分 3 < 5 = True 和 5 is 5 = True，再计算True and True =True；如果是先运算 3 < 5 = True 再运算 True is 5 = False ；如果是先运算 5 is 5 = True 再运算 3 < True = False 。结果明显是True而不是False，所以比较、身份、成员是真正的同级运算。
赋值运算（=）
当有多个=号在一个表达式中时，是从右往左看，谁靠右谁优先。
number1 = number2 = 1
print(number1) # 1先给number2赋值为1，再把number2的值赋值给number1，所以number1的值为1。
因为赋值运算没有返回值，所以其他的赋值运算不支持同级运算。
括号改变优先级顺序
使用括号可以改变运算符的优先级，括号内的运算符就算比括号外的运算符优先级低，也会先计算括号内的运算。
number = (2 * (1 + (3 < 5))) ** 2
print(number) # 16通过上面的代码，我们可以发现是先运算 3 < 5 = True 再运算 1 + True = 2 再运算 2 * 2 = 4 再运算 4 ** 2 = 16 。
如果你想了解更多的运算符优先级，请跳转到python官方文档。
旨在为数千万中国开发者提供一个无缝且高效的云端环境，以支持学习、使用和贡献开源项目。
更多推荐
25
0- 0
已为社区贡献8条内容
所有评论(0)