深入理解Python變量的數(shù)據(jù)類型和存儲

  我們知道，python的變量是有類型的，對于python變量的幾種數(shù)據(jù)類型，我們在寫python時是必須要有一定的概念的。知道數(shù)據(jù)類型就要知道變量數(shù)據(jù)類型怎么存儲，可是為什么python的變量不需要聲明數(shù)據(jù)類型就可以直接賦值？變量如果有數(shù)據(jù)類型，那變量不是可以為任意數(shù)據(jù)類型？那真正的數(shù)據(jù)類型如int在內(nèi)存存儲的字節(jié)大小應(yīng)該為多少？等等諸如一系列的問題讓我提起了的興趣，經(jīng)過網(wǎng)上不斷查找學(xué)習(xí)后，在此將我所了解到的內(nèi)容在此做個總結(jié)歸納

一、變量的數(shù)據(jù)類型

1、什么是變量的數(shù)據(jù)類型

  我們先捋一捋什么是變量，變量從字面上理解就是可以變化的量，我們可以隨時改變這個變量的值，使得我們可以調(diào)用同一個變量而獲得不同的值，與之對應(yīng)的是常量。那么對于一個可變的變量，它有可能表示是一個字符串，一個數(shù)字或者是一個小數(shù)，因為這些在計算機內(nèi)存里存放的方式是不一樣的，所以簡單理解就是變量的數(shù)據(jù)類型不同就是對應(yīng)的數(shù)據(jù)在計算機內(nèi)存中存放方式的不同。這種方式表現(xiàn)在按多少字節(jié)存儲，是否連續(xù)存儲等。
  我們都知道，c是靜態(tài)類型語言，一種在編譯期間就確定數(shù)據(jù)類型的語言，也就是我們需要對變量先聲明其數(shù)據(jù)類型后才能使用，并且在使用過程中一般不能賦值一些超過該數(shù)據(jù)類型數(shù)值，比如：int a = 1.2，當(dāng)然大類型是可以轉(zhuǎn)向小類型的，如：double a = 1 （double類型接收整形數(shù)值）?？梢钥隙ǖ?，大多數(shù)靜態(tài)類型語言都這么干。
  當(dāng)然，python語言也有數(shù)據(jù)類型。但python語言不同，它是一種動態(tài)類型語言，又是強類型語言。它們確定一個變量的數(shù)據(jù)類型是在你第一次給它賦值的時候，也就是說你賦值給變量什么數(shù)據(jù)類型的數(shù)值，變量就是什么數(shù)據(jù)類型的。所以，對比之下，c語言變量的數(shù)據(jù)類型是事先定義的，而python是后天接受的。

2、python五大標準數(shù)據(jù)類型

  在講變量存儲之前，這里先簡單總結(jié)下python的五大標準數(shù)據(jù)類型，為了方便展示，我們采用type方法顯示變量的數(shù)據(jù)類型。

（1）Numbers（數(shù)字）
  數(shù)字數(shù)據(jù)類型用于存儲數(shù)值。他們是不可改變的數(shù)據(jù)類型，可簡單分為以下四種：（注意這里十六進制，八進制都屬于int整形。）
int（整型）：

var = 520
print(type(var))  	 # class 'int'>

float（浮點型）：

var = 5.20
print(type(var))  	 # 輸出：class 'float'>

bool（布爾型）：

var = true
print(type(var))   # 輸出：class 'bool'>

complex（復(fù)數(shù)）：

var = complex(13,14)
print(type(var)) 	  # 輸出：class 'complex'>

（2）String（字符串）
  字符串或串是由數(shù)字、字母、下劃線組成的一串字符，用‘'，“”，“‘ '”都可表示。三者的使用可參考這篇文章： python字符串的各種表達方式.
  如下方代碼所示，獲得的類型為str類型。另外也順便提一個小知識點，要訪問字符串可以正向訪問也可以反向訪問，即正向時，var[0] = ‘p',var[1] = ‘i',var[2] = ‘g'；而反向時，var[-1] = ‘g',var[-2] = ‘i',var[-3] = ‘p'。

var = “pig”
print(type(var)) 	  # 輸出：class 'str'>
print(var[0:3])   # 正向訪問，輸出：'pig'
print(var[-1])   # 反向訪問，輸出：'g'

