Python 种可以通过组合对象和运算符来创建复杂的表达式。运算符是特殊符号，表示应该执行某种计算。

a = 1
b = 2
a + b
3

a + b - 5
-2

a + b 和 a + b - 5 被称为表达式。Python 支持许多将数据对象组合成表达式的运算符。

整套学习自学教程中应用的数据都是《三國志》、《真·三國無雙》系列游戏中的内容。

算术运算符

Python 支持的算术运算符 假设变量： a=10，b=20

表达式	符号说明	执行结果
+	加 - 两个对象相加	a + b 输出结果 30
-	减 - 得到负数或是一个数减去另一个数	a - b 输出结果 -10
*	乘 - 两个数相乘或是返回一个被重复若干次的字符串	a * b 输出结果 200
/	除 - x除以y	b / a 输出结果 2
%	取模 - 返回除法的余数	b % a 输出结果 0
**	幂 - 返回x的y次幂	a**b 为10的20次方， 输出结果 100000000000000000000
//	取整除 - 返回商的整数部分（向下取整）	9//2 是 4； -9//2 是 5

a = 4
b = 3

+a
4

-b
-3

a + b
7

a - b
1

a * b
12

a / b
1.3333333333333333

a % b
1

a ** b
64

比较运算符

符号	表达式	符号说明	执行结果
==	a == b	等于	a与b的值相等
!=	a != b	不等于	a与b的值不相等
<	a < b	小于	a的值小于b
<=	a <= b	小于或等于	a的值小于等于b
>	a > b	大于	a的值大于b
>=	a >= b	大于或等于	a的值大于等于b

a = 10
b = 20

a == b
False

a != b
True

a <= b
True

a >= b
False

a = 30
b = 30

a == b
True

a <= b
True

a >= b
True

特殊的浮点值等式比较

浮点数的比较不能直接进行比较。

x = 1.1 + 2.2
x == 3.3
False

确定两个浮点值是否 相等 的首选方法是在给定一些容差的情况下计算它们是否彼此接近。使用 abs() 返回绝对值。如果两个数字之间的差值的绝对值小于指定的容差，则它们彼此足够接近以被视为相等。

tolerance = 0.00001
x = 1.1 + 2.2
abs(x - 3.3) < tolerance
True

逻辑运算符

布尔操作数的逻辑表达式

x = 5
x < 10
True
type(x < 10)
<class 'bool'>

t = x > 10
t
False
type(t)
<class 'bool'>

callable(x)
False
type(callable(x))
<class 'bool'>

t = callable(len)
t
True
type(t)
<class 'bool'>

符号	表达式举例	符号说明
not	not x < 10	非的含义
or	x < 10 or callable(x)	或者
and	x < 10 and callable(x)	并且

or 复合逻辑表达式

多个逻辑运算符和操作数可以串在一起形成复合逻辑表达式，使用了一种称为麦卡锡评估方法，任意一个元素为真，那么整个表达式为真。

x1 or x2 or x3 or … xn

def f(n):
	return n

f(0) or f(False) or f(1) or f(2) or f(3)
-> f(0) = 0 
-> f(False) = False
-> f(1) = 1
1

and 复合表达式

多个逻辑运算符和操作数可以串在一起形成复合逻辑表达式，如果 xi 中的全部为真，则此表达式为真。

x1 and x2 and  x3 and  … xn

def f(n):
	return n

f(1) and f(False) and f(2) and f(3)
-> f(1) = 1
-> f(False) = False
False

f(1) and f(0.0) and f(2) and f(3)
-> f(1) = 1
-> f(0.0) = 0.0
0.0

f(1) and f(2.2) and f('data')
-> f(1) = 1
-> f(2.2) = 2.2
-> f(data) = data
'data'

短路评估

用于惯用模式利用短路评估来简洁表达避免异常操作。

定义了两个变量a和b，进行判断。

# 常规操作
a = 3
b = 1
(b / a) > 0
True

# 意外情况，解释器引发异常
a = 0
b = 1
(b / a) > 0
Traceback (most recent call last):
  File "<pyshell#2>", line 1, in <module>
    (b / a) > 0
ZeroDivisionError: division by zero

# 可以使用这样的表达式来避免错误
a = 0
b = 1
a != 0 and (b / a) > 0
False

# 更简洁的表达方式
a = 0
b = 1
a and (b / a) > 0
0

定义默认值方法，指定值为零或空时选择默认值。

s = string or '<default_value>'

# string为非空，则为真
string = 'data'
s = string or '<default_value>'
s
'data'

# string是一个空字符串，则为假
string = ''
s = string or '<default_value>'
s
'<default_value>'

链式比较

比较运算符可以链接到任意长度。

x < y <= z
# 等价于
x < y and y <= z

x < f() <= z
# 等价于
x < f() and f() <= z

位运算符

位运算符将操作数视为二进制数字序列并逐位对它们进行操作。

符号	表达式	含义	符号说明
&	a & b	按位与	按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0
|	a | b	按位或	按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。
~	~a	按位否定	按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1 。
^	a ^ b	按位异或（异或）	按位异或运算符：当两对应的二进位相异时，结果为1
>>	a >> n	右移 n 位置	右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数
<<	a << n	左移 n 位置	左移动运算符：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0。

# 0b1010 = 10
# 0b1100 = 12

'0b{:04b}'.format(0b1100 & 0b1010)
'0b1000'
'0b{:04b}'.format(0b1100 | 0b1010)
'0b1110'
'0b{:04b}'.format(0b1100 ^ 0b1010)
'0b0110'
'0b{:04b}'.format(0b1100 >> 2)
'0b0011'
'0b{:04b}'.format(0b0011 << 2)
'0b1100'

身份运算符

Python 提供了两个运算符 is 和 is not，它们确定给定的操作数是否具有相同的标识，即引用相同的对象。与相等不同，这意味着两个操作数引用包含相同数据但不一定是相同对象的对象。

x = 1001
y = 1000 + 1
print(x, y)
1001 1001

x == y
True
x is y
False

# 虽然值相等 但是引用对象不一样
id(x)
2643115955696
id(y)
2643115956944

运算符优先级

Python 运算符的优先顺序，从低到高。

符号	符号描述
or	布尔或
and	布尔与
not	布尔非
==, !=, <, <=, >, >=, is,is not	比较，身份
|	按位或
^	按位异或
&	按位与
<<,>>	位移
+,-	加法，减法
*, /, //,%	乘法、除法、除法、取模
+x, -x,~x	一元正，一元否定，按位否定
**	求幂

2 * 3 ** 4 * 5
810

括号中的表达式总是首先执行。

20 + 4 * 10
60

(20 + 4) * 10
240

无用的括号。

(a < 10) and (b > 30)
# 等价于
a < 10 and b > 30

增广赋值运算符

赋值右侧的值是包含其他变量的表达式是完全可行。

a = 10
b = 20
c = a * 5 + b
c
70

a = 10
a = a + 5
a
15

b = 20
b = b * 3
b
60

错误的用法，使用变量之前并为赋值。

z = z / 12
Traceback (most recent call last):
  File "<pyshell#11>", line 1, in <module>
    z = z / 12
NameError: name 'z' is not defined

简写方式。

简写	标准写法
a += 5	a = a + 5
a /= 10	a = a / 10
a ^= b	a = a ^ b