python濃縮（5）數字

詳細介紹每一種數字類型，適用的各類運算符, 及用於處理數字的內建函數。

5.1 數字類型

數字提供了標量貯存和直接訪問。它是不可更改類型，也就是說變動數字的值會生成新的對象。

Python 支持多種數字類型：整型、長整型、布爾型、雙精度浮點型、十進制浮點型和複數。

如何建立數值對象並用其賦值

anInt = 1

如何更新數字對象

經過給數字對象（從新）賦值， 您能夠「更新」一個數值對象。實際上你並無更新該對象的原始數值。由於數值對象是不可改變對象。Python的對象模型與常規對象模型有些不一樣。更新其實是生成了一個新的數值對象，並獲得它的引用。

在Python 中， 變量更像一個指針指向裝變量值的盒子。 對不可改變類型來講， 你沒法改變盒子的內容， 但你能夠將指針指向一個新盒子。每次將另外的數字賦給變量的時候，實際上建立了一個新的對象並把它賦給變量.(不只僅是數字，對於全部的不可變類型，都是這麼回事)

如何刪除數字對象

你沒法真正刪除一個數值對象， 你僅僅是再也不使用它而已。若是你實際上想刪除一個數值對象的引用， 使用 del 語句（參見3.5.6 小節）。若是試圖使用一個已經被刪除的對象引用， 會引起NameError 異常。

del anInt
del aLong, aFloat, aComplex

5.2 整型

Python 有幾種整數類型。布爾類型是隻有兩個值的整型。常規整型是絕大多數現代系統都能識別的整型。Python 也有長整數類型。然而，它表示的數值大小遠超過C 語言的長整數 。

5.2.1 布爾型

該類型的取值範圍只有兩個值，布爾值True和布爾值False。

5.2.2 標準整數類型

Python 的標準整數類型是最通用的數字類型。

在大多數32 位機器上，標準整數類型的取值範圍是-231 到231-1，也就是-2,147,483,648 到 2,147,483,647；

若是在 64 位機器上使用 64 位編譯器編譯Python，那麼在這個系統上的整數將是64 位；

下面是一些Python 標準整數類型對象的例子：0101 84 -237 0x80 017 -680 -0X92

Python 標準整數類型等價於C 的（有符號）長整型。整數通常以十進制表示，可是Python也支持八進制或十六進制來表示整數。若是八進制整數以數字「0」開始， 十六進制整數則以「0x」 或「0X」 開始。

5.2.3 長整型

不要將python的長整型和C 或其它編譯型語言的長整數類型混淆。那些語言的長整數典型的取值範圍是32 或64 位。Python 的長整數類型能表達的數值僅僅與你的機器支持的(虛擬)內存大小有關， 既Python 能輕鬆表達很大很大很大的整數。

長整數類型是標準整數類型的超集， 當你的程序須要使用比標準整數類型更大的整數時，長整數類型就有用武之地了。在一個整數值後面加個L（大寫或小寫均可以），表示這個整數是長整數。這個整數能夠是十進制，八進制， 或十六進制。下面是一些長整數的例子：

16384L -0x4E8L 017L -2147483648l 052144364L
299792458l 0xDECADEDEADBEEFBADFEEDDEAL -5432101234L

核心風格：用大寫字母 「L」表示長整數

目前整型和長整型正在逐漸緩慢的統一，您只有在對長整數調用repr()函數時纔有機會看到「L」，若是對長整數對象調用str()函數就看不到 L 。舉例以下：

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

5.2.4 整型和長整型的統一

這兩種整數類型正在逐漸統一爲一種。

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

移除這個錯誤是第一步。 下一步修改位移位； 左移比特致使出界（致使0 值）在過去是常常可能發生的事;

>>> 2 << 32
0

在Python2.3 中， 這個操做產生一個警告， 不過在2.4 版裏移除了這個 Warning， 而且這步操做生成了一個真正的長整數。

