本文的主題是 Python 中的數(shù)字。會詳細介紹每一種數(shù)字類型，它們適用的各種運算符, 以及用于處理數(shù)字的內建函數(shù)。在文章的末尾， 簡單介紹了幾個標準庫中用于處理數(shù)字的模塊。

本文地址：http://www.cnblogs.com/archimedes/p/python-number.html，轉載請注明源地址。

數(shù)字類型

數(shù)字提供了標量貯存和直接訪問。它是不可更改類型，也就是說變更數(shù)字的值會生成新的對象。當然，這個過程無論對程序員還是對用戶都是透明的，并不會影響軟件的開發(fā)方式。 Python 支持多種數(shù)字類型：整型、長整型、布爾型、雙精度浮點型、十進制浮點型和復數(shù)。
創(chuàng)建數(shù)值對象并用其賦值
(數(shù)字對象)
創(chuàng)建數(shù)值對象和給變量賦值一樣同樣簡單：

>>> anInt=1 >>> along=-555555555555L >>> afloat=3.141595468565 >>> acomplex=1.334+4.5433j

更新數(shù)字對象
通過給數(shù)字對象（重新）賦值， 您可以“更新”一個數(shù)值對象。我們之所以給更新這兩個字加上引號，是因為實際上你并沒有更新該對象的原始數(shù)值。這是因為數(shù)值對象是不可改變對象。Python 的對象模型與常規(guī)對象模型有些不同。你所認為的更新實際上是生成了一個新的數(shù)值對象，并得到它的引用。 在學習編程的過程中， 我們一直接受這樣的教育，變量就像一個盒子， 里面裝著變量的值。在Python中，變量更像一個指針指向裝變量值的盒子。對不可改變類型來說，你無法改變盒子的內容，但你可以將指針指向一個新盒子。每次將另外的數(shù)字賦給變量的時候，實際上創(chuàng)建了一個新的對象并把它賦給變量.(不僅僅是數(shù)字，對于所有的不可變類型，都是這么回事)

anInt += 1 aFloat = 2.718281828

通過下面的代碼測試：

>>> anInt=1 >>> id(anInt) 10416152 >>> anInt+=1 >>> id(anInt) 10416140

如何刪除數(shù)字對象
按照Python的法則，你無法真正刪除一個數(shù)值對象，你僅僅是不再使用它而已。如果你實際上想刪除一個數(shù)值對象的引用，使用del語句。刪除對象的引用之后，你就不能再使用這個引用(變量名)， 除非你給它賦一個新值。如果試圖使用一個已經被刪除的對象引用，會引發(fā) NameError 異常。

del anInt del aLong, aFloat, aComplex

Python的四種主要數(shù)字類型

1.整型

Python 有幾種整數(shù)類型。布爾類型是只有兩個值的整型。常規(guī)整型是絕大多數(shù)現(xiàn)代系統(tǒng)都能識別的整型。Python 也有長整數(shù)類型。然而，它表示的數(shù)值大小遠超過C 語言的長整數(shù)。下面我們先來了解一下這些類型，然后再來研究那些用于Python整數(shù)類型的運算符和內建函數(shù)。