（3）List（列表）
  列表是 Python 中使用最頻繁的數(shù)據(jù)類型，用 [ ] 標識。列表可以完成大多數(shù)集合類的數(shù)據(jù)結(jié)構(gòu)實現(xiàn)。它可以同時包含字符，數(shù)字，字符串甚至可以包含列表（即嵌套）。如下方代碼所示，列表的處理方式和字符串類似。

var = [ 'pig' , 1 , 2.2 ]
print(type(var)) 	  # 輸出：class 'list'>
print(var[0]) 	  # 獲得第一個元素，輸出：'pig'
print(var+var) 		 # 打印組合的列表，輸出：[ 'pig', 1 , 2.2，'pig', 1 , 2.2 ]

（4）Tuple（元組）
  元組類似于 List（列表）。元組用 () 標識。內(nèi)部元素用逗號隔開。但是元組不能二次賦值，相當(dāng)于只讀列表。

var = ( 'pig', 1 , 2.2 )
print(type(var)) 	  # 輸出：class 'tuple'>
print(var[0]) 	  # 獲得第一個元素，輸出：'pig'
print(var+var) 		 # 打印組合的元組，輸出：( 'pig', 1 , 2.2，'pig', 1 , 2.2 )
var[0] = 'dog'			 # 出錯！不能被二次賦值

（5）Dictionary（字典）
  字典的相對于列表來說，列表是有序的對象集合，而字典是無序的對象集合。兩者之間的區(qū)別在于字典當(dāng)中的元素是通過鍵來存取的，而不是通過偏移存取。字典用"{ }"標識，字典由索引key和它對應(yīng)的值value組成。

dic = {'name'：'張三'，'age'：18}
print(dic ['name'])  # 得到鍵為'name' 的值，輸出：'張三'
print(dic [age])   # 得到鍵為'age' 的值，輸出：18
print(dic)    # 得到完整的字典，輸出：{'name'：'張三'，'age'：18}
print(dic.keys())   # 得到所有鍵，輸出：dict_keys:(['name','age'])
print(dic.values())  # 輸出所有值,輸出：dict_values:(['張三',18])

二、python變量的存儲

 1、變量與儲存地址的關(guān)系

  在高級語言中，變量是對內(nèi)存及其地址的抽象。以c語言舉例， 變量事先定義好一種數(shù)據(jù)類型，于是編譯器為變量分配一個對應(yīng)類型的地址空間和大?。ㄈ鏸nt 4字節(jié)，char 1字節(jié)），當(dāng)該變量改變值時，改變的只是這塊地址空間中保存的值，即在程序運行中，變量的地址就不能再發(fā)生改變了。這種存儲方式稱為值語義。如下代碼用VS2015運行，由結(jié)果可知，test變量的值被存儲在0x0020FDC8，當(dāng)變量改變時，地址不變，地址中對應(yīng)的值發(fā)生改變。

#includeiostream>
using namespace std;
int main()
{
	int test = 1;
	cout  test  ":"  test  endl;
	test = 2;
	cout  test  ":"  test  endl;
	return 0;
}

運行結(jié)果：

0020FDC8：1
0020FDC8：2

  這里就存在一個問題，每次新建一個變量，編譯器就會開辟一塊對應(yīng)數(shù)據(jù)類型大小的內(nèi)存，然后給那塊內(nèi)存取個名字（變量名）。除非一塊內(nèi)存被釋放，那么該變量才能釋放，不然一個變量就只能固定地對應(yīng)一個數(shù)據(jù)類型。
  對此，python做出了改變，它采用了與高級語言截然不同的方式。在python中，一切變量都是對象，變量的存儲采用了引用語義的方式，存儲的只是一個變量的值所在的內(nèi)存地址，而不是這個變量的值本身。簡單理解就是，python變量只是某個數(shù)據(jù)的引用（可以理解成C語言的指針），當(dāng)python變量賦值時，解釋器（因為python為解釋性語言）先為數(shù)值開辟一塊空間，而變量則指向這塊空間，當(dāng)變量改變值時，改變的并不是這塊空間中保存的值，而是改變了變量的指向，使變量指向另一個地址空間。這種存儲方式稱為對象語義或指針語義。舉個例子：

str = 'girls are pig'
print(id(str))
str = 'boys are dog'
print(id(str))

運行結(jié)果：

