运算符
约 2356 字大约 8 分钟
运算符
算数运算符
算术运算符用于组织整数类型和浮点类型的数据，有 一元运算符 和 二元运算符 之分。
一元算术运算符有两个：+（正号）和 -（负号）。例如：+a 还是 a，-a 是对 a 的取反运算。
二元算术运算符如下表所示：
| 算数运算符 | 描述 |
|---|---|
| ++ | 依次相加 |
| -- | 依次相减 |
| + | 加 |
| - | 减 |
| * | 乘 |
| / | 除 |
| % | 取余或（求模） |
| ** | 指数或（幂） |
| // | 取整除 |
例如：
print(1 + 1) # 输出结果：2
print(1 - 1) # 输出结果：0
print(2 * 2) # 输出结果：4
print(4 / 2) # 输出结果：2.0
print(9 // 4) # 输出结果：2
print(9 % 4) # 输出结果：1
print(2 ** 4) # 输出结果：16
print((1 + 2) * 3) # 输出结果：9
赋值运算符
赋值运算符只是一种简写，只有算数和位运算符中的二元运算符才有对应的赋值运算符。
| 赋值运算符 | 描述 |
|---|---|
| = | 普通赋值 |
| += | 加赋值 |
| -= | 减赋值 |
| *= | 乘赋值 |
| /= | 除赋值 |
| %= | 取余赋值 |
| **= | 幂赋值 |
| //= | 整除赋值 |
| &= | 位与赋值 |
| |= | 位或赋值 |
| ^= | 位异赋值 |
| <<= | 左移赋值 |
| >>= | 右移赋值 |
例如：
# 单个变量赋值
num = 1
print(num) # 输出结果：1
# 多个变量赋值
num1, float1, str1 = 10, 0.5, 'hello world'
print(num1) # 输出结果：10
print(float1) # 输出结果：0.5
print(str1) # 输出结果：hello world
# 多变量赋相同值
a = b = 10
print(a) # 输出结果：10
print(b) # 输出结果：10
# 加赋值运算符
a = 100
a += 1 # a = a + 1
print(a) # 输出结果：101
# 减赋值运算符
b = 100
b -= 1 # b = b - 1
print(b) # 输出结果：99
# 乘赋值运算符
c = 100
c *= 2 # c = c * 2
print(c) # 输出结果：200
# 除赋值运算符
d = 100
d /= 2 # d = d / 2
print(d) # 输出结果：50.0
# 整除赋值运算符
e = 100
e //= 3 # e = e // 3
print(e) # 输出结果：33
# 取余赋值运算符
f = 100
f %= 3 # f = f % 3
print(f) # 输出结果：1
# 幂赋值运算符
g = 100
g **= 3 # g = g ** 3
print(g) # 输出结果：1000000
# 先算复合赋值运算符右边的表达式，再算复合赋值运算
h = 100
h *= 1 + 2 # h = 100 * (1 + 2)
print(h) # 输出结果：300
比较运算符
比较运算符用于比较两个表达式的大小，其结果是布尔类型的数据，即 True 或 False。
提示
比较运算符可用于任意类型的数据，但参与比较的两种类型的数据要相互兼容，即能进行隐式转换或显示转换
| 比较运算符 | 描述 |
|---|---|
| > | 大于 |
| < | 小于 |
| == | 等于 |
| != | 不等于 |
| >= | 大于等于 |
| <= | 小于等于 |
| is | 两个对象地址（id）为同一个对象地址（id） |
| is not | 两个对象地址（id）为不同对象地址（id） |
例如：
print(2 > 1) # 输出结果：True。判断左边大于右边
print(1 < 2) # 输出结果：True。判断左边小于右边
print(1 == 1) # 输出结果：True。判断左边等于右边
print(1 != 2) # 输出结果：True。判断左边不等于右边
print(2 >= 1) # 输出结果：True。判断左边大于等于右边
print(2 >= 2)
print(1 <= 2) # 输出结果：True。判断的左边小于等于右边
print(2 <= 2)
a = "hello"
b = "hello"
print(id(a)) # 输出结果：140506224367496
print(id(b)) # 输出结果：140506224367496
print(a is b) # 输出结果：True
a = "hello world"
b = "hello world"
print(id(a)) # 输出结果：140506208811952
print(id(b)) # 输出结果：140506208812208
print(a is not b) # 输出结果：True。交互环境跟 .py 文件结果是不一样的
逻辑运算符
逻辑运算符用于对布尔型变量进行运算，其结果也是布尔型
| 逻辑运算符 | 作用 |
|---|---|
| and | 逻辑与。如果两个语句都为真，则返回 True |
| or | 逻辑或。如果其中一个语句为真，则返回 True |
| not | 逻辑非。反转结果，如果结果为 true，则返回 False |
例如：
print((1 < 2) and (2 > 1)) # 输出结果：True。逻辑与运算
print((1 < 2) or (1 > 2)) # 输出结果：True。逻辑或运算
print(not False) # 输出结果：True。逻辑非运算，取反
数字之间逻辑运算：
# and 运算符，只要有一个值为 0，结果为 0，否则结果为最后一个非 0 数字
print(0 and 1) # 输出结果：0
print(1 and 0) # 输出结果：0
print(1 and 2) # 输出结果：2
print(2 and 1) # 输出结果：1
# or 运算符，只要所有值为 0，结果才为 0，否则结果为第一个非 0 数字
print(0 or 0) # 输出结果：0
print(0 or 1) # 输出结果：1
print(1 or 0) # 输出结果：1
print(1 or 2) # 输出结果：1
print(2 or 1) # 输出结果：2
位运算符
位运算是以二进位（bit）为单位进行运算的，操作数和结果都是整数类型的数据。
| 位运算符 | 描述 |
|---|---|
| & | 位与：只有对应操作数位都是 1 时，结果位才是 1，否则为 0 |
| | | 位或：只有对应操作数位都是 0 时，结果位才是 0，否则为 1 |
| ^ | 位异：只有对应操作数位都是 0 或都是 1 时，结果位才是 0，否则位 1 |
| ~ | 位反：将操作数中对应的二进制数 1 修改为 0；0 修改为 1 |
| >> | 右移：将一个二进制操作数向右移动指定的位数，右边（低位端）溢出的位被丢弃，而在填充左边（高位端）的空位时，如果最高位是 0（正数），左侧空位填入 0；如果最高位是 1（负数），左侧空位填入 1。右移位运算相当于除以 2 的 n 次幂 |
| << | 左移：将一个二进制操作数向左移动指定的位数，左边（高位端）溢出的位被丢弃，右边（低位端）的空位用 0 补充。左移位运算相当于乘以 2 的 n 次幂 |
例如：
# &，位与
0000 0000 0000 1100
& 0000 0000 0000 1000
-----------------------
0000 0000 0000 1000
# |，位或
0000 0000 0000 0110
| 0000 0000 0000 1010
-----------------------
0000 0000 0000 1110
# ^，位异
0000 0000 0001 1111
^ 0000 0000 0001 0110
-----------------------
0000 0000 0000 1001
# ~，位反
~ 0000 0000 0111 1011
-----------------------
1111 1111 1000 0100
# >> 右移
十进制：50 0000 0011 0010
十进制：25 0000 0001 1001 # 上面的向右移 1 位，右边最低位 0 丢弃，左边最高位添加 0
十进制：12 0000 0000 1100 # 上面的向右移 1 位，右边最低为 1 丢弃，左边最高位添加 0
# << 左移
十进制：96 0000 0110 0000
十进制：192 0000 1100 0000 # 上面的向左移 1 位，左边最高位 0 丢弃，右边最低位添加 0
十进制：384 0001 1000 0000 # 上面的向左移 1 位，左边最高位 0 丢弃，右边最低位添加 0
成员运算符
成员资格运算符用于测试序列是否在对象中出现。
| 运算符 | 描述 |
|---|---|
| in | 如果对象中存在具有指定值的序列，则返回 True |
| not in | 如果对象中不存在具有指定值的序列，则返回 True |
运算符优先级
优先级高的运算先执行，优先级低的运算后执行，同一优先级的操作按照从左到右的顺序进行。
运算符优先级，由高到低，同一行的优先级相同，如下表所示：
| 运算符 | 描述 |
|---|---|
| () | 小括号 |
| ** | 幂 |
| ~ | 位反 |
| +、- | 正负号 |
| *、/、%、// | 乘、除、取余、取整 |
| +、- | 加、减 |
| <<、>> | 左位移、右位移 |
| & | 位与 |
| ^ | 位异 |
| | | 位或 |
| <、<=、>、>=、!=、== | 比较 |
| no | 逻辑非 |
| an、or | 逻辑与、逻辑或 |
转义字符
| 转义字符 | 作用 |
|---|---|
| \ | 续行符 |
| \n | 换行符 |
| \0 | 空 |
| \t | 水平制表符 |
| " | 双引号 |
| ' | 单引号 |
| \ | 一个反斜杠 |
| \f | 换页 |
| \0dd | 八进制数，dd 代表字符。例如：\012 代表换行 |
| \xhh | 十六进制数，hh 代表字符。例如：\x0a 代表换行 |
| r/R | 在字符串定界符引号前面添加字母 r 或 R，该字符串原样输出，其中的转义字符不进行转义 |
格式化输出
- %d：整数
- %s：字符串
- %f：浮点数
- %.2f：保留小数点后两位，不够的添加 0，多的去掉
- %03d：指定整数为 3 位数，不够的在数字前面添加 0
- f'{表达式}'：格式化字符串常量
例如：
age = 18
name = 'TOM'
weight = 75.5
stu_id = 1
# %d 整数
print('今年我的年龄是 %d 岁' % age) # 输出结果：今年我的年龄是 18 岁
# %s 字符串
print('我的名字是 %s' % name) # 输出结果：我的名字是 TOM
# %f、%.2f 浮点数
print('我的体重是 %f 公斤' % weight) # 输出结果：我的体重是 75.500000 公斤
print('我的体重是 %.2f 公斤' % weight) # 输出结果：我的体重是 75.50 公斤
# %03d
print('我的学号是 %d' % stu_id) # 输出结果：我的学号是 1
print('我的学号是 %03d' % stu_id) # 输出结果：我的学号是 001
# 格式化输出多个字符
print('我的名字是 %s，今年 %d 岁了' % (name, age)) # 输出结果：我的名字是 TOM，今年 18 岁了
# 运行格式化输出字符进行运算
print('我的名字是 %s，明年 %d 岁了' % (name, age + 1)) # 输出结果：我的名字是 TOM，明年 19 岁了
# 格式化输出允许同一类型字符，注意顺序
print('我的名字是 %s，今年 %s 岁了，体重 %s 公斤' % (name, age, weight)) # 输出结果：我的名字是 TOM，今年 18 岁了，体重 75.5 公斤
# f'{表达式}'
print(f'我的名字是 {name}，今年 {age} 岁了') # 输出结果：我的名字是 TOM，今年 18 岁了