說到內存管理，就先說一下垃圾回收吧。垃圾回收是Python，Java等語言管理內存的一種方式，說的直白些，就是清除無用的垃圾對象。C語言及C++中，需要通過malloc來進行內存的申請，通過free而進行內存的釋放。而Python和Java中有自動的內存管理機制，不需要動態的釋放內存，這種機制就是垃圾回收。
Python中通過引用計數法來進行內存的管理的。對每一個對象，都維護這一個對指向該對對象的引用的計數。比如：
a = "ABC"
b = a
首先創建了一個字符串對象"ABC"，然后將字符串對象的引用賦值為a。因而，字符串對象"ABC"的引用計數會加1。當執行b=a的時候，僅僅是創建了指向"ABC"這個字符串對象的引用的別名，而沒有創建對象。這樣，字符串對象"ABC"的引用計數會加1。如何驗證呢？我們可以查看a和b的id是否一致即可：
a = "ABC"
b = a
id(a) 36422672
id(b) 36422672
引用計數的數目可以通過sys.getrefcount()函數來進行獲取。為啥創建a對象后引用計數是2而不是1呢？這是因為一個是全局域里的，一個是調用函數的。當執行完b=a后，引用計數加1。
import sys
a = "ABC"
sys.getrefcount(a) 2
b = a
sys.getrefcount(a) 3
那什么時候引用計數增加，什么時候引用計數減少呢？：
引用計數增加主要有以下場景：
1、對象被創建時：a = "ABC"；
2、另外的別人被創建時：b = a；
3、被作為參數傳遞給函數時：foo(a)；
4、作為容器對象（list，元組，字典等）的一個元素時：x = [1,a,'33']。
引用計數減少主要有以下場景：
1、一個本地引用離開了它的作用域時，比如上面的foo(a)函數結束時，a指向的對象引用減1；
2、對象的引用被顯式的銷毀時：del a 或者 del b；
3、對象的引用被賦值給其他對象時：a = 789；
4、對象從一個容器對象（例如list）中移除時：L.remove(a)；
5、容器對象本身被銷毀：del L，或者容器對象本身離開了作用域。
所謂垃圾回收，就是回收引用計數為0的對象，釋放其占用的內存空間。垃圾回收機制還有一個循環垃圾回收器, 確保釋放循環引用對象(a引用b, b引用a, 導致其引用計數永遠不為0)。
Python的內存管理是層次結構的，各層負責不同的功能，如下圖所示：-1，-2層主要有操作系統進行操作，屬於內核態；第0層是C中的malloc，free等內存分配和釋放函數進行操作；第1層和第2層是內存池，有Python的接口函數PyMem_Malloc函數實現，當對象小於256K時由該層直接分配內存；第3層是最上層，也就是我們對Python對象的直接操作。感興趣的同學可以閱讀以下《Python源碼剖析》，相信你的收獲肯定是大大滴。
在 C 中如果頻繁的調用 malloc 與 free 時會產生性能問題的，再加上頻繁的分配與釋放小塊的內存會產生內存碎片。Python 在這里主要干的工作有：如果請求分配的內存在1~256字節之間就使用自己的內存管理系統，否則直接使用 malloc。這里還是會調用 malloc 分配內存,但每次會分配一塊大小為256k的大塊內存。經由內存池登記的內存到最后還是會回收到內存池,，並不會調用 C 的 free 釋放掉，以便下次使用。
Python中的變量在內存中的分配主要有兩種，一種是簡單拷貝，list改變一個就會引起另一個的改變，這是因為它們的引用相同，指向了同一個對象：
L= [3,4,5]
LL = L
id(L) 34432584
id(LL) 34432584
L.append(6)
id(L) 34432584
id(LL) 34432584
另外一種是深度拷貝，如數值、字符串、元組（tuple不允許被更改)等，也就是說當將變量a賦值給變量b時，雖然a和b的內存空間仍然相同，但當a的值發生變化時，會重新給a分配空間，a和b的地址變得不再相同。
a = 'ABC'
b = a
id(a) 36042680
id(b) 36042680
a = 'XYZ'
id(a) 36043424
id(b) 36042680
語言的內存管理是語言設計的一個重要方面。它是決定語言性能的重要因素。無論是C語言的手工管理，還是Java的垃圾回收，都成為語言最重要的特征。這里以Python語言為例子，說明一門動態類型的、面向對象的語言的內存管理方式。
對象的內存使用
賦值語句是語言最常見的功能了。但即使是最簡單的賦值語句，也可以很有內涵。Python的賦值語句就很值得研究。
a = 1
整數1為一個對象。而a是一個引用。利用賦值語句，引用a指向對象1。Python是動態類型的語言(參考動態類型)，對象與引用分離。Python像使用“筷子”那樣，通過引用來接觸和翻動真正的食物——對象。
引用和對象
為了探索對象在內存的存儲，我們可以求助於Python的內置函數id()。它用於返回對象的身份(identity)。其實，這里所謂的身份，就是該對象的內存地址。
a = 1 print(id(a)) print(hex(id(a)))
在我的計算機上，它們返回的是:
11246696
'0xab9c68'
分別為內存地址的十進制和十六進制表示。
在Python中，整數和短小的字符，Python都會緩存這些對象，以便重復使用。當我們創建多個等於1的引用時，實際上是讓所有這些引用指向同一個對象。
a = 1 b = 1 print(id(a)) print(id(b))
上面程序返回
11246696
11246696
可見a和b實際上是指向同一個對象的兩個引用。
為了檢驗兩個引用指向同一個對象，我們可以用is關鍵字。is用於判斷兩個引用所指的對象是否相同。
# True a = 1 b = 1 print(a is b) # True a = "good" b = "good" print(a is b) # False a = "very good morning" b = "very good morning" print(a is b) # False a = [] b = [] print(a is b)
上面的注釋為相應的運行結果。可以看到，由於Python緩存了整數和短字符串，因此每個對象只存有一份。比如，所有整數1的引用都指向同一對象。即使使用賦值語句，也只是創造了新的引用，而不是對象本身。長的字符串和其它對象可以有多個相同的對象，可以使用賦值語句創建出新的對象。
在Python中，每個對象都有存有指向該對象的引用總數，即引用計數(reference count)。
我們可以使用sys包中的getrefcount()，來查看某個對象的引用計數。需要注意的是，當使用某個引用作為參數，傳遞給getrefcount()時，參數實際上創建了一個臨時的引用。因此，getrefcount()所得到的結果，會比期望的多1。
from sys import getrefcount a = [1, 2, 3] print(getrefcount(a))
b = a
print(getrefcount(b))
由於上述原因，兩個getrefcount將返回2和3，而不是期望的1和2。
對象引用對象
Python的一個容器對象(container)，比如表、詞典等，可以包含多個對象。實際上，容器對象中包含的並不是元素對象本身，是指向各個元素對象的引用。
我們也可以自定義一個對象，並引用其它對象:
class from_obj(object):
def __init__(self, to_obj):
self.to_obj = to_obj
b = [1,2,3]
a = from_obj(b)
print(id(a.to_obj))
print(id(b))
可以看到，a引用了對象b。
對象引用對象，是Python最基本的構成方式。即使是a = 1這一賦值方式，實際上是讓詞典的一個鍵值"a"的元素引用整數對象1。該詞典對象用於記錄所有的全局引用。該詞典引用了整數對象1。我們可以通過內置函數globals()來查看該詞典。
當一個對象A被另一個對象B引用時，A的引用計數將增加1。
from sys import getrefcount a = [1, 2, 3] print(getrefcount(a)) b = [a, a] print(getrefcount(a))
由於對象b引用了兩次a，a的引用計數增加了2。
容器對象的引用可能構成很復雜的拓撲結構。我們可以用objgraph包來繪制其引用關系，比如
x = [1, 2, 3] y = [x, dict(key1=x)] z = [y, (x, y)] import objgraph objgraph.show_refs([z], filename='ref_topo.png')
objgraph是Python的一個第三方包。安裝之前需要安裝xdot。
sudo apt-get install xdot sudo pip install objgraph
兩個對象可能相互引用，從而構成所謂的引用環(reference cycle)。
a = [] b = [a] a.append(b)
即使是一個對象，只需要自己引用自己，也能構成引用環。
a = [] a.append(a) print(getrefcount(a))
引用環會給垃圾回收機制帶來很大的麻煩，我將在后面詳細敘述這一點。
引用減少
某個對象的引用計數可能減少。比如，可以使用del關鍵字刪除某個引用:
from sys import getrefcount a = [1, 2, 3] b = a print(getrefcount(b)) del a print(getrefcount(b))
del也可以用於刪除容器元素中的元素，比如:
a = [1,2,3] del a[0] print(a)
如果某個引用指向對象A，當這個引用被重新定向到某個其他對象B時，對象A的引用計數減少:
from sys import getrefcount
a = [1, 2, 3] b = a print(getrefcount(b)) a = 1 print(getrefcount(b))
垃圾回收
吃太多，總會變胖，Python也是這樣。當Python中的對象越來越多，它們將占據越來越大的內存。不過你不用太擔心Python的體形，它會乖巧的在適當的時候“減肥”，啟動垃圾回收(garbage collection)，將沒用的對象清除。在許多語言中都有垃圾回收機制，比如Java和Ruby。盡管最終目的都是塑造苗條的提醒，但不同語言的減肥方案有很大的差異 (這一點可以對比本文和Java內存管理與垃圾回收
)。
從基本原理上，當Python的某個對象的引用計數降為0時，說明沒有任何引用指向該對象，該對象就成為要被回收的垃圾了。比如某個新建對象，它被分配給某個引用，對象的引用計數變為1。如果引用被刪除，對象的引用計數為0，那么該對象就可以被垃圾回收。比如下面的表:
a = [1, 2, 3] del a
del a后，已經沒有任何引用指向之前建立的[1, 2, 3]這個表。用戶不可能通過任何方式接觸或者動用這個對象。這個對象如果繼續待在內存里，就成了不健康的脂肪。當垃圾回收啟動時，Python掃描到這個引用計數為0的對象，就將它所占據的內存清空。
然而，減肥是個昂貴而費力的事情。垃圾回收時，Python不能進行其它的任務。頻繁的垃圾回收將大大降低Python的工作效率。如果內存中的對象不多，就沒有必要總啟動垃圾回收。所以，Python只會在特定條件下，自動啟動垃圾回收。當Python運行時，會記錄其中分配對象(object allocation)和取消分配對象(object deallocation)的次數。當兩者的差值高於某個閾值時，垃圾回收才會啟動。
我們可以通過gc模塊的get_threshold()方法，查看該閾值:
import gc print(gc.get_threshold())
返回(700, 10, 10)，后面的兩個10是與分代回收相關的閾值，后面可以看到。700即是垃圾回收啟動的閾值。可以通過gc中的set_threshold()方法重新設置。
我們也可以手動啟動垃圾回收，即使用gc.collect()。
分代回收
Python同時采用了分代(generation)回收的策略。這一策略的基本假設是，存活時間越久的對象，越不可能在后面的程序中變成垃圾。我們的程序往往會產生大量的對象，許多對象很快產生和消失，但也有一些對象長期被使用。出於信任和效率，對於這樣一些“長壽”對象，我們相信它們的用處，所以減少在垃圾回收中掃描它們的頻率。
小家伙要多檢查
Python將所有的對象分為0，1，2三代。所有的新建對象都是0代對象。當某一代對象經歷過垃圾回收，依然存活，那么它就被歸入下一代對象。垃圾回收啟動時，一定會掃描所有的0代對象。如果0代經過一定次數垃圾回收，那么就啟動對0代和1代的掃描清理。當1代也經歷了一定次數的垃圾回收后，那么會啟動對0，1，2，即對所有對象進行掃描。
這兩個次數即上面get_threshold()返回的(700, 10, 10)返回的兩個10。也就是說，每10次0代垃圾回收，會配合1次1代的垃圾回收；而每10次1代的垃圾回收，才會有1次的2代垃圾回收。
同樣可以用set_threshold()來調整，比如對2代對象進行更頻繁的掃描。
import gc gc.set_threshold(700, 10, 5)
孤立的引用環
引用環的存在會給上面的垃圾回收機制帶來很大的困難。這些引用環可能構成無法使用，但引用計數不為0的一些對象。
a = [] b = [a] a.append(b) del a del b
上面我們先創建了兩個表對象，並引用對方，構成一個引用環。刪除了a，b引用之后，這兩個對象不可能再從程序中調用，就沒有什么用處了。但是由於引用環的存在，這兩個對象的引用計數都沒有降到0，不會被垃圾回收。
孤立的引用環
為了回收這樣的引用環，Python復制每個對象的引用計數，可以記為gc_ref。假設，每個對象i，該計數為gc_ref_i。Python會遍歷所有的對象i。對於每個對象i引用的對象j，將相應的gc_ref_j減1。
遍歷后的結果
在結束遍歷后，gc_ref不為0的對象，和這些對象引用的對象，以及繼續更下游引用的對象，需要被保留。而其它的對象則被垃圾回收。
總結
Python作為一種動態類型的語言，其對象和引用分離。這與曾經的面向過程語言有很大的區別。為了有效的釋放內存，Python內置了垃圾回收的支持。Python采取了一種相對簡單的垃圾回收機制，即引用計數，並因此需要解決孤立引用環的問題。Python與其它語言既有共通性，又有特別的地方。對該內存管理機制的理解，是提高Python性能的重要一步。