目錄

軟體環境

• 系統
  
  • CentOS 7
• 軟體
  
  • Python 2.7.5
  • IPython 5.0.0

Python變數呼叫的過程

In [44]: anInt = 1

In [45]: anInt
Out[45]: 1

1. 通過變數名 anInt 得到資料物件的引用值 id(anInt) (即得到資料物件在記憶體中的索引地址)
2. 再通過 id(anInt) 得到資料物件在記憶體中存放的的值 1
3. 最終將變數 anInt 的值 1 調用出來。

注：步驟1. 2.對程式設計師而言是透明的。

數值型

• 數值型
  
  • 布林型 Bool
  • 標準整型 Integral
  • 長整形
  • 浮點型 Float
  • 複數

數值型資料型別，又稱之為數字型。他們適用於各類操作符(EG. 算術/移位/邏輯/…)和用於處理數字的內建函式(EG. abs()/pow()/round()/divmod()/…)。
數值型是一種不可變型別，也就是說改變一個數值型變數的值會生成一個新的資料物件。當然，這個過程對用程式設計師而言是透明的，但是理解不可變型別的原理，可以更深入的理解Python的賦值實現。

不可變型別：在Python中，變數就像是一個指標。它指向裝著變數值(資料物件)的盒子(資料物件佔用的記憶體空間)。對於不可變型別物件來說，我們無法改變盒子的內容，但可以將指標指向另外一個盒子。每次將另外的數字賦給變數時，實際上是建立了一個新的資料物件並將指標重新指向這個新的資料物件。

刪除一個數值型別物件

在Python中，我們無法真正的刪除一個數值型別物件，但是我們可以不再使用它。——使用del語句來刪除數值型別物件的引用。刪除數值型物件的引用之後，我們就不能再使用這個引用(變數名)了，除非你再給它賦一個新的值，否則會觸發NameError。

其本質是：在Python中，所有型別的資料物件都應該存在一個與之對應的引用(變數名)，倘若這個引用沒有對應任何的資料物件時，Python的垃圾回收機制就會自動的將這個引用回收。從而使一個引用失效並節省記憶體空間。

語法：del variableName

布林型 Bool

布林型資料物件的取值範圍只有兩個值：True | False

在Python中所有存在於具有判斷語義的語句中(EG. if/while/elif)的表示式的最終結果都可以用布林值來表示，這是由類中的_nonzero()函式決定的。

類的nonzero()函式用於將類轉換為布林型別(EG. bool(ClassName))。通常在用類進行判斷和將類轉換成布林型別時呼叫。比如語句if A(): print 'foo'中就會呼叫A().__nonzero__()的返回值來進行判斷。下面這個程式應該能幫助你理解nonzero()的作用:

class A:

    def __nonzero__(self):           #過載了 __nonzero__(self) 函式
        print 'A._nonzero__()'
        return True

if A():                        #隱式型別轉換 bool(A())，相當於a = A(); a.__nonzero__();返回為True
    print 'A is not zero'  
else:
    print 'A is zero'

print bool(A())

OUTPUT:

A._nonzero__()
A is not zero
A._nonzero__()
True

• 所有存在於具有判斷語義的語句中(EG. if/while/elif)的表示式的最終都會隱式的執行Bool型別轉換，EG. bool(表示式結果)

• bool()的本質是呼叫了物件所屬類中的__nonzero__()函式，而且只要物件的值不為Null，那麼__nonzero__() == True，反正為False。

即：表示式的最終結果要麼為True，要麼為False。也正因如此，表示式常用於符合判斷語義的語句中。

注意：建立布林值型別變數時，首字母要大寫。

標準整型 Int

之所以稱之為標準整型，是因為除此之外Python還具有長整型。

標準整型佔用的位數：
1. 在32為OS平臺上使用32位編譯器的話，Int佔用32位，取值範圍是-2**31 ~ 2**31-1
2. 在64位OS平臺上使用64位編譯器的話，Int佔用64位，取值範圍是-2**63 ~ 2**63-1

標準整型Int是一種不可變型別：

In [9]: num = 1

In [10]: num = 2

注意：num = 1; num = 2 兩個語句中並不是指的同一個資料物件。第一條語句中的num指向資料物件的Value為 1 ，此時num的引用為資料物件在記憶體中儲存位置的索引地址；第二條句子中的num則表示Value為 2 的資料物件在記憶體中儲存位置的索引地址。

在上面的兩次賦值過程中，1、2 兩個Vlaue對應的資料物件在記憶體中並沒有任何的改變。本質上只是改變了變數 num 的引用(所指向的記憶體地址)。所以說Int型別是一種不可變型別(因為資料物件沒有改變)。Int型別資料物件的值在記憶體中並不會發生改變，但可以改變變數的引用。

長整型

Python的長整型與C/C++等編譯型語言的長整型有本質的區別，因為Python長整型的取值範圍不是固定的，它僅僅與你的PC支援的(虛擬)記憶體大小有關。這樣的話，Python能夠輕鬆的表達一個很大的整型。但是就目前的情況來看，標準整型和長整型有了合併的趨勢。

在Python 2.2之前，標準整型資料物件超出了取值範圍時會出現溢位ERROR，現在如果還出現溢位的話會被Python解析器自動的被捕獲並隱式的將標準整型轉換為長整型物件。

在一個整型數字後面加L|l標識一個長整型的數值型別物件。

In [3]: aLong = -999999999999999999999L

