詳解Python編程中基本的數(shù)學計算使用

在Python中，對數(shù)的規(guī)定比較簡單，基本在小學數(shù)學水平即可理解。
那么，做為零基礎學習這，也就從計算小學數(shù)學題目開始吧。因為從這里開始，數(shù)學的基礎知識列位肯定過關了。    

上面顯示的是在交互模式下，如果輸入 3，就顯示了 3，這樣的數(shù)稱為整數(shù)，這個稱呼和小學數(shù)學一樣。

如果輸入一個比較大的數(shù)，第二個，那么多個 3 組成的一個整數(shù)，在 Python 中稱之為長整數(shù)。為了表示某個數(shù)是長整數(shù)，Python 會在其末尾顯示一個L。其實，現(xiàn)在的 Python 已經能夠自動將輸入的很大的整數(shù)視為長整數(shù)了。你不必在這方面進行區(qū)別。

第三個，在數(shù)學里面稱為小數(shù)，這里你依然可以這么稱呼，不過就像很多編程語言一樣，習慣稱之為“浮點數(shù)”。至于這個名稱的由來，也是有點說道的，有興趣可以 google.

上述舉例中，可以說都是無符號（或者說是非負數(shù)），如果要表示負數(shù)，跟數(shù)學中的表示方法一樣，前面填上負號即可。

值得注意的是，我們這里說的都是十進制的數(shù)。

除了十進制，還有二進制、八進制、十六進制都是在編程中可能用到的，當然用六十進制的時候就比較少了（其實時間記錄方式就是典型的六十進制）。

具體每個數(shù)字，在 Python 中都是一個對象，比如前面輸入的 3，就是一個對象。每個對象，在內存中都有自己的一個地址，這個就是它的身份。    
>>> id(3)
140574872
>>> id(3.222222)
140612356
>>> id(3.0)
140612356
>>>

用內建函數(shù) id()可以查看每個對象的內存地址，即身份。

內建函數(shù)，英文為 built-in Function，讀者根據(jù)名字也能猜個八九不離十了。不錯，就是 Python 中已經定義好的內部函數(shù)。
以上三個不同的數(shù)字，是三個不同的對象，具有三個不同的內存地址。特別要注意，在數(shù)學上，3 和 3.0 是相等的，但是在這里，它們是不同的對象。

用 id()得到的內存地址，是只讀的，不能修改。

了解了“身份”，再來看“類型”，也有一個內建函數(shù)供使用type()。
    
>>> type(3)
<type 'int'>
>>> type(3.0)
<type 'float'>
>>> type(3.222222)
<type 'float'>

用內建函數(shù)能夠查看對象的類型。<type ‘int'>，說明 3 是整數(shù)類型（Interger）；<type ‘float'>則告訴我們那個對象是浮點型（Floating point real number）。與 id()的結果類似，type()得到的結果也是只讀的。

至于對象的值，在這里就是對象本身了。

看來對象也不難理解。請保持自信，繼續(xù)。

變量
僅僅寫出 3、4、5 是遠遠不夠的，在編程語言中，經常要用到“變量”和“數(shù)”（在 Python 中嚴格來講是對象）建立一個對應關系。例如：    
>>> x = 5
>>> x
5
>>> x = 6
>>> x
6

在這個例子中，x = 5就是在變量(x)和數(shù)(5)之間建立了對應關系，接著又建立了 x 與 6 之間的對應關系。我們可以看到，x 先“是”5，后來“是”6。

在 Python 中，有這樣一句話是非常重要的：對象有類型，變量無類型。怎么理解呢？

首先，5、6 都是整數(shù)，Python 中為它們取了一個名字，叫做“整數(shù)”類型的數(shù)據(jù)，或者說數(shù)據(jù)類型是整數(shù)，用 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 沒有類型之說，它不僅可以貼在整數(shù)類型的對象上，還能貼在其它類型的對象上，比如后面會介紹到的 str（字符串）類型的對象等等。

這是 Python 區(qū)別于一些語言非常重要的地方。

四則運算
按照下面要求，在交互模式中運行，看看得到的結果和用小學數(shù)學知識運算之后得到的結果是否一致
    
>>> 2+5
7
>>> 5-2
3
>>> 10/2
5
>>> 5*2
10
>>> 10/5+1
3
>>> 2*3-4
2

上面的運算中，分別涉及到了四個運算符號：加(+)、減(-)、乘(*)、除(/)

另外，我相信看官已經發(fā)現(xiàn)了一個重要的公理：

在計算機中，四則運算和小學數(shù)學中學習過的四則運算規(guī)則是一樣的

要不說人是高等動物呢，自己發(fā)明的東西，一定要繼承自己已經掌握的知識，別跟自己的歷史過不去。偉大的科學家們，在當初設計計算機的時候就想到列位現(xiàn)在學習的需要了，一定不能讓后世子孫再學新的運算規(guī)則，就用小學數(shù)學里面的好了。感謝那些科學家先驅者，澤被后世。

