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官方文档。