1.1 布爾型
Python 從版本 2.3 開始支持布爾類型。該類型的取值范圍只有兩個值，也就是布爾值 True和布爾值 False。?
1.2 標準整數(shù)類型
Python 的標準整數(shù)類型是最通用的數(shù)字類型。在大多數(shù)32位機器上，標準整數(shù)類型的取值范圍是-231到231-1，也就是-2,147,483,648到2,147,483,647。如果在64位機器上使用64位編譯器編譯Python，那么在這個系統(tǒng)上的整數(shù)將是 64 位。下面是一些 Python 標準整數(shù)類型對象的例子：
0101 84 -237 0x80 017 -680 -0X92
Python標準整數(shù)類型等價于C的（有符號）長整型。整數(shù)一般以十進制表示，但是 Python也支持八進制或十六進制來表示整數(shù)。如果八進制整數(shù)以數(shù)字“0”開始， 十六進制整數(shù)則以“0x”或“0X”開始。
1.3 長整型
關于Python長整數(shù)類型我們必須要提的是，請不要將它和C或其它編譯型語言的長整數(shù)類型混淆。那些語言的長整數(shù)典型的取值范圍是32位或64位。Python的長整數(shù)類型能表達的數(shù)值僅僅與你的機器支持的(虛擬)內存大小有關，換句話說，Python 能輕松表達很大很大很大的整數(shù)。長整數(shù)類型是標準整數(shù)類型的超集，當你的程序需要使用比標準整數(shù)類型更大的整數(shù)時，長整數(shù)類型就有用武之地了。在一個整數(shù)值后面加個 L（大寫或小寫都可以），表示這個整數(shù)是長整數(shù)。這個整數(shù)可以是十進制，八進制，或十六進制。下面是一些長整數(shù)的例子：
16384L -0x4E8L 017L -2147483648l 052144364L
299792458l 0xDECADEDEADBEEFBADFEEDDEAL -5432101234L
Edit By Vheavens
Edit By Vheavens
核心風格：用大寫字母 “L”表示長整數(shù)，目前整型和長整型正在逐漸緩慢的統(tǒng)一，您只有在對長整數(shù)調用repr()函數(shù)時才有機會看到“L”，如果對長整數(shù)對象調用 str()函數(shù)就看不到 L。舉例如下：

>>> aLong = 999999999l >>> aLong 999999999L >>> print aLong 999999999

1.4 整型和長整型的統(tǒng)一?

這兩種整數(shù)類型正在逐漸統(tǒng)一為一種。在 Python 2.2 以前，標準整數(shù)類型對象超出取值范圍會溢出（比如上面提到的大于 232 的數(shù)），但是從 Python2.2 以后就再也沒有這樣的錯誤了。

>>> 9999 ** 8 Traceback (most recent call last): File "<stdin>", line 1, in ? OverflowError: integer exponentiation Python 2.2 >>> 9999 ** 8 99920027994400699944002799920001L

雙精度浮點數(shù)

Python中的浮點數(shù)類似C語言中的double類型，是雙精度浮點數(shù)，可以用直接的十進制或科學計數(shù)法表示。每個浮點數(shù)占8個字節(jié)（64比特），完全遵守IEEE754號規(guī)范（52M/11E/1S），其中52個比特用于表示底，11個比特用于表示指數(shù)（可表示的范圍大約是正負 10 的 308.25次方），剩下的一個比特表示符號。這看上去相當完美，然而，實際精度依賴于機器架構和創(chuàng)建 Python 解釋器的編譯器。浮點數(shù)值通常都有一個小數(shù)點和一個可選的后綴e(大寫或小寫，表示科學計數(shù)法)。在e和指數(shù)之間可以用正（+）或負（-）表示指數(shù)的正負（正數(shù)的話可以省略符號）。下面是一些典型的浮點數(shù)值的例子：

0.0 -777. 1.6 -5.555567119 96e3 * 1.0 4.3e25 9.384e-23 -2.172818 float(12) 1.000000001 3.1416 4.2E-10 -90. 6.022e23 -1.609E-19

復數(shù)?

一個實數(shù)和一個虛數(shù)的組合構成一個復數(shù)。一個復數(shù)是一對有序浮點數(shù)(x, y)。表示為x + yj，其中x是實數(shù)部分，y是虛數(shù)部分。漸漸的復數(shù)在日常運算,機械,電子等行業(yè)獲得了廣泛的應用。由于一些研究人員不斷的重復制造用于復數(shù)運算的工具，在很久以前的Python1.4 版本里，復數(shù)終于成為一個真正的Python 數(shù)據(jù)類型。
下面是 Python 語言中有關復數(shù)的幾個概念：

• 虛數(shù)不能單獨存在，它們總是和一個值為 0.0 的實數(shù)部分一起來構成一個復數(shù)。

• 復數(shù)由實數(shù)部分和虛數(shù)部分構成

• 表示虛數(shù)的語法： real+imagj

• 實數(shù)部分和虛數(shù)部分都是浮點數(shù)

• 虛數(shù)部分必須有后綴j或J。