113811696
113812464

  id()方法可以獲得變量指向的地址，由運行結(jié)果所示，一開始變量指向了113811696這個地址，這個地址存放了‘girls are pig'這個字符串，當(dāng)變量發(fā)生改變時，即該變量的指向改變了，指向地址113812464，該地址存放有‘boys are dog'這個字符串。這兩個字符串都是一開始解釋器先在內(nèi)存開辟好的。
  所以，這也就解釋了為什么python的變量被整形賦值就成了整形，被列表賦值就成了列表，變量可以為任意數(shù)據(jù)類型的，因為python的變量只是對編譯器事先在內(nèi)存存放好的數(shù)據(jù)的引用。
  python采用這種方式，好處就體現(xiàn)在，對于解釋器來說，變量就只是一個地址的引用，而這個引用是可以隨時改變的，那么就可以做到一個變量用來指向各種各樣的數(shù)據(jù)類型，只要每次記錄變量與哪個數(shù)據(jù)類型連接就行了，效率不就提升了嘛~。而對于c語言的編譯器來說，一個變量就只能與一個數(shù)據(jù)類型長相廝守，所以它望著記錄了各種各樣變量名與內(nèi)存值對應(yīng)的表格，一邊編譯，一邊陷入了沉思…（這里注意一點牛角尖，變量名只是給解釋器看的東西，在內(nèi)存是不做存儲的，真正存儲的是變量名對應(yīng)的內(nèi)容，上面說的變量都是int a中a這個個體）

2、復(fù)雜數(shù)據(jù)類型的存儲方式

  這里說的復(fù)雜數(shù)據(jù)類型主要是像列表，字典等這種可以改變內(nèi)部數(shù)據(jù)的數(shù)據(jù)類型。以列表作為例子舉例，代碼如下所示：

list1 = [1,2,3]
print(list1)			#輸出：[1,2,3]
print(id(list1))		#輸出：112607104（不同電腦分配給變量的地址不同）
list1[0] = "hello"
print(list1)			#輸出：['hello',2,3]
print(id(list1))		#輸出：112607104
list1.append(4)
print(list1)			#輸出：['hello',2,3,4]
print(id(list1))		#輸出：112607104
list1 = ['hello',4]
print(list1)			#輸出：['hello',4]
print(id(list1))		#輸出：112925120

  由運行結(jié)果所示，無論對列表list1進行什么增刪改查操作，都不會影響list1本身的存儲，只是改變了存儲的內(nèi)容，但list1重新賦值時，地址則發(fā)生改變。這個為了更好地解釋清楚一點，就拿出我自豪的畫畫天賦吧（手動狗頭，咳咳），上圖~。

  先聲明一點，一個變量存有某一個對象的地址即等于該變量指向了這個對象。上面解釋了，list1變量存放的是某個數(shù)據(jù)類型的引用，換種說法就是存放某個對象的地址，這里就是存放一個列表的地址，即list1變量指向了列表。如圖所示，第一步，list1變量指向列表1，該列表存放著三個可變元素list1[0],list1[1],list1[2]，它們分別存放著不同對象（值）的地址。第二步，列表的第一個元素list1[0]發(fā)生改變，變成存放hello這個字符串對象的地址。第三步，列表新增了一個元素，該元素存放了新的整形對象4的地址。第四步，列表變量list1重新賦值，指向了新的列表2，列表2元素又指向了hello和4這兩個對象。
  因此，前面三步，因為都是改變了列表元素的指向，變量本身的指向沒有變化，即變量的地址也沒有變化，但第四步，變量進行重新的賦值，即指向了新的列表，那么變量的地址變發(fā)生了變化。
  這里也有重要的一點是，列表2和列表1指向的對象hello和4是一致的，因為它們的對象是一樣的，所以它們共用一個對象。從下面代碼可以體現(xiàn)，輸出的結(jié)果是一致的。

list1 = ['hello',2,3,4]
print(id(list1[0]))		#輸出：112926064
print(id(list1[3]))		#輸出：8791404644096
list2 = ['hello',4]
print(id(list2[0]))		#輸出：112926064
print(id(list2[1]))		#輸出：8791404644096

3、變量的賦值——淺拷貝和深拷貝

（1）變量賦值的安全隱患

  因為python的這種變量是一個對象的引用的機制，必然導(dǎo)致的結(jié)果是兩個變量賦值時會產(chǎn)生相互牽連的現(xiàn)象。舉個例子，list1賦值為[1,2,3]，然后將其賦值給list2，改變list1時，我們可以發(fā)現(xiàn)list2也發(fā)生改變。代碼如下。