Python 2.3
>>> 2 << 32
__main__:1: FutureWarning: x<<y losing bits or changing sign will return a long
in Python 2.4
and up
0
Python 2.4
>>> 2 << 32
8589934592L

不遠的未來，至少普通用戶會幾乎感受不到長整型的存在。必要時整型會悄悄自動轉換爲長整型。固然，那些要調用C 的人仍然能夠繼續使用這兩種整數類型， 由於C 代碼必須區分不一樣的整數類型。

若是你想詳細瞭解標準整型與長整型整合的信息，請閱讀PEP237.

5.3 雙精度浮點數

Python 中的浮點數相似C 語言中的double 類型， 是雙精度浮點數，能夠用直接的十進制或科學計數法表示。每一個浮點數佔8 個字節（64 比特），徹底遵照IEEE754 號規範（52M/11E/1S），其中52 個比特用於表示底，11 個比特用於表示指數（可表示的範圍大約是正負10 的308.25次方）， 剩下的一個比特表示符號。這看上去至關完美，然而，實際精度依賴於機器架構和建立Python 解釋器的編譯器。

浮點數值一般都有一個小數點和一個可選的後綴e(大寫或小寫，表示科學計數法)。在e和指數之間能夠用正（+）或負（-）表示指數的正負（正數的話能夠省略符號）。下面是一些典型的浮點數值的例子：

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

5.4 複數

在好久之前，數學家們被下面這樣的等式困擾。

x2 = -1

一個實數和一個虛數的組合構成一個複數。一個複數是一對有序浮點數(x, y)。表示爲 x + yj， 其中x 是實數部分，y 是虛數部分。

下面是Python 語言中有關複數的幾個概念：

􀁺 虛數不能單獨存在，它們老是和一個值爲 0.0 的實數部分一塊兒來構成一個複數。

􀁺 複數由實數部分和虛數部分構成

􀁺 表示虛數的語法： real+imagj

􀁺 實數部分和虛數部分都是浮點數

􀁺 虛數部分必須有後綴j 或J。

下面是一些複數的例子：

64.375+1j 4.23-8.5j 0.23-8.55j 1.23e-045+6.7e+089j
6.23+1.5j -1.23-875J 0+1j 9.80665-8.31441J -.0224+0j

5.4.1 複數的內建屬性

複數對象擁有數據屬性， 分別爲該複數的實部和虛部。複數還擁有conjugate 方法， 調用它能夠返回該複數的共軛複數對象。

• num.real 該複數的實部

• num num.imag 該複數的虛部

• num.conjugate() 返回該複數的共軛複數

>>> aComplex = -8.333-1.47j
>>> aComplex
(-8.333-1.47j)
>>> aComplex.real
-8.333
>>> aComplex.imag
-1.47
>>> aComplex.conjugate()
(-8.333+1.47j)

5.5 運算符

數值類型可進行多種運算。從標準運算符到數值運算符，甚至還有專門的整數運算符。

5.5.1 混合模式運算符

當兩個整數相加時， + 號表示整數加法， 當兩個浮點數相加時， + 表示浮點數加法， 依此類推。在Python 中， 甚至非數字類型也可使用 + 運算符。舉例來講， 字符串A + 字符串B 並不表示加法操做， 它表示的是把這兩個字符串鏈接起來， 生成一個新的字符串。 這也體現了重載概念的具體應用。

Python 支持不一樣的數字類型相加。當一個整數和一個浮點數相加時， 系統會決定使用整數加法仍是浮點數加法（實際上並不存在混合運算）。Python 使用數字類型強制轉換的方法來解決數字類型不一致。這種操做不是隨意進行的， 它遵循如下基本規則：當兩個操做數類型不一致時， Python 去檢查一個操做數是否能夠轉換爲另外一類型的操做數。若是能夠，轉換它並返回轉換結果。因爲某些轉換是不可能的，好比果將一個複數轉換爲非複數類型， 將一個浮點數轉換爲整數等等，所以轉換過程必須遵照幾個規則。

