1.2　除法

用单独一个章节来说明除法，就是因为它常常会带来麻烦，不仅Python会这样，很多高级语言都如此。

1.2.1　整数与整数相除

进入Python交互模式之后，练习下面的运算：

  1. >>> 2 / 5
  2. 0
  3. >>> 2.0 / 5
  4. 0.4
  5. >>> 2 / 5.0
  6. 0.4
  7. >>> 2.0 / 5.0
  8. 0.4

看到了吗？麻烦出来了（这是在Python 2.x中），按照数学运算，以上四个运算结果都应该是0.4。但我们看到第一个结果居然是0。Why？

在Python（严格说是Python 2.x中，Python3会有所变化）里面有一个规定，像2/5这样的除法要取整（就是去掉小数，但不是四舍五入）。2除以5，商是0（整数），余数是2（整数）。如果用这种形式：2/5，那么计算结果就是商那个整数。或者可以理解为：整数除以整数，结果是整数（商）。

比如：

  1. >>> 5 / 2
  2. 2
  3. >>> 7 / 2
  4. 3
  5. >>> 8 / 2
  6. 4

再次提醒：得到是商（整数），而不是得到含有小数位的结果再通过“四舍五入”得到整数。例如：5/2，得到的商是2，余数是1，最终5/2=2，并不是对结果进行四舍五入得到3。

1.2.2　浮点数与整数相除

“浮点数与整数相除”用一种貌似严格的语言表述：

假设：x除以y。其中x可能是整数，也可能是浮点数；y可能是整数，也可能是浮点数，但两者之中至少有一个是浮点数。

出结论之前，还是先在交互模式中做实验：

  1. >>> 9.0 / 2
  2. 4.5
  3. >>> 9 / 2.0
  4. 4.5
  5. >>> 9.0 / 2.0
  6. 4.5
  7. >>> 8.0 / 2
  8. 4.0
  9. >>> 8 / 2.0
  10. 4.0
  11. >>> 8.0 / 2.0
  12. 4.0

就如同做物理、化学实验一样，仔细观察上面的实验结果，能得出什么结论？

不管是被除数还是除数，只要有一个数是浮点数，结果就是浮点数。

然而，下面的实验可能又让你有点糊涂了：

  1. >>> 10.0 / 3
  2. 3.3333333333333335

这个是不是就有点搞怪了？按照数学知识，应该是3.33333…，后面是3的循环了，那么你的计算机就停不下来了，满屏都是3。为了避免这个，Python武断终结了循环，但是，可悲的是没有按照“四舍五入”的原则终止。当然，还会有更奇葩的出现：

  1. >>> 0.1 + 0.2
  2. 0.30000000000000004
  3. >>> 0.1 + 0.1 - 0.2
  4. 0.0
  5. >>> 0.1 + 0.1 + 0.1 - 0.3
  6. 5.551115123125783e-17
  7. >>> 0.1 + 0.1 + 0.1 - 0.2
  8. 0.10000000000000003

越来越糊涂了，为什么Computer姑娘在计算这么简单的问题上，如此糊涂了呢？

不是Computer姑娘糊涂，她依然冰雪聪明。

原因在于十进制和二进制的转换上，Computer姑娘用的是二进制进行计算，上面的例子中，我们输入的是十进制，就要把十进制的数转化为二进制，然后再计算。但是，在转化中，浮点数转化为二进制，就出问题了。

例如十进制的0.1，转化为二进制是：0.0001100110011001100110011001100110011001100110011…

也就是说，转化为二进制后，不会精确等于十进制的0.1。同时，计算机存储的位数是有限制的，所以，就出现了上述现象。

这种问题不仅仅在Python中有，所有支持浮点数运算的编程语言都会遇到。

明白了问题原因，怎么解决呢？就Python的浮点数运算而言，大多数计算机每次计算误差不超过2的53次方分之一。对于大多数任务这已经足够了，但是要在心中记住这不是十进制算法，每个浮点数计算可能会带来一个新的舍入错误。

一般情况下，只要简单地将最终显示的结果用“四舍五入”到所期望的十进制位数，就会得到期望的最终结果。