1.復數(shù)的內建屬性
復數(shù)對象擁有數(shù)據(jù)屬性，分別為該復數(shù)的實部和虛部。復數(shù)還擁有conjugate 方法，調用它可以返回該復數(shù)的共軛復數(shù)對象。

復數(shù)屬性
屬性 ? ? ? ? ? ? ? ? ? 描述
num.real ? ? ? ? ? ? 該復數(shù)的實部
num num.imag ? ? ? ? 該復數(shù)的虛部
num.conjugate() ? ? ?返回該復數(shù)的共軛復數(shù)

>>> c=2.3+2.5j >>> c.real 2.3 >>> c.imag 2.5 >>> c.conjugate() (2.3-2.5j)

運算符

數(shù)值類型可進行多種運算。從標準運算符到數(shù)值運算符，甚至還有專門的整數(shù)運算符。
5.5.1 混合模式運算符
Python支持不同的數(shù)字類型相加。當一個整數(shù)和一個浮點數(shù)相加時， 系統(tǒng)會決定使用整數(shù)加法還是浮點數(shù)加法（實際上并不存在混合運算）。Python使用數(shù)字類型強制轉換的方法來解決數(shù)字類型不一致的問題，也就是說它會強制將一個操作數(shù)轉換為同另一個操作數(shù)相同的數(shù)據(jù)類型。這種操作不是隨意進行的， 它遵循以下基本規(guī)則:?

首先，如果兩個操作數(shù)都是同一種數(shù)據(jù)類型，沒有必要進行類型轉換。僅當兩個操作數(shù)類型不一致時， Python才會去檢查一個操作數(shù)是否可以轉換為另一類型的操作數(shù)。如果可以，轉換它并返回轉換結果。

由于某些轉換是不可能的，比如果將一個復數(shù)轉換為非復數(shù)類型，將一個浮點數(shù)轉換為整數(shù)等等，因此轉換過程必須遵守幾個規(guī)則。要將一個整數(shù)轉換為浮點數(shù)，只要在整數(shù)后面加個.0就可以了。要將一個非復數(shù)轉換為復數(shù)，則只需要要加上一個 “0j”的虛數(shù)部分。

這些類型轉換的基本原則是： 整數(shù)轉換為浮點數(shù)，非復數(shù)轉換為復數(shù)。在 Python 語言參考中這樣描述coerce()方法：
如果有一個操作數(shù)是復數(shù)， 另一個操作數(shù)被轉換為復數(shù)。
否則，如果有一個操作數(shù)是浮點數(shù)， 另一個操作數(shù)被轉換為浮點數(shù)。
否則, 如果有一個操作數(shù)是長整數(shù)，則另一個操作數(shù)被轉換為長整數(shù)；
否則，兩者必然都是普通整數(shù)，無須類型轉換。
數(shù)字類型之間的轉換是自動進行的，程序員無須自己編碼處理類型轉換。Python 提供了 coerce() 內建函數(shù)來幫助你實現(xiàn)這種轉換。

參見下面的流程圖闡釋了強制轉換的規(guī)則：

算術運算符

Python 支持單目運算符正號（+）和負號（－）， 雙目運算符， +，－，*，/，%，還有 ** ，分別表示加法，減法，乘法，除法，取余，和冪運算。從 Python2.2 起，還增加了一種新的整除運算符//。

傳統(tǒng)除法
如果是整數(shù)除法， 傳統(tǒng)除法會舍去小數(shù)部分，返回一個整數(shù)（地板除）。如果操作數(shù)之一是浮點數(shù)，則執(zhí)行真正的除法。包括 Python 語言在內的很多語言都是這種行為。看下面的例子：

>>> 1 / 2 # perform integer result (floor) # 地板除 0 >>> 1.0 / 2.0 # returns actual quotient#真正除法 0.5

真正的除法?

除法運算總是返回真實的商，不管操作數(shù)是整數(shù)還是浮點數(shù)。在未來版本的 Python中，這將是除法運算的標準行為。現(xiàn)階段通過執(zhí)行from __future__ import division指令，也可以做到這一點。