要將一個整數轉換爲浮點數，只要在整數後面加個 .0 就能夠了。 要將一個非複數轉換爲複數，則只須要要加上一個 「0j」 的虛數部分。這些類型轉換的基本原則是： 整數轉換爲浮點數， 非複數轉換爲複數。 在Python 語言這樣描述coerce() 方法：

􀁺 若是有一個操做數是複數， 另外一個操做數被轉換爲複數。

􀁺 不然，若是有一個操做數是浮點數， 另外一個操做數被轉換爲浮點數。

􀁺 不然, 若是有一個操做數是長整數，則另外一個操做數被轉換爲長整數；

􀁺 不然，二者必然都是普通整數，無須類型轉換。

不過在確實須要明確指定對某種數據類型進行特殊類型轉換的場合，Python 提供了 coerce() 內建函數來幫助你實現這種轉換。

5.5.2 標準類型運算符

上文中提到的混合模式運算， 在運算以前，Python 內部會將兩個操做數轉換爲同一數據類型。

下面是一些數字標準運算的例子：

>>> 5.2 == 5.2
True
>>> -719 >= 833
False
>>> 5+4e >= 2-3e
True
>>> 2 < 5 < 9 # same as ( 2 < 5 ) and ( 5 < 9 )
True
>>> 77 > 66 == 66 # same as ( 77 > 66 ) and ( 66 == 66 )
True
>>> 0. < -90.4 < 55.3e2 != 3 < 181
False
>>> (-1 < 1) or (1 < -1)
True

5.5.3 算術運算符

Python 支持單目運算符正號（+）和負號（－）， 雙目運算符， +，－，*，/，%，還有 ** ，分別表示加法，減法， 乘法， 除法， 取餘， 和冪運算。整除運算符 // 。

除法

• 對整數操做數，會執行「地板除」（floor，取比商小的最大整數）；

• 對浮點操做數會執行真正的除法；

在將來的Python 版本中，/ 的行爲將變動爲真正的除法， 會增長一種新的運算來表示地板除。

下面咱們總結一下Python 如今的除法規則， 以及將來的除法規則：

傳統除法

若是是整數除法， 傳統除法會捨去小數部分，返回一個整數（地板除）。若是操做數之一是浮點數，則執行真正的除法。

真正的除法

除法運算老是返回真實的商， 無論操做數是整數仍是浮點數。在將來版本的Python 中，這將是除法運算的標準行爲。現階段經過執行 from __future__ import division 指令：

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

地板除

一個新的運算符 // 已經被增長進來， 以執行地板除： // 除法無論操做數何種數值類型，老是捨去小數部分，返回數字序列中比真正的商小的最接近的數字。

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

def velocity(distance, totalTime):
    rate = distance / totalTime

你可能會說， 只要有一個參數爲浮點數這個函數就能正常工做。像上面提到的那樣，要確保它能正常工做須要強制將參數轉換爲浮點類型， 也就是 rate = float(distance) / float(totalTime)。未來除法將變動爲真正的除法，上面的代碼能夠無需更改正常工做。須要地板除的地方只須要改變爲兩個連續的除號。

是的， 代碼會受到一些影響， Python 團隊已經創做了一系列腳本幫助你轉換舊代碼，以確保它能適應新的除法行爲。並且對那些強烈須要某種除法行爲的人來講， Python 解釋器提供了 Qdivision_style 啓動參數。 －Qnew 執行新的除法行爲， -Qold 則執行傳統除法行爲（默認爲Qold）。你也能夠幫助你的用戶使用-Qwarn 或 –Qwarnall 參數度過過渡時期。

表5.2 總結了除法運算符在不一樣Python 版本中的行爲差別。

取餘

整數取餘至關容易理解， 浮點數取餘就略複雜些。對於複數,取餘的定義相似於浮點數,不一樣之處在於商僅取其實數部分,即:x - (math.floor((x/y).real) * y)。

冪運算