对于需要非常精确的情况，可以使用decimal模块（关于“模块”，后面会介绍，这里暂存），它实现的十进制运算适合高精度要求的应用。另外fractions模块支持另外一种形式的运算，它实现的运算基于有理数（因此像1/3这样的数字可以精确地表示）。最高要求则是使用由SciPy提供的Numerical Python包和其他用于数学和统计学的包。列出这些东西，仅仅是让读者明白，问题已经解决，并且方式很多。

1.2.3　引用模块解决除法问题

Python之所以受人欢迎，一个很重重要的原因就是“轮子”多，当然这是比喻，就好比你要跑得快，怎么办？光天天练习跑步也是不行的，还要用轮子。找辆自行车，就快了很多，若还嫌不够快，再换电瓶车、汽车、高铁……反正可以供你选择的很多。但是，这些让你跑得快的东西，多数不是你自己造的，是别人造好了你来用。甚至两条腿也是感谢父母恩赐。正是因为轮子多，可以选择的多，就可以有各种不同的速度享受了。

轮子是人类伟大的发明。

Python就是这样，有各种“轮子”供我们选用。只不过那些“轮子”在Python里面的名字不叫自行车、汽车，而叫“模块”，有的还叫作“库”、“类”。

怎么用？可以通过以下两种形式。

形式1：import module-name。import后面跟空格，然后是模块名称，例如：import os。

形式2：from module1 import module11。module1是一个大模块，里面还有子模块module11，只想用module11，就这么写。

找一个解决除法问题的轮子：

  1. >>> from __future__ import division
  2. >>> 5 / 2
  3. 2.5
  4. >>> 9 / 2
  5. 4.5
  6. >>> 9.0 / 2
  7. 4.5
  8. >>> 9 / 2.0
  9. 4.5

引用了模块之后再做除法，那么不管什么情况，都能得到浮点数的结果了。

这就是“轮子”的力量。

1.2.4　余数

前面计算5/2的时候，商是2，余数是1

余数怎么得到？在Python中（其实大多数语言也如此），用%符号来取得两个数相除的余数。

实验下面的操作：

  1. >>> 5 % 2
  2. 1
  3. >>> 6 % 4
  4. 2
  5. >>> 5.0 % 2
  6. 1.0

利用符号“%”可以得到两个数（可以是整数，也可以是浮点数）相除的余数。

除了利用“%”符号之外，还可以使用内建函数，完成同样的工作。

  1. >>> divmod(5,2)  #表示5除以2，返回了商和余数
  2. (2, 1)
  3. >>> divmod(9,2)
  4. (4, 1)
  5. >>> divmod(5.0,2)
  6. (2.0, 1.0)

内建函数divmod()返回的是两个值，这两个值在一个圆括号内，圆括号内的数字第一个表示商，第二个表示余数。

1.2.5　四舍五入

“四舍五入”在运算中是经常遇到的，按照我们已经对Python的理解，其应该提供一个简单的方法。的确是，有一个内建函数：round()。

  1. >>> round(1.234567, 2)
  2. 1.23
  3. >>> round(1.234567, 3)
  4. 1.235
  5. >>> round(10.0/3, 4)
  6. 3.3333

在round()中的第二个数，表示要保留的小数位数，返回值是一个四舍五入之后的数值。

简单吧？越简单的时候，越要小心，当你遇到下面的情况，就会有点儿怀疑：

  1. >>> round(1.2345,3)
  2. 1.234               #应该是：1.235
  3. >>> round(2.235,2)
  4. 2.23                #应该是：2.24

哈哈，我发现了Python的一个Bug，太激动了。

别那么激动，如果真的是Bug，还这么明显，是轮不到我的。为什么？具体解释看这里，下面摘录官方文档中的一段话：

Note:The behavior of round()for floats can be surprising:for example，round（2.675，2）gives 2.67 instead of the expected 2.68.This is not a bug:it’s a result of the fact that most decimal fractions can’t be represented exactly as a float.See Floating Point Arithmetic:Issues and Limitations for more information.

原来真的轮不到我。归根到底还是浮点数中的十进制转化为二进制惹的祸。

除法的问题似乎要到此结束了，其实远远没有，不过，作为初学者，至此即可。