21.Python算术运算符及用法详解

算术运算符是处理四则运算的符号，在数字的处理中应用得最多。Python 支持所有的基本算术运算符，如表 1 所示。

表 1 Python常用算术运算符

运算符	说明	实例	结果
+	加	12.45 + 15	27.45
-	减	4.56 - 0.26	4.3
*	乘	5 * 3.6	18.0
/	除	7 / 2	3.5
%	取余，即返回除法的余数	7 % 2	1
//	整除，返回商的整数部分	7 // 2	3
**	幂，即返回 x 的 y 次方	2 ** 4	16，即 24

接下来将对表 1 中各个算术运算符的用法逐一讲解。

+ 加法运算符

例如如下代码：

1. a = 5.2
2. b = 3.1
3. the_sum = a + b
4. # sum的值为8.3
5. print("the_sum的值为：", the_sum)

除此之外，“+”还可以作为字符串（包括后续要介绍的序列）的连接运算符。例如如下代码：

1. s1 = 'Hello, '
2. s2 = 'Charlie'
3. # 使用+连接两个字符串
4. print(s1 + s2)

- 减法运算符

例如如下代码：

1. c = 5.2
2. d = 3.1
3. sub = c - d
4. # sub的值为2.1
5. print("sub的值为：", sub)

此外，“-”除了可以作为减法运算符之外，还可以作为求负的运算符。请看如下代码：

1. # 定义变量x，其值为-5.0
2. x = -5.0
3. # 将x求负，其值变成5.0
4. x = -x
5. print(x)

但单目运算符“+”则不对操作数做任何改变，例如如下代码：

1. # 定义变量y，其值为-5.0
2. y = -5.0
3. # y值依然是-5.0
4. y = +y
5. print(y)

＊乘法运算符

例如如下代码：

1. e = 5.2
2. f = 3.1
3. multiply = e * f
4. # multiply的值为16.12
5. print("multiply的值为：", multiply)

此外，“＊”还可以作为字符串（包括后续要介绍的序列）的连接运算符，表示将 N 个字符串连接起来。例如如下代码：

1. s3 = 'crazyit '
2. # 使用*将5个字符串连接起来
3. print(s3 * 5)

上面代码将会输出：

crazyit crazyit crazyit crazyit crazyit

/ 和 // 除法运算符

Python 的除法运算符有两个：“/”表示普通除法，使用它除出来的结果与平常数学计算的结果是相同的（即除不尽时，会产生小数部分）；而“//”表示整除，使用它除出来的结果只有整数部分，小数部分将会被舍弃。

记住，在 Python 3.x 中，除法运算的结果都是浮点类型。

例如如下代码：

1. print("19/4的结果是:", 19/4)
2. print("19//4的结果是:", 19//4)
3. aa = 5.2
4. bb = 3.1
5. # aa / bb的值将是1.67741935483871
6. print("aa/bb的值是:", aa / bb)
7. # aa // bb值将是1.0
8. print("aa//bb的值是:", aa // bb)

此外，Python 不允许使用 0 作为除数，否则将会引发 ZeroDivisionError 错误。

在有些编程语言中，0 作为除数会得到无穷大，包括正无穷大或负无穷大。

对于 Python 2.x 而言，它只提供了一个“/”运算符，该运算符是 Python 3.x 中“/”和“//”的综合版。对于 Python 2.x 中的“/”而言，它既是整除运算符，也是非整除运算符。规则如下：

• 当两个操作数都是整数时，Python 2.x 中的“/”就是整除运算符。
• 当两个操作数有一个是浮点数（或两个都是浮点数）时，Python 2.x 中的“/”就是非整除运算符。

例如，在 Python 2.x 的交互式解释执行器中执行如下代码：

>>>print(5/2)
2
>>>print(5.0/2)
2.5
>>>print(5/2.0)
2.5
>>>print(5.0/2.0)
2.5

% 求余运算符

Python 不要求求余运算符的两个操作数都是整数，Python 的求余运算符完全支持对浮点数求余。求余运算的结果不一定总是整数，它是使用第一个操作数来除以第二个操作数，得到一个整除的结果后剩下的值就是余数。

由于求余运算也需要进行除法运算，因此求余运算的第二个操作数不能是 0，否则程序会报出 ZeroDivisionError 错误。

例如如下程序：

1. print("5%3的值为：", 5 % 3) # 输出2
2. print("5.2%3.1的值为：",5.2 % 3.1) # 输出2.1
3. print("-5.2%-3.1的值为：", -5.2 % -3.1) # 输出-2.1
4. print("5.2%-2.9的值为：", 5.2 % -2.9) # 输出-0.6
5. print("5.2%-1.5的值为：", 5.2 % -1.5) # 输出-0.8
6. print("-5.2%1.5的值为：", -5.2 % 1.5) # 输出0.8
7. #print("5对0.0求余的结果是:", 5 % 0.0) # 导致错误

这里需要注意的一点是，使用 % 求余，如果除数（第二个操作数）是负数，那么取得的结果也一定是负数。因此，运行上面程序，可以看到如下输出结果：

5%3的值为： 2
5.2%3.1的值为： 2.1
-5.2%-3.1的值为： -2.1
5.2%-2.9的值为： -0.5999999999999996
5.2%-1.5的值为： -0.7999999999999998
-5.2%1.5的值为： 0.7999999999999998

前三个算式的运行结果比较简单，它们进行的都是很简单的求余计算。但 5.2 % -2.9 的结果有点奇怪，我们预计它为 -0.6，但实际输出的是 -0.5999999999999996。这里有两个问题：

1. 第一个问题，为什么预计 5.2 % 2.9 的结果是 -0.6 呢？因为 Python 求余运算的逻辑是用被除数减去除数的 N 倍，此处的 N 是 -2，因此得到结果是 0.6。
2. 第二个问题，为什么实际输出的是 -0.5999999999999996 呢？这是由浮点数的存储机制导致的。计算机底层的浮点数的存储机制并不是精确保存每一个浮点数的值，读者暂时不需要花太多的时间去理解浮点数的存储机制，只要知道浮点数在 Python 中可能产生精度丢失的问题就行。比如此处正常计算的结果应该是 -0.6，但实际计算出来的结果是一个非常接近 -0.6 的值。

** 乘方运算符

Python 支持使用“**”作为乘方运算符，这是一个使用非常方便的运算符。由于开方其实是乘方的逆运算，因此实际上使用“**”也可进行开方运算。例如如下代码：

纯文本复制

1. print('5 的 2 次方：', 5 ** 2) # 25
2. print('4 的 3 次方：', 4 ** 3) # 64
3. print('4 的开平方：', 4 ** 0.5) # 2.0
4. print('27 的开 3 次方：',27 **(1 / 3 )) # 3.0