In [4]: type(aLong)
Out[4]: long

雙精度浮點型 Float

雙精度浮點型，簡稱浮點型，類似C中的Double Float。浮點型資料型別物件佔用64位記憶體空間，有十進位制(.)和科學記數法(e)兩種表示方式。

In [51]: floatTest
Out[51]: 3.141592

In [52]: floatTest = 3.14159299999999999999999999999999999999999

In [53]: floatTest
Out[53]: 3.141593

上面的例子可以看出Python中float型別的資料同樣有著儲存限制(8Byte)。

複數

Python還支援複數資料型別，一個實數和一個虛數的組合構成一個複數。一個複數是一對有序浮點型(x,y)，表示為 x + yj，其中x為實數部分，y為虛數部分。
注意：實數部分和虛數部分都是浮點型。

In [48]: pulralTest = 3+6j

In [49]: pulralTest
Out[49]: (3+6j)

數值型別物件的內建功能函式

下列介紹的所有函式都是數值型物件都能夠使用的內建功能函式

abs(Number) 求Number的絕對值

abs(…)
abs(number) -> number
Return the absolute value of the argument.

abs()返回給定引數的絕對值：

In [6]: abs(-1)
Out[6]: 1

In [7]: abs(10.)
Out[7]: 10.0

In [8]: abs(0.23 - 0.78)
Out[8]: 0.55

coerce(x, y) 將x, y轉換為同一種數值型別

coerce(…)
coerce(x, y) -> (x1, y1)
Return a tuple consisting of the two numeric arguments converted to a common type, using the same rules as used by arithmetic operations. If coercion is not possible, raise TypeError.

將x, y轉換為同一種數值型別：
如果有一個運算元是複數， 另一個運算元被轉換為複數。
否則，如果有一個運算元是浮點數， 另一個運算元被轉換為浮點數。
否則, 如果有一個運算元是長整數，則另一個運算元被轉換為長整數。
否則，兩者必然都是普通整數，無須型別轉換 。

>>> coerce(1.23-41j, 134)
((1.23-41j), (134+0j)) 

>>> coerce(1j, 134L)
(1j, (134+0j))

>>> coerce(1.3, 134L)
(1.3, 134.0)

>>> coerce(1, 134L)
(1L, 134L)

>>> coerce(1, 2)
(1, 2)

divmod(x, y) 除法-取餘運算的結合

divmod(…)
divmod(x, y) -> (quotient, remainder)
Return the tuple ((x-x%y)/y, x%y). Invariant: div*y + mod == x.

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)
((-0+0j), (2+1j))

地板除 // ：//除法不管運算元是什麼數值型別，其得到的商總會捨去小數部分，並取數字序列中比真正的商小且最接近的值。

>>>1//2  
0  
>>>1.0//2  
0  
>>>-1//2.0  
-1  

pow() 指數運算，或將結果取餘

pow(…)
pow(x, y[, z]) -> number
With two arguments, equivalent to x**y. With three arguments,
equivalent to (x**y) % z, but may be more efficient (e.g. for longs).

pow()內建函式和( )操作符，都能夠進行指數運算。但是pow()還附加了一個取餘引數，來進行取餘運算：**

EG. pow(2,5,3) ==> 2 ** 5 % 3

而且pow(2,5,3)的效率要高於pow(2,5) % 3。這個特性常用於密碼運算。

round() 浮點型的四捨五入運算和求精度

round(…)
round(number[, ndigits]) -> floating point number
Round a number to a given precision in decimal digits (default 0 digits).
This always returns a floating point number. Precision may be negative.

rouund()內建函式提供了一個可斷的[, ndigits]引數，如果不傳遞這個引數，則函式返回與number引數最接近的浮點型物件。如果傳遞了這個引數，則返回指定number引數精度的浮點型值：
注意：rount()內建函式是按照四捨五入的規則進行取整(但返回值仍是浮點型物件)

In [10]: round(3.45)
Out[10]: 3.0

In [11]: round(-3.5)
Out[11]: -4.0

In [12]: round(-3.4)
Out[12]: -3.0

In [13]: round(3.499999999999,1)
Out[13]: 3.5

In [14]: round(3.499999999999,0)
Out[14]: 3.0

int()/math.floor()/round() 之間的區別：
1. int():直接截去小數部分(返回整型物件)
2. floor():得到最接近原數但會小於原數的整數(返回值為浮點型物件)
3. round():得到最接近原數的整數(返回浮點型物件)

EXAMPLE:

In [19]: import math

In [20]: for eachNum in (.2, .7, 1.2, 1.7, -.2, -.7, -1.2, -1.7):
    ...:     print "int(%.1f)\t%+.1f" % (eachNum,float(int(eachNum)))
    ...:     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
--------------------

僅用於整型物件的函式

進位制轉換函式
八進位制：oct()
十六進位制：hex()

ASCII轉換函式
chr()：接收一個整型值，返回一個其值對應的字元。

In [22]: chr(97)
Out[22]: 'a'

ord(): 接收一個字元，返回其對應的整型值。

In [23]: ord('a')
Out[23]: 97

數值型相關模組推薦

• 對高階的數字科學計算應用來說，你會對下面兩個第三方包感興趣

  • NumPy
  • SciPy

• 模組

  • devimal — 十進位制浮點運算類
  • array — 高效數值陣列
  • math/cmath — 標準C庫數學運算函式
  • random — 多種偽隨機數生成器 * 常用