冪運算操做符和一元操做符之間的優先級關係比較特別: 冪運算操做符比其左側操做數的一元操做符優先級低,比起右側操做數的一元操做符的優先級高,因爲這個特性你會在算術運算符表中找到兩個** .eg:

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

第2 種狀況下解釋器先計算 3**2 再取其相反數,咱們須要給"-3"加上括號來獲得咱們但願的結果。最後一個例子，結果是4**(-1),這是按照規定的優先級得到的結果.

>>> 4 ** -1
Traceback (innermost last):
File "<stdin>", line 1, in ?
ValueError: integer to the negative power

總結

表5.3 總結了全部的算術運算符， 從上到下， 計算優先級依次下降。 這裏列出的全部

運算符都比即將在5.5.4 小節講到的位運算符優先級高。

下面是更多Python 數值運算的例子：

>>> -442 - 77
-519
>>>
>>> 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

注意指數運算符的優先級高於鏈接實部和虛部的+號運算符。就上面最後一個例子來講， 咱們人爲的加上了括號，這就改變運算順序， 從而獲得咱們想要的結果。

5.5.4 *位運算符（只適用於整數）

Python 整數支持標準位運算：取反(~)，按位 與(&), 或(|) 及 異或(^) 及左移(<<)和右移(>>)。Python 這樣處理位運算：

􀁺 負數會被當成正數的 2 進制補碼處理。

􀁺 左移和右移 N 位等同於無溢出檢查的2 的N 次冪運算： 2**N。

􀁺 對長整數來講, 位運算符使用一種經修改的 2 進制補碼形式，使得符號位能夠無限的向左擴展。

取反(~)運算的優先級與數字單目運算符相同， 是全部位操做符中優先級最高的一個。 左移和右移運算的優先級次之，但低於加減法運算。與， 或， 異或 運算優先級最低。全部位運算符按優先級高低列在表 5.4 中。

表5.4 整型位運算符

位運算符 功能

~num 單目運算，對數的每一位取反。結果爲

num1 << num2 Num1 左移 num2 位

num1 >> num2 Num1 右移 num2 位

num1 & num2 num1 與 num2 按位與

num1 ^ num2 num1 異或 num2

num1 | num2 num1 與 num2 按位或

下面是幾個使用整數30(011110)，45(101101)，60(111100)進行位運算的例子：

>>> 30 & 45
12
>>> 30 | 45
63
>>> 45 & 60
44
>>> 45 | 60
61
>>> ~30
-31
>>> ~45
-46
>>> 45 << 1
90
>>> 60 >> 2
15
>>> 30 ^ 45
51

5.6 內建函數與工廠函數

5.6.1 標準類型函數

在上一章中， 咱們介紹了 cmp(), str() 和 type() 內建函數。 這些函數能夠用於全部的標準類型。

>>> cmp(-6, 2)
-1
>>> cmp(-4.333333, -2.718281828)
-1
>>> cmp(0xFF, 255)
0
>>> str(0xFF)
'255'
>>> str(55.3e2)
'5530.0'
>>> type(0xFF)
<type 'int'>
>>> type(98765432109876543210L)
<type 'long'>
>>> type(2-1j)
<type 'complex'>

5.6.2 數字類型函數

轉換工廠函數

函數 int(), long(), float() 和 complex() 用來將其它數值類型轉換爲相應的數值類型。

• 從Python1.5 版本開始， 這些函數也接受字符串參數， 返回字符串所表示的數值；

• 從Python1.6 版開始，int() 和 long() 在轉換字符串時，接受一個進制參數，若是是數字類型之間的轉換，則這個進制參數不能使用；

• 從Python2.2 起， 有了第五個內建函數 bool()。它用來將整數值1 和0 轉換爲標準布爾值 True 和False.

因爲Python 2.2 對類型和類進行了整合（這裏指Python 的傳統風格類和新風格類）， 全部這些內建函數如今都轉變爲工廠函數。所謂工廠函數就是指這些內建函數都是類對象， 當你調用它們時，其實是建立了一個類實例。eg：

