一、變量與對象
關系圖如下：
1、變量，通過變量指針引用對象
變量指針指向具體對象的內存空間，取對象的值。
2、對象，類型已知，每個對象都包含一個頭部信息（頭部信息：類型標識符和引用計數器）
注意：
變量名沒有類型，類型屬於對象（因為變量引用對象，所以類型隨對象），變量引用什么類型的對象，變量就是什么類型的。
In [32]: var1=object
In [33]: var2=var1
In [34]: id(var1)
Out[34]: 139697863383968
In [35]: id(var2)
Out[35]: 139697863383968
PS：id()是python的內置函數，用於返回對象的身份，即對象的內存地址。
In [39]: a=123
In [40]: b=a
In [41]: id(a)
Out[41]: 23242832
In [42]: id(b)
Out[42]: 23242832
In [43]: a=456
In [44]: id(a)
Out[44]: 33166408
In [45]: id(b)
Out[45]: 23242832
3、引用所指判斷
通過is進行引用所指判斷，is是用來判斷兩個引用所指的對象是否相同。
整數
In [46]: a=1
In [47]: b=1
In [48]: print(a is b)
True
短字符串
In [49]: c="good"
In [50]: d="good"
In [51]: print(c is d)
True
長字符串
In [52]: e="very good"
In [53]: f="very good"
In [54]: print(e is f)
False
列表
In [55]: g=[]
In [56]: h=[]
In [57]: print(g is h)
False
由運行結果可知：
1、Python緩存了整數和短字符串，因此每個對象在內存中只存有一份，引用所指對象就是相同的，即使使用賦值語句，也只是創造新的引用，而不是對象本身；
2、Python沒有緩存長字符串、列表及其他對象，可以由多個相同的對象，可以使用賦值語句創建出新的對象。
二、引用計數
在Python中，每個對象都有指向該對象的引用總數---引用計數
查看對象的引用計數：sys.getrefcount()
1、普通引用
In [2]: import sys
In [3]: a=[1,2,3]
In [4]: getrefcount(a)
Out[4]: 2
In [5]: b=a
In [6]: getrefcount(a)
Out[6]: 3
In [7]: getrefcount(b)
Out[7]: 3
注意：
當使用某個引用作為參數，傳遞給getrefcount()時，參數實際上創建了一個臨時的引用。因此，getrefcount()所得到的結果，會比期望的多1。
2、容器對象
Python的一個容器對象(比如：表、詞典等)，可以包含多個對象。
In [12]: a=[1,2,3,4,5]
In [13]: b=a
In [14]: a is b
Out[14]: True
In [15]: a[0]=6
In [16]: a
Out[16]: [6, 2, 3, 4, 5]
In [17]: a is b
Out[17]: True
In [18]: b
Out[18]: [6, 2, 3, 4, 5]
由上可見，實際上，容器對象中包含的並不是元素對象本身，是指向各個元素對象的引用。
3、引用計數增加
1、對象被創建
In [39]: getrefcount(123)
Out[39]: 6
In [40]: n=123
In [41]: getrefcount(123)
Out[41]: 7
2、另外的別人被創建
In [42]: m=n
In [43]: getrefcount(123)
Out[43]: 8
3、作為容器對象的一個元素
In [44]: a=[1,12,123]
In [45]: getrefcount(123)
Out[45]: 9
4、被作為參數傳遞給函數：foo(x)
4、引用計數減少
1、對象的別名被顯式的銷毀
In [46]: del m
In [47]: getrefcount(123)
Out[47]: 8
2、對象的一個別名被賦值給其他對象
In [48]: n=456
In [49]: getrefcount(123)
Out[49]: 7
3、對象從一個窗口對象中移除，或，窗口對象本身被銷毀
In [50]: a.remove(123)
In [51]: a
Out[51]: [1, 12]
In [52]: getrefcount(123)
Out[52]: 6
4、一個本地引用離開了它的作用域，比如上面的foo(x)函數結束時，x指向的對象引用減1。
三、垃圾回收
當Python中的對象越來越多，占據越來越大的內存，啟動垃圾回收(garbage collection)，將沒用的對象清除。
1、原理
當Python的某個對象的引用計數降為0時，說明沒有任何引用指向該對象，該對象就成為要被回收的垃圾。比如某個新建對象，被分配給某個引用，對象的引用計數變為1。如果引用被刪除，對象的引用計數為0，那么該對象就可以被垃圾回收。
In [74]: a=[321,123]
In [75]: del a
2、解析del
del a后，已經沒有任何引用指向之前建立的[321,123]，該表引用計數變為0，用戶不可能通過任何方式接觸或者動用這個對象，當垃圾回收啟動時，Python掃描到這個引用計數為0的對象，就將它所占據的內存清空。
3、注意
1、垃圾回收時，Python不能進行其它的任務，頻繁的垃圾回收將大大降低Python的工作效率；
2、Python只會在特定條件下，自動啟動垃圾回收（垃圾對象少就沒必要回收）
3、當Python運行時，會記錄其中分配對象(object allocation)和取消分配對象(object deallocation)的次數。當兩者的差值高於某個閾值時，垃圾回收才會啟動。
In [93]: import gc
In [94]: gc.get_threshold() #gc模塊中查看閾值的方法
Out[94]: (700, 10, 10)
閾值分析：
700即是垃圾回收啟動的閾值；
每10次0代垃圾回收，會配合1次1代的垃圾回收；而每10次1代的垃圾回收，才會有1次的2代垃圾回收；
當然也是可以手動啟動垃圾回收：
In [95]: gc.collect() #手動啟動垃圾回收
Out[95]: 2
4、何為分代回收
Python將所有的對象分為0，1，2三代；
所有的新建對象都是0代對象；
當某一代對象經歷過垃圾回收，依然存活，就被歸入下一代對象。
四、內存池機制
Python中有分為大內存和小內存：（256K為界限分大小內存）
1、大內存使用malloc進行分配
2、小內存使用內存池進行分配
3、Python的內存池(金字塔)
第3層：最上層，用戶對Python對象的直接操作
第1層和第2層：內存池，有Python的接口函數PyMem_Malloc實現-----若請求分配的內存在1~256字節之間就使用內存池管理系統進行分配，調用malloc函數分配內存，但是每次只會分配一塊大小為256K的大塊內存，不會調用free函數釋放內存，將該內存塊留在內存池中以便下次使用。
第0層：大內存-----若請求分配的內存大於256K，malloc函數分配內存，free函數釋放內存。
第-1，-2層：操作系統進行操作