list1 = [1,2,3]
list2 = list1
print(list1)			#輸出：[1,2,3]
print(list2)			#輸出：[1,2,3]
print(id(list1))		#輸出：112607104
print(id(list2))		#輸出：112607104
list1[0] = 'hello'
print(list1)			#輸出：['hello',2,3]
print(list2)			#輸出：['hello',2,3]
print(id(list1))		#輸出：112607104
print(id(list2))		#輸出：112607104

  解釋圖如下，第一步，list1變量指向了列表1，經(jīng)過賦值后，變量list2也指向了列表1，因此兩者地址相同。第二步，變量list1改變第一個列表元素的值，使其指向‘hello'，這時我們訪問list2內(nèi)容時，因為list1和list2指向的列表一致，所以list2就變成改變后的值。

  由此引出主題深拷貝和淺拷貝，所謂深拷貝呢，就是一個變量的內(nèi)容賦值給另一個變量時，是把全部資源重新復(fù)制一份再賦值給新的變量，而淺拷貝則不然，它的賦值只是將資源的地址給新的變量，二者同時共享該資源。顯然，上面的賦值運算例子就是一個淺拷貝。

（2）淺拷貝

  為了更加深入了解二者，舉一個稍微復(fù)雜一丟丟的例子，這里我們需要用到外部包，copy包，它的方法copy()就是一個淺拷貝，而deepcopy()就是一個深拷貝。先舉例淺拷貝，這次采用嵌套列表并且使用copy方法來進行拷貝。對比輸出結(jié)果可以看到對列表list1和list2進行操作時，兩者沒影響，但對peope這個列表操作時，則兩個列表都有影響。

import copy
people = ['girl','boy']
list1 = [1,2,people]
list2 = copy.copy(list1)
print(list1)				#輸出：[1,2,['girl','boy']]
print(list2)				#輸出：[1,2,['girl','boy']]
list1.append('hello')		
list2.append('hi')			
print(list1)				#輸出：[1,2,['girl','boy'],'hello']
print(list2)				#輸出：[1,2,['girl','boy'],'hi']
people[0] = 'pig'
print(list1)				#輸出：[1,2,['pig','boy'],'hello']
print(list2)				#輸出：[1,2,['pig','boy'],'hi']

  由下圖可知，第一步，list1和list2分別指向列表1和列表2，其元素也指向?qū)?yīng)的值，但個列表的第三個元素都指向了同個列表。第二步，list1產(chǎn)生新元素，指向‘hello'，list2產(chǎn)生新的元素，指向‘hi'。第三步，people這個列表的第一元素地址指向從‘girl'變成了‘pig'（狗頭保命），因為是共用列表，所以list1和list2這兩個變量都產(chǎn)生了變化。從中也可以分析得到，copy這個方法不像‘='這種賦值運算，它拷貝了資源的第一層，但如果有該資源有第二層時，則變成共用資源，這也是比較容易被忽略的一點。

（3）深拷貝

  為了解決淺拷貝帶來的安全隱患，有時我們需要采用深拷貝來拷貝我們的資源。即python的copy模塊提供的另一個deepcopy方法。深拷貝會完全復(fù)制原變量相關(guān)的所有數(shù)據(jù)，在內(nèi)存中生成一堆一模一樣的資源，在這個過程中我們對這兩個變量中的一個進行任意修改都不會影響其他變量。我們來測試一下。

import copy
people = ['girl','boy']
list1 = [1,2,people]
list2 = copy.deepcopy(list1)
print(list1)				#輸出：[1,2,['girl','boy']]
print(list2)				#輸出：[1,2,['girl','boy']]
list1.append('hello')		
list2.append('hi')			
print(list1)				#輸出：[1,2,['girl','boy'],'hello']
print(list2)				#輸出：[1,2,['girl','boy'],'hi']
people[0] = 'pig'
print(list1)				#輸出：[1,2,['pig','boy'],'hello']
print(list2)				#輸出：[1,2,['girl','boy'],'hi']

  流程如下圖所示，其步驟和淺拷貝的步驟一致，但不同的一點是，步驟三的people列表改變時，只有l(wèi)ist1變量的people列表中‘girl'變成‘pig'，而list2變量沒什么影響，二者完全獨立。