>>> 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)

表5.5 數值工廠函數總結

功能函數

Python 有五個運算內建函數用於數值運算： abs(), coerce(), divmod(), pow(), pow()和 round()。

abs()

abs()返回給定參數的絕對值。若是參數是一個複數， 那麼就返回math.sqrt(num.real2 +num.imag2)。下面是幾個abs()函數的示例：

>>> abs(-1)
1
>>> abs(10.)
10.0
>>> abs(1.2-2.1j)
2.41867732449
>>> abs(0.23 - 0.78)
0.55

coerce()

儘管從技術上講它是一個數據類型轉換函數，不過它的行爲更像一個運算符。函數coerce()爲程序員提供了不依賴Python 解釋器， 而是自定義兩個數值類型轉換的方法。

‍對一種新建立的數值類型來講， 這個特性很是有用。函數coerce一個包含類型轉換完畢的兩個數值元素的元組。下面是幾個例子：‍

>>> coerce(1, 2)
(1, 2)
>>> coerce(1.3, 134L)
(1.3, 134.0)
>>>
>>> coerce(1, 134L)
(1L, 134L)
>>>
>>> coerce(1j, 134L)
(1j, (134+0j))
>>>
>>> coerce(1.23-41j, 134L)
((1.23-41j), (134+0j))

divmod()

divmod()內建函數把除法和取餘運算結合起來, 返回一個包含商和餘數的元組。

對整數來講， 它的返回值就是地板除和取餘操做的結果；

對浮點數來講， 返回的商部分是math.floor(num1/num2)；

對複數來講， 商部分是ath.floor((num1/num2).real)；

>>> divmod(10,3)
(3, 1)
>>> divmod(3,10)
(0, 3)
>>> divmod(10,2.5)
(4.0, 0.0)
>>> divmod(2.5,10)
(0.0, 2.5)
>>> divmod(2+1j, 0.5-1j)
(0j, (2+1j))

pow()

函數 pow() 和雙星號 （**） 運算符均可以進行指數運算。不過兩者的區別並不只僅在於一個是運算符，一個是內建函數。

內建函數pow()還接受第三個可選的參數，一個餘數參數。若是有這個參數的， pow() 先進行指數運算，而後將運算結果和第三個參數進行取餘運算。這個特性主要用於密碼運算，而且比 pow(x,y) % z 性能更好， 這是由於這個函數的實現相似於C 函數 pow(x,y,z)。

>>> pow(2,5)
32
>>>
>>> pow(5,2)
25
>>> pow(3.141592,2)
9.86960029446
>>>
>>> pow(1+1j, 3)
(-2+2j)

round()

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

>>> round(3)
3.0
>>> round(3.45)
3.0
>>> round(3.4999999)
3.0
>>> round(3.4999999, 1)
3.5
>>> import math
>>> for eachNum in range(10):
... print round(math.pi, eachNum)
...
3.0
3.1
3.14
3.142
3.1416
3.14159
3.141593
3.1415927
3.14159265
3.141592654
3.1415926536
>>> round(-3.5)
-4.0
>>> round(-3.4)
-3.0
>>> round(-3.49)
-3.0
>>> round(-3.49, 1)
-3.5

值得注意的是 round() 函數是按四捨五入的規則進行取整。也就是round(0.5)獲得1，round(-0.5)獲得－1。猛一看 int(), round(), math.floor() 這幾個函數好像作的是同一件事， 下面列出它們之間的不一樣之處：

• 函數 int()直接截去小數部分。（返回值爲整數）

• 函數 floor()獲得最接近原數但小於原數的整數。（返回值爲浮點數）

• 函數 round()獲得最接近原數的整數。（返回值爲浮點數）

以下例子用四個正數和四個負數做爲這三個函數的參數，將返回結果列在一塊兒作個比較：

