【python】Python【算术运算符】 和 【赋值运算符】 和 【位运算符】
一、Python算术运算符
算术运算符也即数学运算符，用来对数字进行数学运算，比如加减乘除。下表列出了 Python 支持所有基本算术运算符。
| 运算符 | 说明 | 实例 | 结果 |
|---|---|---|---|
| + | 加 | 12.45 + 15 | 27.45 |
| - | 减 | 4.56 - 0.26 | 4.3 |
| * | 乘 | 5 * 3.6 | 18.0 |
| / | 除法（和数学中的规则一样） | 7 / 2 | 3.5 |
| // | 整除（只保留商的整数部分） | 7 // 2 | 3 |
| % | 取余，即返回除法的余数 | 7 % 2 | 1 |
| ** | 幂运算/次方运算，即返回 x 的 y 次方 | 2 ** 4 | 16，即 24 |
二、Python赋值运算符
= 和 == 是两个不同的运算符，= 用来赋值，而 == 用来判断两边的值是否相等，千万不要混淆。
| 运算符 | 说 明 | 用法举例 | 等价形式 |
|---|---|---|---|
| = | 最基本的赋值运算 | x = y | x = y |
| += | 加赋值 | x += y | x = x + y |
| -= | 减赋值 | x -= y | x = x - y |
| *= | 乘赋值 | x *= y | x = x * y |
| /= | 除赋值 | x /= y | x = x / y |
| %= | 取余数赋值 | x %= y | x = x % y |
| **= | 幂赋值 | x **= y | x = x ** y |
| //= | 取整数赋值 | x //= y | x = x // y |
| &= | 按位与赋值 | x &= y | x = x & y |
| |= | 按位或赋值 | x |= y | x = x | y |
| ^= | 按位异或赋值 | x ^= y | x = x ^ y |
| <<= | 左移赋值 | x <<= y | x = x << y，这里的 y 指的是左移的位数 |
| >>= | 右移赋值 | x >>= y | x = x >> y，这里的 y 指的是右移的位数 |
三、Python位运算符详解
Python 位运算按照数据在内存中的二进制位（Bit）进行操作，它一般用于底层开发（算法设计、驱动、图像处理、单片机等），在应用层开发（Web 开发、Linux 运维等）中并不常见。想加快学习进度，或者不关注底层开发的读者可以先跳过本节，以后需要的话再来学习。
Python 位运算符只能用来操作整数类型，它按照整数在内存中的二进制形式进行计算。Python 支持的位运算符如表 1 所示。
| 运算符 | 说明 | 使用形式 | 举 例 |
|---|---|---|---|
| & | 按位与 | a & b | 4 & 5 |
| | | 按位或 | a | b | 4 | 5 |
| ^ | 按位异或 | a ^ b | 4 ^ 5 |
| ~ | 按位取反 | ~a | ~4 |
| << | 按位左移 | a << b | 4 << 2，表示整数 4 按位左移 2 位 |
| >> | 按位右移 | a >> b | 4 >> 2，表示整数 4 按位右移 2 位 |
& 按位与运算符
| 第一个Bit位 | 第二个Bit位 | 结果 |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
| 按位或运算符
| 第一个Bit位 | 第二个Bit位 | 结果 |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |
^按位异或运算符
| 第一个Bit位 | 第二个Bit位 | 结果 |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |
~按位取反运算符
按位取反运算符~为单目运算符（只有一个操作数），右结合性，作用是对参与运算的二进制位取反。例如~1为0，~0为1，这和逻辑运算中的!非常类似。
例如，~9可以转换为如下的运算：
~ 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 （9 在内存中的存储）
-----------------------------------------------------------------------------------
1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0110 （-10 在内存中的存储）
所以~9的结果为 -10。
<<左移运算符
Python 左移运算符<<用来把操作数的各个二进制位全部左移若干位，高位丢弃，低位补 0。
例如，9<<3可以转换为如下的运算：
<< 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 （9 在内存中的存储）
-----------------------------------------------------------------------------------
0000 0000 -- 0000 0000 -- 0000 0000 -- 0100 1000 （72 在内存中的存储）
所以9<<3的结果为 72。
又如，(-9)<<3可以转换为如下的运算：
<< 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 （-9 在内存中的存储）
-----------------------------------------------------------------------------------
1111 1111 -- 1111 1111 -- 1111 1111 -- 1011 1000 （-72 在内存中的存储）
所以(-9)<<3的结果为 -72
如果数据较小，被丢弃的高位不包含 1，那么左移 n 位相当于乘以 2 的 n 次方。
使用 Python 代码对上面的分析进行验证：
print("%X" % (9<<3) ) print("%X" % ((-9)<<3) )
运行结果：
48
-48
>>右移运算符
Python 右移运算符>>用来把操作数的各个二进制位全部右移若干位，低位丢弃，高位补 0 或 1。如果数据的最高位是 0，那么就补 0；如果最高位是 1，那么就补 1。
例如，9>>3可以转换为如下的运算：
>> 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 （9 在内存中的存储）
-----------------------------------------------------------------------------------
0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0001 （1 在内存中的存储）
所以9>>3的结果为 1。
又如，(-9)>>3可以转换为如下的运算：
>> 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 （-9 在内存中的存储）
-----------------------------------------------------------------------------------
1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 1110 （-2 在内存中的存储）
所以(-9)>>3的结果为 -2
如果被丢弃的低位不包含 1，那么右移 n 位相当于除以 2 的 n 次方（但被移除的位中经常会包含 1）。
使用 Python 代码对上面的分析进行验证：
print("%X" % (9<<3) ) print("%X" % ((-9)<<3) )
运行结果：
1
-2
四、Python比较运算符（关系运算符）
比较运算符，也称关系运算符，用于对常量、变量或表达式的结果进行大小比较。如果这种比较是成立的，则返回 True（真），反之则返回 False（假）。
True 和 False 都是 bool 类型，它们专门用来表示一件事情的真假，或者一个表达式是否成立，我们将在《Python bool布尔类型》中详细讲解。
Python 支持的比较运算符如表 1 所示。
| 比较运算符 | 说明 |
|---|---|
| > | 大于，如果>前面的值大于后面的值，则返回 True，否则返回 False。 |
| < | 小于，如果<前面的值小于后面的值，则返回 True，否则返回 False。 |
| == | 等于，如果==两边的值相等，则返回 True，否则返回 False。 |
| >= | 大于等于（等价于数学中的 ≥），如果>=前面的值大于或者等于后面的值，则返回 True，否则返回 False。 |
| <= | 小于等于（等价于数学中的 ≤），如果<=前面的值小于或者等于后面的值，则返回 True，否则返回 False。 |
| != | 不等于（等价于数学中的 ≠），如果!=两边的值不相等，则返回 True，否则返回 False。 |
| is | 判断两个变量所引用的对象是否相同，如果相同则返回 True，否则返回 False。 |
| is not | 判断两个变量所引用的对象是否不相同，如果不相同则返回 True，否则返回 False。 |
== 和 is 的区别
初学 Python，大家可能对 is 比较陌生，很多人会误将它和 == 的功能混为一谈，但其实 is 与 == 有本质上的区别，完全不是一码事儿。
== 用来比较两个变量的值是否相等，而 is 则用来比对两个变量引用的是否是同一个对象，例如：
import time #引入time模块 t1 = time.gmtime() # gmtime()用来获取当前时间 t2 = time.gmtime() print(t1 == t2) #输出True print(t1 is t2) #输出False
运行结果：
True
False
time 模块的 gmtime() 方法用来获取当前的系统时间，精确到秒级，因为程序运行非常快，所以 t1 和 t1 得到的时间是一样的。== 用来判断 t1 和 t2 的值是否相等，所以返回 True。
虽然 t1 和 t2 的值相等，但它们是两个不同的对象（每次调用 gmtime() 都返回不同的对象），所以t1 is t2返回 False。这就好像两个双胞胎姐妹，虽然她们的外貌是一样的，但它们是两个人。
那么，如何判断两个对象是否相同呢？答案是判断两个对象的内存地址。如果内存地址相同，说明两个对象使用的是同一块内存，当然就是同一个对象了；这就像两个名字使用了同一个身体，当然就是同一个人了。
五、Python逻辑运算符及其用法
高中数学中我们就学过逻辑运算，例如 p 为真命题，q 为假命题，那么“p且q”为假，“p或q”为真，“非q”为真。Python 也有类似的逻辑运算，请看下表：
| 逻辑运算符 | 含义 | 基本格式 | 说明 |
|---|---|---|---|
| and | 逻辑与运算，等价于数学中的“且” | a and b | 当 a 和 b 两个表达式都为真时，a and b 的结果才为真，否则为假。 |
| or | 逻辑或运算，等价于数学中的“或” | a or b | 当 a 和 b 两个表达式都为假时，a or b 的结果才是假，否则为真。 |
| not | 逻辑非运算，等价于数学中的“非” | not a | 如果 a 为真，那么 not a 的结果为假；如果 a 为假，那么 not a 的结果为真。相当于对 a 取反。 |
逻辑运算符一般和关系运算符结合使用，例如：
14>6 and 45.6 > 90
14>6 结果为 True，成立，45.6>90 结果为 False，不成立，所以整个表达式的结果为 False，也即不成立。
再看一个比较实用的例子：
age = int(input("请输入年龄：")) height = int(input("请输入身高：")) if age>=18 and age<=30 and height >=170 and height <= 185 : print("恭喜，你符合报考飞行员的条件") else: print("抱歉，你不符合报考飞行员的条件")
可能的运行结果：
请输入年龄：23↙
请输入身高：178↙
恭喜，你符合报考飞行员的条件
打脸某些 Python 教程
有些不负责任的 Python 教程说：Python 逻辑运算符用于操作 bool 类型的表达式，执行结果也是 bool 类型，这两点其实都是错误的！
Python 逻辑运算符可以用来操作任何类型的表达式，不管表达式是不是 bool 类型；同时，逻辑运算的结果也不一定是 bool 类型，它也可以是任意类型。请看下面的例子：
print(100 and 200) print(45 and 0) print("" or "http://c.biancheng.net/python/") print(18.5 or "http://c.biancheng.net/python/")
运行结果：
200
0
http://c.biancheng.net/python/
18.5
你看，本例中 and 和 or 运算符操作的都不是 bool 类型表达式，操作的结果也不是 bool 值。
逻辑运算符的本质
在 Python 中，and 和 or 不一定会计算右边表达式的值，有时候只计算左边表达式的值就能得到最终结果。
另外，and 和 or 运算符会将其中一个表达式的值作为最终结果，而不是将 True 或者 False 作为最终结果。
以上两点极其重要，了解这两点不会让你在使用逻辑运算的过程中产生疑惑。
对于 and 运算符，两边的值都为真时最终结果才为真，但是只要其中有一个值为假，那么最终结果就是假，所以 Python 按照下面的规则执行 and 运算：
- 如果左边表达式的值为假，那么就不用计算右边表达式的值了，因为不管右边表达式的值是什么，都不会影响最终结果，最终结果都是假，此时 and 会把左边表达式的值作为最终结果。
- 如果左边表达式的值为真，那么最终值是不能确定的，and 会继续计算右边表达式的值，并将右边表达式的值作为最终结果。
对于 or 运算符，情况是类似的，两边的值都为假时最终结果才为假，只要其中有一个值为真，那么最终结果就是真，所以 Python 按照下面的规则执行 or 运算：
- 如果左边表达式的值为真，那么就不用计算右边表达式的值了，因为不管右边表达式的值是什么，都不会影响最终结果，最终结果都是真，此时 or 会把左边表达式的值作为最终结果。
- 如果左边表达式的值为假，那么最终值是不能确定的，or 会继续计算右边表达式的值，并将右边表达式的值作为最终结果。
使用代码验证上面的结论：
url = "http://c.biancheng.net/cplus/" print("----False and xxx-----") print( False and print(url) ) print("----True and xxx-----") print( True and print(url) ) print("----False or xxx-----") print( False or print(url) ) print("----True or xxx-----") print( True or print(url) )
运行结果：
----False and xxx-----
False
----True and xxx-----
http://c.biancheng.net/cplus/
None
----False or xxx-----
http://c.biancheng.net/cplus/
None
----True or xxx-----
True
第 4 行代码中，and 左边的值为假，不需要再执行右边的表达式了，所以 print(url) 没有任何输出。
第 6 行代码中，and 左边的值为真，还需要执行右边的表达式才能得到最终的结果，所以 print(url) 输出了一个网址。
第 8、10 行代码也是类似的。
六、Python三目运算符（三元运算符）用法详解
我们从一个具体的例子切入本节内容。假设现在有两个数字，我们希望获得其中较大的一个，那么可以使用 if else 语句，例如：
if a>b: max = a; else: max = b;
但是 Python 提供了一种更加简洁的写法，如下所示：
max = a if a>b else b
这是一种类似于其它编程语言中三目运算符? :的写法。Python 是一种极简主义的编程语言，它没有引入? :这个新的运算符，而是使用已有的 if else 关键字来实现相同的功能。
使用 if else 实现三目运算符（条件运算符）的格式如下：
exp1 if contion else exp2
condition 是判断条件，exp1 和 exp2 是两个表达式。如果 condition 成立（结果为真），就执行 exp1，并把 exp1 的结果作为整个表达式的结果；如果 condition 不成立（结果为假），就执行 exp2，并把 exp2 的结果作为整个表达式的结果。
前面的语句max = a if a>b else b的含义是：
- 如果 a>b 成立，就把 a 作为整个表达式的值，并赋给变量 max；
- 如果 a> b 不成立，就把 b 作为整个表达式的值，并赋给变量 max。
三目运算符的嵌套
Python 三目运算符支持嵌套，如此可以构成更加复杂的表达式。在嵌套时需要注意 if 和 else 的配对，例如：
a if a>b else c if c>d else d
应该理解为：
a if a>b else ( c if c>d else d )
【实例】使用 Python 三目运算符判断两个数字的关系：
a = int( input("Input a: ") ) b = int( input("Input b: ") ) print("a大于b") if a>b else ( print("a小于b") if a<b else print("a等于b") )
可能的运行结果：
Input a: 45↙
Input b: 100↙
a小于b
该程序是一个嵌套的三目运算符。程序先对 a>b 求值，如果该表达式为 True，程序就返回执行第一个表达式 print("a大于b")，否则将继续执行 else 后面的内容，也就是：
( print("a小于b") if a<b else print("a等于b") )
进入该表达式后，先判断 a<b 是否成立，如果 a<b 的结果为 True，将执行 print("a小于b")，否则执行 print("a等于b")。
七、Python运算符优先级和结合性一览表
Python 运算符优先级
所谓优先级，就是当多个运算符同时出现在一个表达式中时，先执行哪个运算符。
例如对于表达式a + b * c，Python 会先计算乘法再计算加法；b * c的结果为 8，a + 8的结果为 24，所以 d 最终的值也是 24。先计算*再计算+，说明*的优先级高于+。
Python 支持几十种运算符，被划分成将近二十个优先级，有的运算符优先级不同，有的运算符优先级相同，请看下表。
| 运算符说明 | Python运算符 | 优先级 | 结合性 | 优先级顺序 |
|---|---|---|---|---|
| 小括号 | ( ) | 19 | 无 | 高 ︿ | | | | | | | | | | | | | | | | | | | | | | 低 |
| 索引运算符 | x[i] 或 x[i1: i2 [:i3]] | 18 | 左 | |
| 属性访问 | x.attribute | 17 | 左 | |
| 乘方 | ** | 16 | 右 | |
| 按位取反 | ~ | 15 | 右 | |
| 符号运算符 | +（正号）、-（负号） | 14 | 右 | |
| 乘除 | *、/、//、% | 13 | 左 | |
| 加减 | +、- | 12 | 左 | |
| 位移 | >>、<< | 11 | 左 | |
| 按位与 | & | 10 | 右 | |
| 按位异或 | ^ | 9 | 左 | |
| 按位或 | | | 8 | 左 | |
| 比较运算符 | ==、!=、>、>=、<、<= | 7 | 左 | |
| is 运算符 | is、is not | 6 | 左 | |
| in 运算符 | in、not in | 5 | 左 | |
| 逻辑非 | not | 4 | 右 | |
| 逻辑与 | and | 3 | 左 | |
| 逻辑或 | or | 2 | 左 | |
| 逗号运算符 | exp1, exp2 | 1 | 左 |
结果表1中的运算符优先级，我们尝试分析下面表达式的结果：
4+4<<2
+的优先级是 12，<<的优先级是 11，+的优先级高于<<，所以先执行 4+4，得到结果 8，再执行 8<<2，得到结果 32，这也是整个表达式的最终结果。
像这种不好确定优先级的表达式，我们可以给子表达式加上( )，也就是写成下面的样子：
(4+4) << 2
这样看起来就一目了然了，不容易引起误解。
当然，我们也可以使用( )改变程序的执行顺序，比如：
4+(4<<2)
则先执行 4<<2，得到结果 16，再执行 4+16，得到结果20。
虽然 Python 运算符存在优先级的关系，但我不推荐过度依赖运算符的优先级，这会导致程序的可读性降低。因此，我建议读者：
- 不要把一个表达式写得过于复杂，如果一个表达式过于复杂，可以尝试把它拆分来书写。
- 不要过多地依赖运算符的优先级来控制表达式的执行顺序，这样可读性太差，应尽量使用
( )来控制表达式的执行顺序。
Python 运算符结合性
所谓结合性，就是当一个表达式中出现多个优先级相同的运算符时，先执行哪个运算符：先执行左边的叫左结合性，先执行右边的叫右结合性。
例如对于表达式对于100 / 25 * 16，/和*的优先级相同，应该先执行哪一个呢？这个时候就不能只依赖运算符优先级决定了，还要参考运算符的结合性。/和*都具有左结合性，因此先执行左边的除法，再执行右边的乘法，最终结果是 64。
Python 中大部分运算符都具有左结合性，也就是从左到右执行；只有 ** 乘方运算符、单目运算符（例如 not 逻辑非运算符）、赋值运算符和三目运算符例外，它们具有右结合性，也就是从右向左执行。表 1 中列出了所有 Python 运算符的结合性。
总结
当一个表达式中出现多个运算符时，Python 会先比较各个运算符的优先级，按照优先级从高到低的顺序依次执行；当遇到优先级相同的运算符时，再根据结合性决定先执行哪个运算符：如果是左结合性就先执行左边的运算符，如果是右结合性就先执行右边的运算符。
浙公网安备 33010602011771号