>>> from __future__ import division >>> >>> 1 / 2 # returns real quotient 0.5 >>> 1.0 / 2.0 # returns real quotient 0.5

地板除

從Python 2.2開始，一個新的運算符//已經被增加進來，以執(zhí)行地板除：// 除法不管操作數(shù)何種數(shù)值類型，總是舍去小數(shù)部分，返回數(shù)字序列中比真正的商小的最接近的數(shù)字。

>>> 1 // 2 # floors result, returns integer # 地板除， 返回整數(shù) 0 >>> 1.0 // 2.0 # floors result, returns float # 地板除， 返回浮點數(shù) 0.0 >>> -1 // 2 # move left on number line# 返回比 –0.5 小的整數(shù)， 也就是 －1 -1

冪運算
冪運算操作符和一元操作符之間的優(yōu)先級關系比較特別:冪運算操作符比其左側操作數(shù)的一元操作符優(yōu)先級低,比起右側操作數(shù)的一元操作符的優(yōu)先級高,由于這個特性你會在算術運算符表中找到兩個** .下面舉幾個例子:

>>> 3 ** 2 9 >>> -3 ** 2 # ** 優(yōu)先級高于左側的 - -9 >>> (-3) ** 2 # 加括號提高 -的優(yōu)先級 9 >>> 4.0 ** -1.0 # ** 優(yōu)先級低于右側的 - 0.25

第2種情況下解釋器先計算3**2再取其相反數(shù),我們需要給"-3"加上括號來得到我們希望的結果。最后一個例子，結果是4**(-1),這是按照規(guī)定的優(yōu)先級獲得的結果.?

>>> 4 ** -1

Traceback (innermost last):?

File "<stdin>", line 1, in ?
ValueError: integer to the negative power
下面是更多 Python 數(shù)值運算的例子：?

>>> -442 - 77 -519 >>> Edit By Vheavens Edit By Vheavens >>> 4 ** 3 64 >>> >>> 4.2 ** 3.2 98.7183139527 >>> 8 / 3 2 >>> 8.0 / 3.0 2.66666666667 >>> 8 % 3 2 >>> (60. - 32.) * ( 5. / 9. ) 15.5555555556 >>> 14 * 0x04 56 >>> 0170 / 4 30 >>> 0x80 + 0777 639 >>> 45L * 22L 990L >>> 16399L + 0xA94E8L 709879L >>> -2147483648L - 52147483648L -54294967296L >>> 64.375+1j + 4.23-8.5j (68.605-7.5j) >>> 0+1j ** 2 # same as 0+(lj**2) (-1+0j) >>> 1+1j ** 2 # same as 1+(lj**2) 0j >>> (1+1j) ** 2 2j View Code

*位運算符（只適用于整數(shù)）

Python整數(shù)支持標準位運算：取反(~)，按位 與(&), 或(|) 及 異或(^) 及左移(<<)和右移(>>)。Python 這樣處理位運算：
負數(shù)會被當成正數(shù)的2進制補碼處理。
左移和右移N位等同于無溢出檢查的2的N次冪運算：2**N。
對長整數(shù)來說, 位運算符使用一種經修改的2進制補碼形式，使得符號位可以無限的向左擴展。取反(~)運算的優(yōu)先級與數(shù)字單目運算符相同，是所有位操作符中優(yōu)先級最高的一個。左移和右移運算的優(yōu)先級次之，但低于加減法運算。與，或，異或運算優(yōu)先級最低。所有位運算符按優(yōu)先級高低列在表 5.4

內建函數(shù)與工廠函數(shù)

標準類型函數(shù)
cmp(), str() 和 type()內建函數(shù)。這些函數(shù)可以用于所有的標準類型。對數(shù)字對象來說，這些函數(shù)分別比較兩個數(shù)的大小，將數(shù)字轉換為字符串，以及返回數(shù)字對象的類型。

轉換工廠函數(shù)
函數(shù) int(), long(), float() 和 complex() 用來將其它數(shù)值類型轉換為相應的數(shù)值類型。從Python2.3開始，Python 的標準數(shù)據(jù)類型添加了一個新成員：布爾（Boolean）類型。從此 true 和 false 現(xiàn)在有了常量值即 True 和 False(不再是1和0)

