详解Python编程中基本的数学计算使⽤
在中，对数的规定⽐较简单，基本在⼩学数学⽔平即可理解。
那么，做为零基础学习这，也就从计算⼩学数学题⽬开始吧。因为从这⾥开始，数学的基础知识列位肯定过关了。
上⾯显⽰的是在交互模式下，如果输⼊ 3，就显⽰了 3，这样的数称为整数，这个称呼和⼩学数学⼀样。
如果输⼊⼀个⽐较⼤的数，第⼆个，那么多个 3 组成的⼀个整数，在 Python 中称之为长整数。为了表⽰某个数是长整数，Python 会在其末尾显⽰⼀个L。其实，现在的 Python 已经能够⾃动将输⼊的很⼤的整数视为长整数了。你不必在这⽅⾯进⾏区别。
第三个，在数学⾥⾯称为⼩数，这⾥你依然可以这么称呼，不过就像很多编程语⾔⼀样，习惯称之为“浮点数”。⾄于这个名称的由来，也是有点说道的，有兴趣可以 google.
上述举例中，可以说都是⽆符号（或者说是⾮负数），如果要表⽰负数，跟数学中的表⽰⽅法⼀样，前⾯填上负号即可。
值得注意的是，我们这⾥说的都是⼗进制的数。
除了⼗进制，还有⼆进制、⼋进制、⼗六进制都是在编程中可能⽤到的，当然⽤六⼗进制的时候就⽐较少了（其实时间记录⽅式就是典型的六⼗进制）。
具体每个数字，在 Python 中都是⼀个对象，⽐如前⾯输⼊的 3，就是⼀个对象。每个对象，在内存中都有⾃⼰的⼀个地址，这个就是它的⾝份。
>>> id(3)
140574872
>>> id(3.222222)
140612356
>>> id(3.0)
140612356
>>>
⽤内建函数 id()可以查看每个对象的内存地址，即⾝份。
内建函数，英⽂为 built-in Function，读者根据名字也能猜个⼋九不离⼗了。不错，就是 Python 中已经定义好的内部函数。
以上三个不同的数字，是三个不同的对象，具有三个不同的内存地址。特别要注意，在数学上，3 和 3.0 是相等的，但是在这⾥，它们是不同的对象。
⽤ id()得到的内存地址，是只读的，不能修改。
了解了“⾝份”，再来看“类型”，也有⼀个内建函数供使⽤type()。
>>> type(3)
>>> type(3.0)
>>> type(3.222222)
⽤内建函数能够查看对象的类型。，说明 3 是整数类型（Interger）；则告诉我们那个对象是浮点型（Floating point real number）。与 id()的结果类似，type()得到的结果也是只读的。
⾄于对象的值，在这⾥就是对象本⾝了。
看来对象也不难理解。请保持⾃信，继续。
变量
仅仅写出 3、4、5 是远远不够的，在编程语⾔中，经常要⽤到“变量”和“数”（在 Python 中严格来讲是对象）建⽴⼀个对应关系。例如：>>> x = 5
>>> x
5
>>> x = 6
>>> x
6
在这个例⼦中，x = 5就是在变量(x)和数(5)之间建⽴了对应关系，接着⼜建⽴了 x 与 6 之间的对应关系。我们可以看到，x 先“是”5，后
来“是”6。
在 Python 中，有这样⼀句话是⾮常重要的：对象有类型，变量⽆类型。怎么理解呢？
⾸先，5、6 都是整数，Python 中为它们取了⼀个名字，叫做“整数”类型的数据，或者说数据类型是整数，⽤ int 表⽰。
当我们在 Python 中写⼊了 5、6，computer 姑娘就⾃动在她的内存中某个地⽅给我们建⽴这两个对象（对象的定义后⾯会讲，这⾥你先⽤着，逐渐就明晰含义了），就好⽐建造了两个雕塑，⼀个是形状似 5，⼀个形状似 6，这就两个对象，这两个对象的类型就是 int.
那个 x 呢？就好⽐是⼀个标签，当x = 5时，就是将 x 这个标签拴在了 5 上了，通过这个 x，就顺延看到了 5，于是在交互模式中，>>> x输出的结果就是 5，给⼈的感觉似乎是 x 就是 5，事实是 x 这个标签贴在 5上⾯。同样的道理，当x = 6时，标签就换位置了，贴到 6 上⾯。
所以，这个标签 x 没有类型之说，它不仅可以贴在整数类型的对象上，还能贴在其它类型的对象上，⽐如后⾯会介绍到的 str（字符串）类型的对象等等。
这是 Python 区别于⼀些语⾔⾮常重要的地⽅。
四则运算
按照下⾯要求，在交互模式中运⾏，看看得到的结果和⽤⼩学数学知识运算之后得到的结果是否⼀致
>>> 2 5
7
>>> 5-2
3
>>> 10/2
5
>>> 5*2
10
>>> 10/5 1
3
>>> 2*3-4
2
上⾯的运算中，分别涉及到了四个运算符号：加( )、减(-)、乘(*)、除(/)
另外，我相信看官已经发现了⼀个重要的公理：
在计算机中，四则运算和⼩学数学中学习过的四则运算规则是⼀样的
要不说⼈是⾼等动物呢，⾃⼰发明的东西，⼀定要继承⾃⼰已经掌握的知识，别跟⾃⼰的历史过不去。伟⼤的科学家们，在当初设计计算机的时候就想到列位现在学习的需要了，⼀定不能让后世⼦孙再学新的运算规则，就⽤⼩学数学⾥⾯的好了。感谢那些科学家先驱者，泽被后世。
下⾯计算三个算术题，看看结果是什么
4 2
4.0 2
4.0 2.0
看官可能愤怒了，这么简单的题⽬，就不要劳驾计算机了，太浪费了。
别着急，还是要运算⼀下，然后看看结果，有没有不⼀样？要仔细观察哦。
>>> 4 2
6
>>> 4.0 2
6.0
>>> 4.0 2.0
6.0
不⼀样的地⽅是：第⼀个式⼦结果是 6，这是⼀个整数；后⾯两个是 6.0，这是浮点数。
定义 1：类似 4、-2、129486655、-988654、0 这样形式的数，称之为整数
定义 2：类似 4.0、-2.0、2344.123、3.1415926 这样形式的数，称之为浮点数
对这两个的定义，不⽤死记硬背，google ⼀下。记住爱因斯坦说的那句话：书上有的我都不记忆（是这么的说？好像是，⼤概意思，反正我也不记忆）。后半句他没说，我补充⼀下：忘了就 google。
似乎计算机做⼀些四则运算是不在话下的，但是，有⼀个问题请你务必注意：在数学中，整数是可以⽆限⼤的，但是在计算机中，整数不能⽆限⼤。为什么呢？（我推荐你去 google，其实计算机的基本知识中肯定学习过了。）因此，就会有某种情况出现，就是参与运算的数或者运算结果超过了计算机中最⼤的数了，这种问题称之为“整数溢出问题”。
整数溢出问题
这⾥有⼀篇专门讨论这个问题的⽂章，推荐阅读：整数溢出
对于其它语⾔，整数溢出是必须正视的，但是，在 Python ⾥⾯，看官就⽆忧愁了，原因就是 Python 为我们解决了这个问题，请阅读下⾯的拙⽂：⼤整数相乘
ok!看官可以在 IDE 中实验⼀下⼤整数相乘。
>>> 123456789870987654321122343445567678890098876*1233455667789990099876543332387665443345566 152278477193527562870044352587576277277562328362032444339019158937017801601677976183816L
看官是幸运的，Python 解忧愁，所以，选择学习 Python 就是珍惜光阴了。
上⾯计算结果的数字最后有⼀个Ｌ，就表⽰这个数是⼀个长整数，不过，看官不⽤管这点，反正是 Python 为我们搞定了。
在结束本节之前，有两个符号需要看官牢记（不记住也没关系，可以随时 google，只不过记住后使⽤更⽅便）
整数，⽤ int 表⽰，来⾃单词：integer
浮点数，⽤ float 表⽰，就是单词：float
可以⽤⼀个命令：type(object)来检测⼀个数是什么类型。
>>> type(4)
#4 是 int，整数
>>> type(5.0)
　#5.0 是 float，浮点数
type(988776544222112233445566778899887766554433221133344455566677788998776543222344556678)
# 是长整数，也是⼀个整数
除法
除法啰嗦，不仅是 Python。
整数除以整数
进⼊ Python 交互模式之后（以后在本教程中，可能不再重复这类的叙述，只要看到>>>，就说明是在交互模式下），练习下⾯的运算：>>> 2 / 5
>>> 2.0 / 5
0.4
>>> 2 / 5.0
0.4
>>> 2.0 / 5.0
0.4
看到没有？⿇烦出来了（这是在 Python2.x 中），按照数学运算，以上四个运算结果都应该是 0.4。但我们看到的后三个符合，第⼀个居然结果是 0。why?
因为，在 Python（严格说是 Python2.x 中，Python3 会有所变化）⾥⾯有⼀个规定，像 2/5 中的除法这样，是要取整（就是去掉⼩数，但不是四舍五⼊）。2 除以 5，商是 0（整数），余数是 2（整数）。那么如果⽤这种形式：2/5，计算结果就是商那个整数。或者可以理解为：整数除以整数，结果是整数（商）。
⽐如：
>>> 5 / 2
2
>>> 7 / 2
3
>>> 8 / 2
4
注意：得到是商（整数）,⽽不是得到含有⼩数位的结果再通过“四舍五⼊”取整。例如：5/2，得到的是商 2，余数 1，最终5 / 2 = 2。并不是对 2.5 进⾏四舍五⼊。
浮点数与整数相除
这个标题和上⾯的标题格式不⼀样，上⾯的标题是“整数除以整数”，如果按照风格⼀贯制的要求，本节标题应该是“浮点数除以整数”，但没有，现在是“浮点数与整数相除”，其含义是：
假设：x 除以 y。其中 x 可能是整数，也可能是浮点数；y 可能是整数，也可能是浮点数。
出结论之前，还是先做实验：
>>> 9.0 / 2
4.5
>>> 9 / 2.0
4.5
>>> 9.0 / 2.0
4.5
>>> 8.0 / 2
4.0
>>> 8 / 2.0
4.0
>>> 8.0 / 2.0
4.0
归纳，得到规律：不管是被除数还是除数，只要有⼀个数是浮点数，结果就是浮点数。所以，如果相除的结果有余数，也不会像前⾯⼀样了，⽽是要返回⼀个浮点数，这就跟在数学上学习的结果⼀样了。
>>> 10.0 / 3
3.3333333333333335
这个是不是就有点搞怪了，按照数学知识，应该是 ，后⾯是 3 的循环了。那么你的计算机就停不下来了，满屏都是 3。为了避免这个，Python 武断终结了循环，但是，可悲的是没有按照“四舍五⼊”的原则终⽌。当然，还会有更奇葩的出现：
>>> 0.1 0.2
0.30000000000000004
>>> 0.1 0.1 - 0.2
0.0
>>> 0.1 0.1 0.1 - 0.3
5.551115123125783e-17
>>> 0.1 0.1 0.1 - 0.2
0.10000000000000003
越来越糊涂了，为什么 computer 姑娘在计算这么简单的问题上，如此糊涂了呢？不是 computer 姑娘糊
涂，她依然冰雪聪明。原因在于⼗进制和⼆进制的转换上，computer 姑娘⽤的是⼆进制进⾏计算，上⾯的例⼦中，我们输⼊的是⼗进制，她就要把⼗进制的数转化为⼆进制，然后再计算。但是，在转化中，浮点数转化为⼆进制，就出问题了。
例如⼗进制的 0.1，转化为⼆进制是：
也就是说，转化为⼆进制后，不会精确等于⼗进制的 0.1。同时，计算机存储的位数是有限制的，所以，就出现上述现象了。
这种问题不仅仅是 Python 中有，所有⽀持浮点数运算的编程语⾔都会遇到，它不是 Python 的 bug。
明⽩了问题原因，怎么解决呢？就 Python 的浮点数运算⽽⾔，⼤多数机器上每次计算误差不超过 2**53 分之⼀。对于⼤多数任务这已经⾜够了，但是要在⼼中记住这不是⼗进制算法，每个浮点数计算可能会带来⼀个新的舍⼊错误。
⼀般情况下，只要简单地将最终显⽰的结果⽤“四舍五⼊”到所期望的⼗进制位数，就会得到期望的最终结果。
对于需要⾮常精确的情况，可以使⽤ decimal 模块，它实现的⼗进制运算适合会计⽅⾯的应⽤和⾼精度要求的应⽤。另外 fractions 模块⽀持另外⼀种形式的运算，它实现的运算基于有理数（因此像 1/3 这样
的数字可以精确地表⽰）。最⾼要求则可是使⽤由 SciPy 提供的Numerical Python 包和其它⽤于数学和统计学的包。列出这些东西，仅仅是让看官能明⽩，解决问题的⽅式很多，后⾯会⽤这些中的某些⽅式解决上述问题。
关于⽆限循环⼩数问题，我有⼀个链接推荐给诸位，它不是想象的那么简单呀。请阅读：的词条：，会不会有深⼊体会呢？
补充⼀个资料，供有兴趣的朋友阅读：浮点数算法：争议和限制
Python 总会要提供多种解决问题的⽅案的，这是她的风格。
引⽤模块解决除法--启⽤轮⼦
Python 之所以受⼈欢迎，⼀个很重重要的原因，就是轮⼦多。这是⽐喻啦。就好⽐你要跑的快，怎么办？光天天练习跑步是不⾏滴，要⽤轮⼦。辆⾃⾏车，就快了很多。还嫌不够快，再换电瓶车，再换汽车，再换⾼铁...反正你可以选择的很多。但是，这些让你跑的快的东西，多数不是你⾃⼰造的，是别⼈造好了，你来⽤。甚⾄两条腿也是感谢⽗母恩赐。正是因为轮⼦多，可以选择的多，就可以以各种不同速度享受了。
轮⼦是⼈类伟⼤的发明。
Python 就是这样，有各种轮⼦，我们只需要⽤。只不过那些轮⼦在 Python ⾥⾯的名字不叫⾃⾏车、汽车，叫做“模块”，有⼈承接别的语⾔的名称，叫做“类库”、“类”。不管叫什么名字吧。就是别⼈造好的东西我们拿过来使⽤。
怎么⽤？可以通过两种形式⽤：
形式 1：import module-name。import 后⾯跟空格，然后是模块名称，例如：import os
形式 2：from module1 import module11。module1 是⼀个⼤模块，⾥⾯还有⼦模块 module11，只想⽤ module11，就这么写了。不啰嗦了，实验⼀个：
>>> from __future__ import division
>>> 5 / 2
2.5
>>> 9 / 2
4.5
>>> 9.0 / 2
4.5
>>> 9 / 2.0
4.5
注意了，引⽤了⼀个模块之后，再做除法，就不管什么情况，都是得到浮点数的结果了。
这就是轮⼦的⼒量。
余数
前⾯计算 5/2 的时候，商是 2，余数是 1
余数怎么得到？在 Python 中（其实⼤多数语⾔也都是），⽤%符号来取得两个数相除的余数.
实验下⾯的操作：
>>> 5 % 2
1
>>> 6%4
2
python教程字符串函数>>> 5.0%2
1.0
符号：%，就是要得到两个数（可以是整数，也可以是浮点数）相除的余数。
前⾯说 Python 有很多⼈见⼈爱的轮⼦（模块），她还有丰富的内建函数，也会帮我们做不少事情。例如函数 divmod()
>>> divmod(5,2) # 表⽰ 5 除以 2，返回了商和余数
(2, 1)
>>> divmod(9,2)
(4, 1)
>>> divmod(5.0,2)
(2.0, 1.0)
四舍五⼊
最后⼀个了，⼀定要坚持，今天的确有点啰嗦了。要实现四舍五⼊，很简单，就是内建函数：round()
动⼿试试：
>>> round(1.234567,2)
1.23
>>> round(1.234567,3)
1.235
>>> round(10.0/3,4)
3.3333

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。