久久黄色小说视频,人妻少妇heyzo无码专区,久久乐视频

主頁 > 知識庫 > 深入理解Python變量的數據類型和存儲

深入理解Python變量的數據類型和存儲

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

一、變量的數據類型

1、什么是變量的數據類型

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

2、python五大標準數據類型

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

（1）Numbers（數字）
數字數據類型用于存儲數值。他們是不可改變的數據類型，可簡單分為以下四種：（注意這里十六進制，八進制都屬于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（復數）：

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

（2）String（字符串）
字符串或串是由數字、字母、下劃線組成的一串字符，用‘'，“”，“‘ '”都可表示。三者的使用可參考這篇文章： 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 中使用最頻繁的數據類型，用 [ ] 標識。列表可以完成大多數集合類的數據結構實現。它可以同時包含字符，數字，字符串甚至可以包含列表（即嵌套）。如下方代碼所示，列表的處理方式和字符串類似。

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（列表）。元組用 () 標識。內部元素用逗號隔開。但是元組不能二次賦值，相當于只讀列表。

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（字典）
字典的相對于列表來說，列表是有序的對象集合，而字典是無序的對象集合。兩者之間的區別在于字典當中的元素是通過鍵來存取的，而不是通過偏移存取。字典用"{ }"標識，字典由索引key和它對應的值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、變量與儲存地址的關系

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

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

運行結果：

0020FDC8：1
0020FDC8：2

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

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

運行結果：

113811696
113812464

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

2、復雜數據類型的存儲方式

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

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

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

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

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的這種變量是一個對象的引用的機制，必然導致的結果是兩個變量賦值時會產生相互牽連的現象。舉個例子，list1賦值為[1,2,3]，然后將其賦值給list2，改變list1時，我們可以發現list2也發生改變。代碼如下。

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，經過賦值后，變量list2也指向了列表1，因此兩者地址相同。第二步，變量list1改變第一個列表元素的值，使其指向‘hello'，這時我們訪問list2內容時，因為list1和list2指向的列表一致，所以list2就變成改變后的值。

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

（2）淺拷貝

為了更加深入了解二者，舉一個稍微復雜一丟丟的例子，這里我們需要用到外部包，copy包，它的方法copy()就是一個淺拷貝，而deepcopy()就是一個深拷貝。先舉例淺拷貝，這次采用嵌套列表并且使用copy方法來進行拷貝。對比輸出結果可以看到對列表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，其元素也指向對應的值，但個列表的第三個元素都指向了同個列表。第二步，list1產生新元素，指向‘hello'，list2產生新的元素，指向‘hi'。第三步，people這個列表的第一元素地址指向從‘girl'變成了‘pig'（狗頭保命），因為是共用列表，所以list1和list2這兩個變量都產生了變化。從中也可以分析得到，copy這個方法不像‘='這種賦值運算，它拷貝了資源的第一層，但如果有該資源有第二層時，則變成共用資源，這也是比較容易被忽略的一點。

（3）深拷貝

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

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列表改變時，只有list1變量的people列表中‘girl'變成‘pig'，而list2變量沒什么影響，二者完全獨立。

三、python變量數據類型的大小

本來探索到上面已經差不多要結束，鬼知道我腦子又冒出了個奇怪的想法，python的int類型到底要占有電腦的多少個字節呢。畢竟習慣了c語言，而python對變量神奇的設計總是散發著它獨特的魅力。所以找啊找，找到一個可以顯示數據大小的API函數getsizeof()，只要導入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

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

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

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

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

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