python的對象引用計數

❶ python面試題總結1-內存管理機制

（1）.引用計數
（2）. 垃圾回收
(3）. 內存池機制

在python中每創建一個對象，對應的會有一個引用計數，當發生賦值操作如a=b，對應的b的引用計數會自動加1，當引用的對象被清除或者函數結束時，引用計數會自動減1。

在python中使用引用計數，標記清楚，分代回收三種方式進行垃圾回收。
其中，引用計數當對象的引用計數歸0時，對象會自動被清除。標記清除機制是首先遍歷所有對象，如果對象可達，就說明有變數引用它，則標記其為可達的。如果不可達，則對其進行清除。分代回收是當對象創建時被標記為第0代，經過一次垃圾回收之後，餘下的對象被標記為第1代，最高為第2代。其原理是，對象的生存期越長，月可能不是垃越。

ython語言雖然提供了對內存的垃圾收集機制，但實際上它將不用的內存放到內存池而不是返回給操作系統，所以就有了以下：

1 Pymalloc機制；這個主要是為了加速Python的執行效率，Python引入了一個內存池機制，用於管理，為了對小塊內存的申請和釋放。

2 Python中所有小於256個位元組的對象都是依靠pymalloc分配器來實現的，而稍大的對象用的則是系統的malloc。

3 對於Python對象，比如整數、浮點數和List這些，都有自己獨立的內存池，對象間並不共享他們的內存池。換句話說就是，假設你分配並且釋放了大量的整數，那麼用於緩存這些整數的內存就不能再分配給浮點數。

❷ Python如何進行內存管理

Python是如何進行內存管理的？

答:從三個方面來說,一對象的引用計數機制,二垃圾回收機制,三內存池機制。

一、對象的引用計數機制

Python內部使用引用計數，來保持追蹤內存中的對象，所有對象都有引用計數。

引用計數增加的情況：

1，一個對象分配一個新名稱

2，將其放入一個容器中（如列表、元組或字典）

引用計數減少的情況：

1，使用del語句對對象別名顯示的銷毀

2，引用超出作用域或被重新賦值

Sys.getrefcount( )函數可以獲得對象的當前引用計數

多數情況下，引用計數比你猜測得要大得多。對於不可變數據（如數字和字元串），解釋器會在程序的不同部分共享內存，以便節約內存。

相關推薦：《Python視頻教程》

二、垃圾回收

1，當一個對象的引用計數歸零時，它將被垃圾收集機制處理掉。

2，當兩個對象a和b相互引用時，del語句可以減少a和b的引用計數，並銷毀用於引用底層對象的名稱。然而由於每個對象都包含一個對其他對象的應用，因此引用計數不會歸零，對象也不會銷毀。（從而導致內存泄露）。為解決這一問題，解釋器會定期執行一個循環檢測器，搜索不可訪問對象的循環並刪除它們。

三、內存池機制

Python提供了對內存的垃圾收集機制，但是它將不用的內存放到內存池而不是返回給操作系統。

1，Pymalloc機制。為了加速Python的執行效率，Python引入了一個內存池機制，用於管理對小塊內存的申請和釋放。

2，Python中所有小於256個位元組的對象都使用pymalloc實現的分配器，而大的對象則使用系統的malloc。

3，對於Python對象，如整數，浮點數和List，都有其獨立的私有內存池，對象間不共享他們的內存池。也就是說如果你分配又釋放了大量的整數，用於緩存這些整數的內存就不能再分配給浮點數。

❸ Python引入了一個機制：引用計數。

python內部使用引用計數，來保持追蹤內存中的對象，
Python內部記錄了對象有多少個引用
，即引用計數，當對象被創建時就創建了一個引用計數，當對象不再需要時，這個對象的引用計數為0時，它被垃圾回收。
總結一下對象會在一下情況下引用計數加1：
1.對象被創建：x=4
2.另外的別人被創建：y=x
3.被作為參數傳遞給函數：foo(x)
4.作為容器對象的一個元素：a=[1,x,'33']
引用計數減少情況
1.一個本地引用離開了它的作用域。比如上面的foo(x)函數結束時，x指向的對象引用減1。
2.對象的別名被顯式的銷毀：del x ；或者del y
3.對象的一個別名被賦值給其他對象：x=789
4.對象從一個窗口對象中移除：myList.remove(x)
5.窗口對象本身被銷毀：del myList，或者窗口對象本身離開了作用域。垃圾回收
1、當內存中有不再使用的部分時，垃圾收集器就會把他們清理掉。
它會去檢查那些引用計數為0的對象
，然後清除其在內存的空間。當然除了引用計數為0的會被清除，還有一種情況也會被垃圾收集器清掉：當兩個對象相互引用時，他們本身其他的引用已經為0了。
2、垃圾回收機制還有一個
循環垃圾回收器
, 確保釋放循環引用對象(a引用b, b引用a, 導致其引用計數永遠不為0)。
在Python中，許多時候申請的內存都是小塊的內存，這些小塊內存在申請後，很快又會被釋放，由於這些內存的申請並不是為了創建對象，所以並沒有對象一級的內存池機制。
這就意味著Python在運行期間會大量地執行malloc和free的操作，頻繁地在用戶態和核心態之間進行切換，這將嚴重影響Python的執行效率。為了加速Python的執行效率，Python引入了一個內存池機制，用於管理對小塊內存的申請和釋放。
內存池機制
Python提供了對內存的垃圾收集機制，但是它將不用的內存放到內存池而不是返回給操作系統。
Python中所有小於256個位元組的對象都使用pymalloc實現的分配器，而大的對象則使用系統的
malloc。另外Python對象，如整數，浮點數和List，都有其獨立的私有內存池，對象間不共享他們的內存池。也就是說如果你分配又釋放了大量的整數，用於緩存這些整數的內存就不能再分配給浮點數。
在Python中，許多時候申請的內存都是小塊的內存，這些小塊內存在申請後，很快又會被釋放，由於這些內存的申請並不是為了創建對象，所以並沒有對象一級的內存池機制。這就意味著Python在運行期間會大量地執行malloc和free的操作，頻繁地在用戶態和核心態之間進行切換，這將嚴重影響
Python的執行效率。這也就是之前提到的

❹ python的內存管理機制

論壇

活動

招聘

專題

打開CSDN APP
Copyright © 1999-2020, CSDN.NET, All Rights Reserved

登錄

XCCS_澍
關注
Python 的內存管理機制及調優手段？ 原創
2018-08-05 06:50:53

XCCS_澍

碼齡7年

關注
內存管理機制：引用計數、垃圾回收、內存池。
一、引用計數：
    引用計數是一種非常高效的內存管理手段， 當一個 Python 對象被引用時其引用計數增加 1， 當其不再被一個變數引用時則計數減 1. 當引用計數等於 0 時對象被刪除。
二、垃圾回收 ：
1. 引用計數
      引用計數也是一種垃圾收集機制，而且也是一種最直觀，最簡單的垃圾收集技術。當 Python 的某個對象的引用計數降為 0 時，說明沒有任何引用指向該對象，該對象就成為要被回收的垃圾了。比如某個新建對象，它被分配給某個引用，對象的引用計數變為 1。如果引用被刪除，對象的引用計數為 0，那麼該對象就可以被垃圾回收。不過如果出現循環引用的話，引用計數機制就不再起有效的作用了
2. 標記清除
     如果兩個對象的引用計數都為 1，但是僅僅存在他們之間的循環引用，那麼這兩個對象都是需要被回收的，也就是說，它們的引用計數雖然表現為非 0，但實際上有效的引用計數為 0。所以先將循環引用摘掉，就會得出這兩個對象的有效計數。
3. 分代回收
     從前面「標記-清除」這樣的垃圾收集機制來看，這種垃圾收集機制所帶來的額外操作實際上與系統中總的內存塊的數量是相關的，當需要回收的內存塊越多時，垃圾檢測帶來的額外操作就越多，而垃圾回收帶來的額外操作就越少；反之，當需回收的內存塊越少時，垃圾檢測就將比垃圾回收帶來更少的額外操作。

❺ python程序執行完有對象的引用計數不為0，會怎麼處理

1. 整個執行結束後，解釋器退出時會清理所有解釋器產生的對象。2. CPython的實現里有個mark-sweep。因此即使出現了循環引用又被扔掉的對象，最終還是會被回收的。3. 你的例子不構成循環引用，完全會根據計數正常回收。清理b時，b所指list引用歸0，list被回收，list中對a的引用就會減1，因此沒有任何問題。

❻ Python 的內存管理機制

Python採用自動內存管理，即Python會自動進行垃圾回收，不需要像C、C++語言一樣需要程序員手動釋放內存，手動釋放可以做到實時性，但是存在內存泄露、空指針等風險。

Python自動垃圾回收也有自己的優點和缺點：優點：

缺點：

Python的垃圾回收機制採用 以引用計數法為主，分代回收為輔 的策略。

先聊引用計數法，Python中每個對象都有一個核心的結構體，如下

一個對象被創建時，引用計數值為1，當一個變數引用一個對象時，該對象的引用計數ob_refcnt就加一，當一個變數不再引用一個對象時，該對象的引用計數ob_refcnt就減一，Python判斷是否回收一個對象，會將該對象的引用計數值ob_refcnt減一判斷結果是否等於0，如果等於0就回收，如果不等於0就不回收，如下：

一個對象在以下三種情況下引用計數會增加：

一個對象在以下三種情況引用計數會減少：

驗證案例：

運行結果：

事實上，關於垃圾回收的測試，最好在終端環境下測試，比如整數257，它在PyCharm中用下面的測試代碼列印出來的結果是4，而如果在終端環境下列印出來的結果是2。這是因為終端代表的是原始的Python環境，而PyCharm等IDE做了一些特殊處理，在Python原始環境中，整數緩存的范圍是在 [-5, 256] 的雙閉合區間內，而PyCharm做了特殊處理之後，PyCharm整數緩存的范圍變成了 [-5, 無窮大]，但我們必須以終端的測試結果為主，因為它代表的是原始的Python環境，並且代碼最終也都是要發布到終端運行的。

好，那麼回到終端，我們來看兩種特殊情況

前面學習過了，整數緩存的范圍是在 [-5, 256] 之間，這些整數對象在程序載入完全就已經駐留在內存之中，並且直到程序結束退出才會釋放佔有的內存，測試案例如下：

如果字元串的內容只由字母、數字、下劃線構成，那麼它只會創建一個對象駐留在內存中，否則，每創建一次都是一個新的對象。

引用計數法有缺陷，它無法解決循環引用問題，即A對象引用了B對象，B對象又引用了A對象，這種情況下，A、B兩個對象都無法通過引用計數法來進行回收，有一種解決方法是程序運行結束退出時進行回收，代碼如下：

前面講過，Python垃圾回收機制的策略是 以引用計數法為主，以分代回收為輔 。分代回收就是為了解決循環引用問題的。

Python採用分代來管理對象的生命周期：第0代、第1代、第2代，當一個對象被創建時，會被分配到第一代，默認情況下，當第0代的對象達到700個時，就會對處於第0代的對象進行檢測和回收，將存在循環引用的對象釋放內存，經過垃圾回收後，第0代中存活的對象會被分配為第1代，同樣，當第1代的對象個數達到10個時，也會對第1代的對象進行檢測和回收，將存在循環引用的對象釋放內存，經過垃圾回收後，第1代中存活的對象會被分配為第2代，同樣，當第二代的對象個數達到10個時，也會對第2代的對象進行檢測和回收，將存在循環引用的對象釋放內存。Python就是通過這樣一種策略來解決對象之間的循環引用問題的。

測試案例：

運行結果：

如上面的運行結果，當第一代中對象的個數達到699個即將突破臨界值700時（在列印699之前就已經回收了，所以看不到698和699）進行了垃圾回收，回收掉了循環引用的對象。

第一代、第二代、第三代分代回收都是有臨界值的，這個臨界值可以通過調用 gc.get_threshold 方法查看，如下：

當然，如果對默認臨界值不滿意，也可以調用 gc.set_threshold 方法來自定義臨界值，如下：

最後，簡單列出兩個gc的其它方法，了解一下，但禁止在程序代碼中使用

以上就是對Python垃圾回收的簡單介紹，當然，深入研究肯定不止這些內容，目前，了解到這個程度也足夠了。

❼ Python對象

眾所周知，Python是一門面向對象的語言，在Python無論是數值、字元串、函數亦或是類型、類，都是對象。
對象是在 堆 上分配的結構，我們定義的所有變數、函數等，都存儲於堆內存，而變數名、函數名則是一個存儲於 棧 中、指向堆中具體結構的引用。

要想深入學習Python，首先需要知道Python對象的定義。

我們通常說的Python都是指CPython，底層由C語言實現，源碼地址： cpython [GitHub]
Python對象的定義位於 Include/object.h ，是一個名為 PyObject 的結構體：

Python中的所有對象都繼承自PyObejct，PyObject包含一個用於垃圾回收的雙向鏈表，一個引用計數變數 ob_refcnt 和 一個類型對象指針 ob_type

從PyObejct的注釋中，我們可以看到這樣一句：每個指向 可變大小Python對象 的指針也可以轉換為 PyVarObject* （可變大小的Python對象會在下文中解釋）。 PyVarObejct 就是在PyObject的基礎上多了一個 ob_size 欄位，用於存儲元素個數：

在PyObject結構中，還有一個類型對象指針 ob_type ，用於表示Python對象是什麼類型，定義Python對象類型的是一個 PyTypeObject 介面體

實際定義是位於 Include/cpython/object.h 的 _typeobject ：

在這個類型對象中，不僅包含了對象的類型，還包含了如分配內存大小、對象標准操作等信息，主要分為：

以Python中的 int類型 為例，int類型對象的定義如下：

從PyObject的定義中我們知道，每個對象的 ob_type 都要指向一個具體的類型對象，比如一個數值型對象 100 ，它的ob_type會指向 int類型對象PyLong_Type 。

PyTypeObject結構體第一行是一個PyObject_VAR_HEAD宏，查看宏定義可知PyTypeObject是一個變長對象

也就是說，歸根結底 類型對象也是一個對象 ，也有ob_type屬性，那 PyLong_Type 的 ob_type 是什麼呢？
回到PyLong_Type的定義，第一行 PyVarObject_HEAD_INIT(&PyType_Type, 0) ，查看對應的宏定義

由以上關系可以知道， PyVarObject_HEAD_INIT(&PyType_Type, 0) = { { _PyObject_EXTRA_INIT 1, &PyType_Type } 0} ，將其代入 PyObject_VAR_HEAD ，得到一個變長對象：

這樣看就很明確了，PyLong_Type的類型就是PyType_Typ，同理可知， Python類型對象的類型就是PyType_Type ，而 PyType_Type對象的類型是它本身

從上述內容中，我們知道了對象和對象類型的定義，那麼根據定義，對象可以有以下兩種分類

Python對象定義有 PyObject 和 PyVarObject ，因此，根據對象大小是否可變的區別，Python對象可以劃分為 可變對象（變長對象） 和 不可變對象（定長對象）

原本的對象a大小並沒有改變，只是s引用的對象改變了。這里的對象a、對象b就是定長對象

可以看到，變數l仍然指向對象a，只是對象a的內容發生了改變，數據量變大了。這里的對象a就是變長對象

由於存在以上特性，所以使用這兩種對象還會帶來一種區別：
聲明 s2 = s ，修改s的值： s = 'new string' ，s2的值不會一起改變，因為只是s指向了一個新的對象，s2指向的舊對象的值並沒有發生改變
聲明 l2 = l ，修改l的值： l.append(6) ，此時l2的值會一起改變，因為l和l2指向的是同一個對象，而該對象的內容被l修改了

此外，對於 字元串 對象，Python還有一套內存復用機制，如果兩個字元串變數值相同，那它們將共用同一個對象：

對於 數值型 對象，Python會默認創建0~2 8 以內的整數對象，也就是 0 ~ 256 之間的數值對象是共用的：

按照Python數據類型，對象可分為以下幾類：

Python創建對象有兩種方式，泛型API和和類型相關的API

這類API通常以 PyObject_xxx 的形式命名，可以應用在任意Python對象上，如:

使用 PyObjecg_New 創建一個數值型對象：

這類API通常只能作用於一種類型的對象上，如：

使用 PyLong_FromLong 創建一個數值型對象：

在我們使用Python聲明變數的時候，並不需要為變數指派類型，在給變數賦值的時候，可以賦值任意類型數據，如：

從Python對象的定義我們已經可以知曉造成這個特點的原因了，Python創建對象時，會分配內存進行初始化，然後Python內部通過 PyObject* 變數來維護這個對象，所以在Python內部各函數直接傳遞的都是一種泛型指針 PyObject* ，這個指針所指向的對象類型是不固定的，只能通過所指對象的 ob_type 屬性動態進行判斷，而Python正是通過 ob_type 實現了多態機制

Python在管理維護對象時，通過引用計數來判斷內存中的對象是否需要被銷毀，Python中所有事物都是對象，所有對象都有引用計數 ob_refcnt 。
當一個對象的引用計數減少到0之後，Python將會釋放該對象所佔用的內存和系統資源。
但這並不意味著最終一定會釋放內存空間，因為頻繁申請釋放內存會大大降低Python的執行效率，因此Python中採用了內存對象池的技術，是的對象釋放的空間會還給內存池，而不是直接釋放，後續需要申請空間時，優先從內存對象池中獲取。