下面計算三個算術題，看看結果是什么
    
4 + 2
4.0 + 2
4.0 + 2.0

看官可能憤怒了，這么簡單的題目，就不要勞駕計算機了，太浪費了。

別著急，還是要運算一下，然后看看結果，有沒有不一樣？要仔細觀察哦。
    
>>> 4+2
6
>>> 4.0+2
6.0
>>> 4.0+2.0
6.0

不一樣的地方是：第一個式子結果是 6，這是一個整數(shù)；后面兩個是 6.0，這是浮點數(shù)。

定義 1：類似 4、-2、129486655、-988654、0 這樣形式的數(shù)，稱之為整數(shù)
定義 2：類似 4.0、-2.0、2344.123、3.1415926 這樣形式的數(shù)，稱之為浮點數(shù)
對這兩個的定義，不用死記硬背，google 一下。記住愛因斯坦說的那句話：書上有的我都不記憶（是這么的說？好像是，大概意思，反正我也不記憶）。后半句他沒說，我補充一下：忘了就 google。

似乎計算機做一些四則運算是不在話下的，但是，有一個問題請你務必注意：在數(shù)學中，整數(shù)是可以無限大的，但是在計算機中，整數(shù)不能無限大。為什么呢？（我推薦你去 google，其實計算機的基本知識中肯定學習過了。）因此，就會有某種情況出現(xiàn)，就是參與運算的數(shù)或者運算結果超過了計算機中最大的數(shù)了，這種問題稱之為“整數(shù)溢出問題”。

整數(shù)溢出問題
這里有一篇專門討論這個問題的文章，推薦閱讀：整數(shù)溢出

對于其它語言，整數(shù)溢出是必須正視的，但是，在 Python 里面，看官就無憂愁了，原因就是 Python 為我們解決了這個問題，請閱讀下面的拙文：大整數(shù)相乘

ok!看官可以在 IDE 中實驗一下大整數(shù)相乘。
    
>>> 123456789870987654321122343445567678890098876*1233455667789990099876543332387665443345566
152278477193527562870044352587576277277562328362032444339019158937017801601677976183816L

看官是幸運的，Python 解憂愁，所以，選擇學習 Python 就是珍惜光陰了。

上面計算結果的數(shù)字最后有一個 Ｌ，就表示這個數(shù)是一個長整數(shù)，不過，看官不用管這點，反正是 Python 為我們搞定了。

在結束本節(jié)之前，有兩個符號需要看官牢記（不記住也沒關系，可以隨時 google，只不過記住后使用更方便）

整數(shù)，用 int 表示，來自單詞：integer
浮點數(shù)，用 float 表示，就是單詞：float
可以用一個命令：type(object)來檢測一個數(shù)是什么類型。    
>>> type(4)
<type 'int'>  #4 是 int，整數(shù)
>>> type(5.0)
<type 'float'>　#5.0 是 float，浮點數(shù)
type(988776544222112233445566778899887766554433221133344455566677788998776543222344556678)
<type 'long'>  # 是長整數(shù)，也是一個整數(shù)

除法
除法啰嗦，不僅是 Python。

整數(shù)除以整數(shù)
進入 Python 交互模式之后（以后在本教程中，可能不再重復這類的敘述，只要看到>>>，就說明是在交互模式下），練習下面的運算：    
>>> 2 / 5
0
>>> 2.0 / 5
0.4
>>> 2 / 5.0
0.4
>>> 2.0 / 5.0
0.4

看到沒有？麻煩出來了（這是在 Python2.x 中），按照數(shù)學運算，以上四個運算結果都應該是 0.4。但我們看到的后三個符合，第一個居然結果是 0。why?

因為，在 Python（嚴格說是 Python2.x 中，Python3 會有所變化）里面有一個規(guī)定，像 2/5 中的除法這樣，是要取整（就是去掉小數(shù)，但不是四舍五入）。2 除以 5，商是 0（整數(shù)），余數(shù)是 2（整數(shù)）。那么如果用這種形式：2/5，計算結果就是商那個整數(shù)?；蛘呖梢岳斫鉃椋赫麛?shù)除以整數(shù)，結果是整數(shù)（商）。

比如：
    
>>> 5 / 2
2
>>> 7 / 2
3
>>> 8 / 2
4

注意：得到是商（整數(shù)）,而不是得到含有小數(shù)位的結果再通過“四舍五入”取整。例如：5/2，得到的是商 2，余數(shù) 1，最終5 / 2 = 2。并不是對 2.5 進行四舍五入。

浮點數(shù)與整數(shù)相除
這個標題和上面的標題格式不一樣，上面的標題是“整數(shù)除以整數(shù)”，如果按照風格一貫制的要求，本節(jié)標題應該是“浮點數(shù)除以整數(shù)”，但沒有，現(xiàn)在是“浮點數(shù)與整數(shù)相除”，其含義是：