>>> import math
>>> for eachNum in (.2, .7, 1.2, 1.7, -.2, -.7, -1.2, -1.7):
... print "int(%.1f)\t%+.1f" % (eachNum, float(int(each-
Num)))
... print "floor(%.1f)\t%+.1f" % (eachNum,
... math.floor(eachNum))
... print "round(%.1f)\t%+.1f" % (eachNum, round(eachNum))
... print '-' * 20
...
int(0.2) +0.0
floor(0.2) +0.0
round(0.2) +0.0
--------------------
int(0.7) +0.0
floor(0.7) +0.0
round(0.7) +1.0
--------------------
int(1.2) +1.0
floor(1.2) +1.0
round(1.2) +1.0
--------------------
int(1.7) +1.0
floor(1.7) +1.0
round(1.7) +2.0
--------------------
int(-0.2) +0.0
floor(-0.2) -1.0
round(-0.2) +0.0
--------------------
int(-0.7) +0.0
floor(-0.7) -1.0
round(-0.7) -1.0
--------------------
int(-1.2) -1.0
floor(-1.2) -2.0
round(-1.2) -1.0
--------------------
int(-1.7) -1.0
floor(-1.7) -2.0
round(-1.7) -2.0

5.6.3 僅用於整數的函數

除了適應於全部數值類型的內建函數以外，Python 還提供一些僅適用於整數的內建函數（標準整數和長整數）。這些函數分爲兩類，一類用於進制轉換，另外一類用於ASCII 轉換。

進制轉換函數

Python 還提供了兩個內建函數來返回字符串表示的8 進制和16 進制整數。它們分別是 oct()和 hex()。它們都接受一個整數（任意進制的）對象，並返回一個對應值的字符串對象。eg：

>>> hex(255)
'0xff'
>>> hex(23094823l)
'0x1606627L'
>>> hex(65535*2)
'0x1fffe'
>>> oct(255)
'0377'
>>> oct(23094823l)
'0130063047L'
>>> oct(65535*2)
'0377776'

ASCII 轉換函數

Python 也提供了ASCII碼與其序列值之間的轉換函數。每一個字符對應一個惟一的整數（0－255）。函數chr()接受一個單字節整數值，返回一個字符串，其值爲對應的字符。函數ord()則相反，它接受一個字符，返回其對應的整數值。

>>> ord('a')
97
>>> ord('A')
65
>>> ord('0')
48
>>> chr(97)
'a'
>>> chr(65L)
'A'
>>> chr(48)
'0'

表5.7 僅適用於整數的內建函數

5.7 其餘數字類型

5.7.1 布爾「數」

• 儘管布爾值看上去是「True」 和「False，可是事實上是整型的子類，對應與整數的1 和0：

• 有兩個永不改變的值 True 或False。

• 布爾型是整型的子類，可是不能再被繼承而生成它的子類。

• 沒有__nonzero__()方法的對象的默認值是 True。

• 對於值爲零的任何數字或空集（空列表、空元組和空字典等）在Python 中的布爾值都是False。

• 在數學運算中，Boolean 值的True 和False 分別對應於1 和 0。

• 之前返回整數的大部分標準庫函數和內建布爾型函數如今返回布爾型。

• True 和False 如今都不是關鍵字，可是在Python 未來的版本中會是。

全部Python 對象都有一個內建的True 或False 值，下面是使用內建類型布爾值的一些例子：

# intro
>>> bool(0) 
False
>>> bool('0') 
True
>>> bool([]) 
False
>>> bool ( (1,) ) 
True
# 使用布爾數
>>> foo = 42
>>> bar = foo < 100
>>> bar
True
>>> print bar + 100
101
>>> print '%s' % bar
True
>>> print '%d' % bar
1
# 無 __nonzero__()
>>> class C: pass
>>> c = C()
>>> bool(c) 
True
>>> bool(C) 
True
# 重載 __nonzero__() 使它返回 False
>>> class C:
... def __nonzero__(self):
... return False
...
>>> c = C()
>>> bool(c) 
False
>>> bool(C) 
True
# 哦，別這麼幹!! (不管如何不要這麼幹！)
>>> True, False = False, True
>>> bool(True) False

