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

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

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

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

  我們先捋一捋什么是變量，變量從字面上理解就是可以變化的量，我們可以隨時(shí)改變這個(gè)變量的值，使得我們可以調(diào)用同一個(gè)變量而獲得不同的值，與之對(duì)應(yīng)的是常量。那么對(duì)于一個(gè)可變的變量，它有可能表示是一個(gè)字符串，一個(gè)數(shù)字或者是一個(gè)小數(shù)，因?yàn)檫@些在計(jì)算機(jī)內(nèi)存里存放的方式是不一樣的，所以簡(jiǎn)單理解就是變量的數(shù)據(jù)類型不同就是對(duì)應(yīng)的數(shù)據(jù)在計(jì)算機(jī)內(nèi)存中存放方式的不同。這種方式表現(xiàn)在按多少字節(jié)存儲(chǔ)，是否連續(xù)存儲(chǔ)等。
  我們都知道，c是靜態(tài)類型語言，一種在編譯期間就確定數(shù)據(jù)類型的語言，也就是我們需要對(duì)變量先聲明其數(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語言不同，它是一種動(dòng)態(tài)類型語言，又是強(qiáng)類型語言。它們確定一個(gè)變量的數(shù)據(jù)類型是在你第一次給它賦值的時(shí)候，也就是說你賦值給變量什么數(shù)據(jù)類型的數(shù)值，變量就是什么數(shù)據(jù)類型的。所以，對(duì)比之下，c語言變量的數(shù)據(jù)類型是事先定義的，而python是后天接受的。

2、python五大標(biāo)準(zhǔn)數(shù)據(jù)類型

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

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

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

float（浮點(diǎn)型）：

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字符串的各種表達(dá)方式.
  如下方代碼所示，獲得的類型為str類型。另外也順便提一個(gè)小知識(shí)點(diǎn)，要訪問字符串可以正向訪問也可以反向訪問，即正向時(shí)，var[0] = ‘p',var[1] = ‘i',var[2] = ‘g'；而反向時(shí)，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ù)類型，用 [ ] 標(biāo)識(shí)。列表可以完成大多數(shù)集合類的數(shù)據(jù)結(jié)構(gòu)實(shí)現(xiàn)。它可以同時(shí)包含字符，數(shù)字，字符串甚至可以包含列表（即嵌套）。如下方代碼所示，列表的處理方式和字符串類似。

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

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

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

（5）Dictionary（字典）
  字典的相對(duì)于列表來說，列表是有序的對(duì)象集合，而字典是無序的對(duì)象集合。兩者之間的區(qū)別在于字典當(dāng)中的元素是通過鍵來存取的，而不是通過偏移存取。字典用"{ }"標(biāo)識(shí)，字典由索引key和它對(duì)應(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變量的存儲(chǔ)

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

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

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

運(yùn)行結(jié)果：

0020FDC8：1
0020FDC8：2

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

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

運(yùn)行結(jié)果：

113811696
113812464

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

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

  這里說的復(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

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

  先聲明一點(diǎn)，一個(gè)變量存有某一個(gè)對(duì)象的地址即等于該變量指向了這個(gè)對(duì)象。上面解釋了，list1變量存放的是某個(gè)數(shù)據(jù)類型的引用，換種說法就是存放某個(gè)對(duì)象的地址，這里就是存放一個(gè)列表的地址，即list1變量指向了列表。如圖所示，第一步，list1變量指向列表1，該列表存放著三個(gè)可變?cè)豯ist1[0],list1[1],list1[2]，它們分別存放著不同對(duì)象（值）的地址。第二步，列表的第一個(gè)元素list1[0]發(fā)生改變，變成存放hello這個(gè)字符串對(duì)象的地址。第三步，列表新增了一個(gè)元素，該元素存放了新的整形對(duì)象4的地址。第四步，列表變量list1重新賦值，指向了新的列表2，列表2元素又指向了hello和4這兩個(gè)對(duì)象。
  因此，前面三步，因?yàn)槎际歉淖兞肆斜碓氐闹赶颍兞勘旧淼闹赶驔]有變化，即變量的地址也沒有變化，但第四步，變量進(jìn)行重新的賦值，即指向了新的列表，那么變量的地址變發(fā)生了變化。
  這里也有重要的一點(diǎn)是，列表2和列表1指向的對(duì)象hello和4是一致的，因?yàn)樗鼈兊膶?duì)象是一樣的，所以它們共用一個(gè)對(duì)象。從下面代碼可以體現(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）變量賦值的安全隱患

  因?yàn)閜ython的這種變量是一個(gè)對(duì)象的引用的機(jī)制，必然導(dǎo)致的結(jié)果是兩個(gè)變量賦值時(shí)會(huì)產(chǎn)生相互牽連的現(xiàn)象。舉個(gè)例子，list1賦值為[1,2,3]，然后將其賦值給list2，改變list1時(shí)，我們可以發(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改變第一個(gè)列表元素的值，使其指向‘hello'，這時(shí)我們?cè)L問list2內(nèi)容時(shí)，因?yàn)閘ist1和list2指向的列表一致，所以list2就變成改變后的值。

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

（2）淺拷貝

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

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)的值，但個(gè)列表的第三個(gè)元素都指向了同個(gè)列表。第二步，list1產(chǎn)生新元素，指向‘hello'，list2產(chǎn)生新的元素，指向‘hi'。第三步，people這個(gè)列表的第一元素地址指向從‘girl'變成了‘pig'（狗頭保命），因?yàn)槭枪灿昧斜?，所以list1和list2這兩個(gè)變量都產(chǎn)生了變化。從中也可以分析得到，copy這個(gè)方法不像‘='這種賦值運(yùn)算，它拷貝了資源的第一層，但如果有該資源有第二層時(shí)，則變成共用資源，這也是比較容易被忽略的一點(diǎn)。

（3）深拷貝

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

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']

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

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

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

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

  那么它的自增長問題呢，這個(gè)可能要去看python的源碼才能解決，還好有大佬已經(jīng)提前給我們鋪了下路，這里我就沒這個(gè)能力去了解太深入了，直接引用大佬的結(jié)論就可以了。具體可以參考這篇文章：點(diǎn)此處跳轉(zhuǎn)。在64位python的解釋器中，int類型的定義是通過一個(gè)結(jié)構(gòu)體來定義的，簡(jiǎn)化后的結(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引用計(jì)數(shù)8個(gè)字節(jié)，ob_type類型信息8個(gè)字節(jié)（指針），ob_size變長部分元素的個(gè)數(shù)8個(gè)字節(jié)。ob_digit變長的數(shù)據(jù)部分，字節(jié)數(shù)為4 * abs（ob_size），ob_size可以為0，所以ob_digit這部分可以占0字節(jié)，那么最少int就為8 + 8 + 8 = 24個(gè)字節(jié)，每次增量都是4（unsigned int）的倍數(shù)。
  對(duì)于32位的版本與64位又有所不同，定義如下，最少12個(gè)字節(jié)，增量為2個(gè)字節(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)
};

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

總結(jié)

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

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

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