假設：x 除以 y。其中 x 可能是整數(shù)，也可能是浮點數(shù)；y 可能是整數(shù)，也可能是浮點數(shù)。
出結論之前，還是先做實驗：
    
>>> 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

歸納，得到規(guī)律：不管是被除數(shù)還是除數(shù)，只要有一個數(shù)是浮點數(shù)，結果就是浮點數(shù)。所以，如果相除的結果有余數(shù)，也不會像前面一樣了，而是要返回一個浮點數(shù)，這就跟在數(shù)學上學習的結果一樣了。
    
>>> 10.0 / 3
3.3333333333333335

這個是不是就有點搞怪了，按照數(shù)學知識，應該是 3.33333...，后面是 3 的循環(huán)了。那么你的計算機就停不下來了，滿屏都是 3。為了避免這個，Python 武斷終結了循環(huán)，但是，可悲的是沒有按照“四舍五入”的原則終止。當然，還會有更奇葩的出現(xiàn)：
    
>>> 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 姑娘用的是二進制進行計算，上面的例子中，我們輸入的是十進制，她就要把十進制的數(shù)轉化為二進制，然后再計算。但是，在轉化中，浮點數(shù)轉化為二進制，就出問題了。

例如十進制的 0.1，轉化為二進制是：0.0001100110011001100110011001100110011001100110011...

也就是說，轉化為二進制后，不會精確等于十進制的 0.1。同時，計算機存儲的位數(shù)是有限制的，所以，就出現(xiàn)上述現(xiàn)象了。

這種問題不僅僅是 Python 中有，所有支持浮點數(shù)運算的編程語言都會遇到，它不是 Python 的 bug。

明白了問題原因，怎么解決呢？就 Python 的浮點數(shù)運算而言，大多數(shù)機器上每次計算誤差不超過 2**53 分之一。對于大多數(shù)任務這已經足夠了，但是要在心中記住這不是十進制算法，每個浮點數(shù)計算可能會帶來一個新的舍入錯誤。

一般情況下，只要簡單地將最終顯示的結果用“四舍五入”到所期望的十進制位數(shù)，就會得到期望的最終結果。

對于需要非常精確的情況，可以使用 decimal 模塊，它實現(xiàn)的十進制運算適合會計方面的應用和高精度要求的應用。另外 fractions 模塊支持另外一種形式的運算，它實現(xiàn)的運算基于有理數(shù)（因此像 1/3 這樣的數(shù)字可以精確地表示）。最高要求則可是使用由 SciPy 提供的 Numerical Python 包和其它用于數(shù)學和統(tǒng)計學的包。列出這些東西，僅僅是讓看官能明白，解決問題的方式很多，后面會用這些中的某些方式解決上述問題。

關于無限循環(huán)小數(shù)問題，我有一個鏈接推薦給諸位，它不是想象的那么簡單呀。請閱讀：維基百科的詞條：0.999...，會不會有深入體會呢？

補充一個資料，供有興趣的朋友閱讀：浮點數(shù)算法：爭議和限制
Python 總會要提供多種解決問題的方案的，這是她的風格。

引用模塊解決除法--啟用輪子
Python 之所以受人歡迎，一個很重重要的原因，就是輪子多。這是比喻啦。就好比你要跑的快，怎么辦？光天天練習跑步是不行滴，要用輪子。找輛自行車，就快了很多。還嫌不夠快，再換電瓶車，再換汽車，再換高鐵...反正你可以選擇的很多。但是，這些讓你跑的快的東西，多數(shù)不是你自己造的，是別人造好了，你來用。甚至兩條腿也是感謝父母恩賜。正是因為輪子多，可以選擇的多，就可以以各種不同速度享受了。

輪子是人類偉大的發(fā)明。

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

注意了，引用了一個模塊之后，再做除法，就不管什么情況，都是得到浮點數(shù)的結果了。

這就是輪子的力量。

余數(shù)
前面計算 5/2 的時候，商是 2，余數(shù)是 1

余數(shù)怎么得到？在 Python 中（其實大多數(shù)語言也都是），用%符號來取得兩個數(shù)相除的余數(shù).

實驗下面的操作：    
>>> 5 % 2
1
>>> 6%4
2
>>> 5.0%2
1.0

符號：%，就是要得到兩個數(shù)（可以是整數(shù)，也可以是浮點數(shù)）相除的余數(shù)。

前面說 Python 有很多人見人愛的輪子（模塊），她還有豐富的內建函數(shù)，也會幫我們做不少事情。例如函數(shù) divmod()
    
>>> divmod(5,2) # 表示 5 除以 2，返回了商和余數(shù)
(2, 1)
>>> divmod(9,2)
(4, 1)
>>> divmod(5.0,2)
(2.0, 1.0)

四舍五入
最后一個了，一定要堅持，今天的確有點啰嗦了。要實現(xiàn)四舍五入，很簡單，就是內建函數(shù)：round()

動手試試：    
>>> round(1.234567,2)
1.23
>>> round(1.234567,3)
1.235
>>> round(10.0/3,4)
3.3333