5.7.2 十進制浮點數

從Python2.4 起（參閱PEP327）十進制浮點製成爲一個Python 特性。這主要是由於下面的語句常常會讓一些編寫科學計算或金融應用程序的程序員抓狂：

>>> 0.1
0.1000000000000001
爲何會這樣？這是由於語言絕大多數C 語言的雙精度實現都遵照IEEE 754 規範，其中52 位用於底。所以浮點值只能有52 位精度，相似這樣的值的二進制表示只能象上面那樣被截斷。0.1 的二進制表示是0.11001100110011 . . .
由於最接近的二進制表示就是.0001100110011...或 1/16 +1/32 + 1/256 + . . .
你能夠看到，這些片段不停的重複直到舍入出錯。若是咱們使用十進制來作一樣的事情，感受就會好不少，看上去會有任意的精度。注意下面，你不能混用十進制浮點數和普通的浮點數。你能夠經過字符串或其它十進制數建立十進制數浮點數。你必須導入 decimal 模塊以便使用 Decimal 類：
>>> from decimal import Decimal
>>> dec = Decimal(.1)
Traceback (most recent call last): File "<stdin>", line 1, in ?
File "/usr/local/lib/python2.4/decimal.py", line 523, in __new__
raise TypeError("Cannot convert float to Decimal. " +
TypeError: Cannot convert float to Decimal. First convert the float to
a string
>>> dec = Decimal('.1')
>>> dec
Decimal("0.1")
>>> print dec
0.1
>>> dec + 1.0
Traceback (most recent call last): File "<stdin>", line 1, in ?
File "/usr/local/lib/python2.4/decimal.py", line 906, in __add__
other = _convert_other(other)
File "/usr/local/lib/python2.4/decimal.py", line 2863, in
_convert_other
raise TypeError, "You can interact Decimal only with int, long or
Decimal data types."
TypeError: You can interact Decimal only with int, long or Decimal data types.
>>>
>>> dec + Decimal('1.0') Decimal("1.1")
>>> print dec + Decimal('1.0')
1.1

你能夠從 Python 文檔中讀取相關的 PEP 以瞭解十進制數。值得慶幸的是，十進制數和其它數值類型同樣， 可使用一樣的算術運算符。因爲十進制數本質上是一種用於數值計算的特殊類， 咱們在本章的剩餘部分將再也不專門講解十進制數。

5.8 相關模塊

在Python 標準庫中有很多專門用於處理數值類型對象的模塊，它們加強並擴展了內建函數的功能和數值運算的功能。 表5.8 列出了幾個比較核心的模塊。

對高級的數字科學計算應用來講，你會對著名的第三方包 Numeric(NumPy) 和SciPy 感興趣。關於這兩個包的詳細請訪問下面的網址。

http://numeric.scipy.org/

http://scipy.org/

表5.8 數字類型相關模塊

核心模塊: random

當你的程序須要隨機數功能時，random 模塊就能派上用場。該模塊包含多個僞隨機數發生器，它們均以當前的時間戳爲隨機數種子。這樣只要載入這個模塊就能隨時開始工做。下面列出了該模塊中最經常使用的函數：

兩個整數參數，返回兩者之間的隨機整數

• randrange() 它接受和 range() 函數同樣的參數， 隨機返回range([start,]stop[,step])結果的一項

• uniform() 幾乎和 randint()同樣，不過它返回的是兩者之間的一個浮點數(不包括範圍上限)。

• random() 相似 uniform() 只不過下限恆等於0.0，上限恆等於1.0

• choice() 隨機返回給定序列（關於序列，見第六章）的一個元素

到這兒，咱們的 Python 數值類型之旅就該結束了。

表5.9 總結了數值類型的全部內建函數和運算符。