下面是一些使用內建函數(shù)的示例：

>>> int(4.25555) 4 >>> long(42) 42L >>> float(4) 4.0 >>> complex(4) (4+0j) >>>>>> complex(2.4, -8) (2.4-8j) >>> >>> complex(2.3e-10, 45.3e4) (2.3e-10+453000j)

功能函數(shù)
Python 有五個運算內建函數(shù)用于數(shù)值運算： abs(), coerce(), divmod(), pow(), pow() 和 round()。我們將對這些函數(shù)逐一瀏覽，并給出一些有用的例子：

abs()返回給定參數(shù)的絕對值。如果參數(shù)是一個復數(shù)，那么就返回 math.sqrt(num.real2 + num.imag2)

coerce()僅回一個包含類型轉換完畢的兩個數(shù)值元素的元組

divmod()內建函數(shù)把除法和取余運算結合起來, 返回一個包含商和余數(shù)的元組。對整數(shù)來說，它的返回值就是地板除和取余操作的結果。對浮點數(shù)來說，返回的商部分是math.floor(num1/num2)，對復數(shù)來說，商部分是ath.floor((num1/num2).real)。

>>> divmod(10, 3) (3, 1) >>> divmod(10, 2.5) (4.0, 0.0) >>> divmod(2.5, 10) (0.0, 2.5) >>> divmod(2+1j, 2.3+4.3j) (0j, (2+1j))

round()用于對浮點數(shù)進行四舍五入運算。它有一個可選的小數(shù)位數(shù)參數(shù)。如果不提供小數(shù)位參數(shù)，它返回與第一個參數(shù)最接近的整數(shù)（但仍然是浮點類型）。第二個參數(shù)告訴round 函數(shù)將結果精確到小數(shù)點后指定位數(shù)。

>>> round(3) 3.0 >>> round(3.154) 3.0 >>> round(3.499999, 1) 3.5>>> import math >>> for n in range(10):print round(math.pi, n)3.0 3.1 3.14 3.142 3.1416 3.14159 3.141593 3.1415927 3.14159265 3.141592654

數(shù)值運算內建函數(shù):

函數(shù) ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 功能
abs(num) ? ? ? ? ? ? ? ? ? 返回num 的絕對值
coerce(num1, num2) ? ? ? ? 將num1和num2轉換為同一類型，然后以一個元組的形式返回
divmod(num1, num2) ? ? ? ? 除法－取余運算的結合。返回一個元組(num1/num2,num1 % num2)。對浮點數(shù)和復數(shù)的商進行下舍入
pow(num1, num2, mod=1) ? ? 取num1 的num2次方，如果提供mod參數(shù)，則計算結果再對mod進行取余運算
round(flt, ndig=0) ? ? ? ? 接受一個浮點數(shù) flt 并對其四舍五入，保存 ndig位小數(shù)。若不提供ndig 參數(shù)，則默認小數(shù)點后0位
round() ? ? ? ? ? ? ? ? ? ?僅用于浮點數(shù)

僅適用于整數(shù)的內建函數(shù):?

函數(shù) ? ? ? ? ? ? ? ? ? ? 操作
hex(num) ? ? ? ? ? 將數(shù)字轉換成十六進制數(shù)并以字符串形式返回
oct(num) ? ? ? ? ? 將數(shù)字轉換成八進制數(shù)并以字符串形式返回
chr(num) ? ? ? ? ? 將ASCII值的數(shù)字轉換成ASCII字符，范圍只能是0 <= num <= 255?
ord(chr) ? ? ? ? ? 接受一個 ASCII 或 Unicode 字符（長度為1的字符串），返回相應的ASCII或Unicode值。
unichr(num) ? ? ? ?接受Unicode碼值，返回 其對應的Unicode字符。所接受的碼值范圍依賴于你的Python是構建于UCS‐2還是UCS‐4

?

轉載于:https://www.cnblogs.com/wuyudong/p/python-number.html

總結

以上是生活随笔為你收集整理的Python基础（10）--数字的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。