三、python變量數(shù)據(jù)類型的大小

  本來探索到上面已經(jīng)差不多要結(jié)束，鬼知道我腦子又冒出了個奇怪的想法，python的int類型到底要占有電腦的多少個字節(jié)呢。畢竟習(xí)慣了c語言，而python對變量神奇的設(shè)計總是散發(fā)著它獨特的魅力。所以找啊找，找到一個可以顯示數(shù)據(jù)大小的API函數(shù)getsizeof()，只要導(dǎo)入sys包即可。那么寫個例子：

import sys
print(sys.getsizeof(0))  # 輸出：24
print(sys.getsizeof(1))  # 輸出：28 
print(sys.getsizeof(2))  # 輸出：28
print(sys.getsizeof(2**15)) # 輸出：28
print(sys.getsizeof(2**30)) # 輸出：32
print(sys.getsizeof(2**128)) # 輸出：44

  看到輸出結(jié)果，屬實讓人震驚，一個int型的數(shù)值，居然用高達24個字節(jié)來存儲，而且在電腦存儲大小居然是不限定的，是自增長的。喝口水壓壓驚后，讓我想到c++的STL容器，可以使用棧頂指針，當(dāng)檢測到容量超出時，則刪除舊內(nèi)存而去開辟一塊新的內(nèi)存，確實可以實現(xiàn)這種效果。
  扯完犢子，那么這里首先先解決第一個問題，int類型這個變量什么時候內(nèi)存會變大？我在這篇博客中提到的文章找到了答案: 點此處跳轉(zhuǎn)。重點就是下面這張圖，簡單來說就是int類型每多2^30（1073741824 ）就會增加四個字節(jié)。這也驗證了上面例子getsizeof(2**30)是32字節(jié)，而比它小的是28個字節(jié)的原因，當(dāng)然零除外。其他類型也可以在下面找到答案。

  那么它的自增長問題呢，這個可能要去看python的源碼才能解決，還好有大佬已經(jīng)提前給我們鋪了下路，這里我就沒這個能力去了解太深入了，直接引用大佬的結(jié)論就可以了。具體可以參考這篇文章：點此處跳轉(zhuǎn)。在64位python的解釋器中，int類型的定義是通過一個結(jié)構(gòu)體來定義的，簡化后的結(jié)構(gòu)體如下所示：

struct PyLongObject {
 long ob_refcnt;    // 8 bytes
 struct _typeobject *ob_type; // 8 bytes
 long ob_size;     // 8 bytes
 unsigned int ob_digit[1];  // 4 bytes * abs(ob_size)
};

  ob_refcnt引用計數(shù)8個字節(jié)，ob_type類型信息8個字節(jié)（指針），ob_size變長部分元素的個數(shù)8個字節(jié)。ob_digit變長的數(shù)據(jù)部分，字節(jié)數(shù)為4 * abs（ob_size），ob_size可以為0，所以ob_digit這部分可以占0字節(jié)，那么最少int就為8 + 8 + 8 = 24個字節(jié)，每次增量都是4（unsigned int）的倍數(shù)。
  對于32位的版本與64位又有所不同，定義如下，最少12個字節(jié)，增量為2個字節(jié)。

struct PyLongObject {
 int ob_refcnt;    // 4 bytes
 struct _typeobject *ob_type; // 4 bytes
 int ob_size;     // 4 bytes
 unsigned short ob_digit[1]; // 2 bytes * abs(ob_size)
};

  至于其他類型實際大小，也是一個類似的方案，這里也不探討太多東西了，學(xué)無止境吧~

總結(jié)

  這篇文章從變量的角度切入，首先談?wù)勈裁词亲兞康念愋?，并且舉例了python中常用的基本數(shù)據(jù)類型，接著討論了變量在內(nèi)存中的存儲，說白了就一句話，變量就是某一個對象的引用，對象在內(nèi)存愛怎么放怎么放與變量無關(guān)。最后討論了int類型占有電腦的字節(jié)數(shù)。

Tips：本人能力有限，如有錯誤之處麻煩指出。放棄不難，但堅持一定很酷！

到此這篇關(guān)于深入理解Python變量的數(shù)據(jù)類型和存儲的文章就介紹到這了,更多相關(guān)Python變量的數(shù)據(jù)類型和存儲內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！