python清理內存

㈠ python的內存問題該這么解決

1.沒有開gc，或者gc設為debug狀態，導致交叉引用沒有被回收調
2.如果一個數據在邏輯上不應該存在，但是因為代碼上沒有做相關清除操作，導致他還存在，也是一種泄漏
舉個栗子，例如我要記錄最近50天的某個基金的日化收益率，定義一個全局的字典global_dict，運行了一個腳本進行計算，沒10分鍾算一次，但是我沒有進行clear操作，每次的計算只是單純的賦值dict[date] = rate，按理來說dict["五十天前"]的收益率都是不需要的，就是一種泄漏。
3.這種情況出現在python3.4之前，因為3.4已經修復了，是這樣的，如果一個類定義了__del__，並且該類存在循環引用的情況，這時候gc就會把這個類放在gc.garbage當中，不會去做回收，可以說是跳出了分代回收的機制，但是3.4之後的版本就沒有這種情況，會把他回收調。

㈡ Python是怎樣管理內存的

Python中的內存管理是由Python私有堆空間管理，所以Python對象和數據結構都位於私有堆中，程序員無法訪問此私有堆，Python解釋器負責處理這個問題。
Python對象的堆空間分配由Python的內存管理器完成，核心API提供了一些程序員編寫代碼的工具。
Python還有一個內存的垃圾收集器，可以回收所有未使用的內存，並使其可用於堆空間。

㈢ Python如何管理內存

Python對內存的管理要從三個方面來說：1.對象的引用計數機制、2.垃圾回收機制、 3.內存池機制

㈣ BAT面試題28：Python是如何進行內存管理的

Python的內存管理，一般從以下三個方面來說：

1)對象的引用計數機制(四增五減)

2)垃圾回收機制(手動自動，分代回收)

3)內存池機制(大m小p)

1)對象的引用計數機制

要保持追蹤內存中的對象，Python使用了引用計數這一簡單的技術。sys.getrefcount(a)可以查看a對象的引用計數，但是比正常計數大1，因為調用函數的時候傳入a，這會讓a的引用計數+1

2)垃圾回收機制

吃太多，總會變胖，Python也是這樣。當Python中的對象越來越多，它們將占據越來越大的內存。不過你不用太擔心Python的體形，它會在適當的時候「減肥」，啟動垃圾回收(garbage
collection)，將沒用的對象清除

從基本原理上，當Python的某個對象的引用計數降為0時，說明沒有任何引用指向該對象，該對象就成為要被回收的垃圾了

比如某個新建對象，它被分配給某個引用，對象的引用計數變為1。如果引用被刪除，對象的引用計數為0，那麼該對象就可以被垃圾回收。

然而，減肥是個昂貴而費力的事情。垃圾回收時，Python不能進行其它的任務。頻繁的垃圾回收將大大降低Python的工作效率。如果內存中的對象不多，就沒有必要總啟動垃圾回收。

所以，Python只會在特定條件下，自動啟動垃圾回收。當Python運行時，會記錄其中分配對象(object
allocation)和取消分配對象(object deallocation)的次數。當兩者的差值高於某個閾值時，垃圾回收才會啟動。

我們可以通過gc模塊的get_threshold()方法，查看該閾值。

3)內存池機制

Python中有分為大內存和小內存：(256K為界限分大小內存)

1、大內存使用malloc進行分配

2、小內存使用內存池進行分配

python中的內存管理機制都有兩套實現，一套是針對小對象，就是大小小於256K時，pymalloc會在內存池中申請內存空間;當大於256K時，則會直接執行系統的malloc的行為來申請內存空間。

㈤ python如何進行內存管理

Python的內存管理主要有三種機制：引用計數機制，垃圾回收機制和內存池機制。
引用計數機制
簡介
python內部使用引用計數，來保持追蹤內存中的對象，Python內部記錄了對象有多少個引用，即引用計數，當對象被創建時就創建了一個引用計數，當對象不再需要時，這個對象的引用計數為0時，它被垃圾回收。
特性
1.當給一個對象分配一個新名稱或者將一個對象放入一個容器(列表、元組或字典)時，該對象的引用計數都會增加。
2.當使用del對對象顯示銷毀或者引用超出作用於或者被重新賦值時，該對象的引用計數就會減少。
3.可以使用sys.getrefcount()函數來獲取對象的當前引用計數。多數情況下，引用計數要比我們猜測的大的多。對於不可變數據(數字和字元串)，解釋器會在程序的不同部分共享內存，以便節約內存。
垃圾回收機制
特性
1.當內存中有不再使用的部分時，垃圾收集器就會把他們清理掉。它會去檢查那些引用計數為0的對象，然後清除其在內存的空間。當然除了引用計數為0的會被清除，還有一種情況也會被垃圾收集器清掉：當兩個對象相互引用時，他們本身其他的引用已經為0了。
2.垃圾回收機制還有一個循環垃圾回收器, 確保釋放循環引用對象(a引用b, b引用a, 導致其引用計數永遠不為0)。
內存池機制
簡介
在Python中，許多時候申請的內存都是小塊的內存，這些小塊內存在申請後，很快又會被釋放，由於這些內存的申請並不是為了創建對象，所以並沒有對象一級的內存池機制。這就意味著Python在運行期間會大量地執行malloc和free的操作，頻繁地在用戶態和核心態之間進行切換，這將嚴重影響Python的執行效率。為了加速Python的執行效率，Python引入了一個內存池機制，用於管理對小塊內存的申請和釋放。
內存池概念
內存池的概念就是預先在內存中申請一定數量的，大小相等的內存塊留作備用，當有新的內存需求時，就先從內存池中分配內存給這個需求，不夠了之後再申請新的內存。這樣做最顯著的優勢就是能夠減少內存碎片，提升效率。內存池的實現方式有很多，性能和適用范圍也不一樣。
特性
1.Python提供了對內存的垃圾收集機制，但是它將不用的內存放到內存池而不是返回給操作系統。
2.Pymalloc機制。為了加速Python的執行效率，Python引入了一個內存池機制，用於管理對小塊內存的申請和釋放。
3.Python中所有小於256個位元組的對象都使用pymalloc實現的分配器，而大的對象則使用系統的 malloc。
4.對於Python對象，如整數，浮點數和List，都有其獨立的私有內存池，對象間不共享他們的內存池。也就是說如果你分配又釋放了大量的整數，用於緩存這些整數的內存就不能再分配給浮點數。

㈥ 如何釋放Python佔用的內存

在上文的優化中，對每500個用戶，會進行一些計算並記錄結果在磁碟文件中。原本以為這么做，這些結果就在磁碟文件中了，而不會再繼續佔用內存；但實際上，python的大坑就是Python不會自動清理這些內存。這是由其本身實現決定的。具體原因網上多有文章介紹，這里就不了。
本篇博客將貼一個筆者的實驗腳本，用以說明Python確實存在這么一個不釋放內存的現象，另外也提出一個解決方案，即：先del，再顯式調用gc.collect(). 腳本和具體效果見下。

實驗環境一：Win 7， Python 2.7

[python] view plain
from time import sleep, time
import gc

def mem(way=1):
print time()
for i in range(10000000):
if way == 1:
pass
else: # way 2, 3
del i

print time()
if way == 1 or way == 2:
pass
else: # way 3
gc.collect()
print time()

if __name__ == "__main__":
print "Test way 1: just pass"
mem(way=1)
sleep(20)
print "Test way 2: just del"
mem(way=2)
sleep(20)
print "Test way 3: del, and then gc.collect()"
mem(way=3)
sleep(20)

運行結果如下：

[plain] view plain
Test way 1: just pass
1426688589.47
1426688590.25
1426688590.25
Test way 2: just del
1426688610.25
1426688611.05
1426688611.05
Test way 3: del, and then gc.collect()
1426688631.05
1426688631.85
1426688631.95

對於way 1和way 2，結果是完全一樣的，程序內存消耗峰值是326772KB，在sleep 20秒時，內存實時消耗是244820KB；
對於way 3，程序內存消耗峰值同上，但是sleep時內存實時消耗就只有6336KB了。

實驗環境二： Ubuntu 14.10， Python 2.7.3

運行結果：

[plain] view plain
Test way 1: just pass
1426689577.46
1426689579.41
1426689579.41
Test way 2: just del
1426689599.43
1426689601.1
1426689601.1
Test way 3: del, and then gc.collect()
1426689621.12
1426689622.8
1426689623.11

[plain] view plain
ubuntu@my_machine:~$ ps -aux | grep test_mem
Warning: bad ps syntax, perhaps a bogus '-'? See
ubuntu 9122 10.0 6.0 270916 245564 pts/1 S+ 14:39 0:03 python test_mem.py
ubuntu 9134 0.0 0.0 8104 924 pts/2 S+ 14:40 0:00 grep --color=auto test_mem
ubuntu@my_machine:~$ ps -aux | grep test_mem
Warning: bad ps syntax, perhaps a bogus '-'? See
ubuntu 9122 10.0 6.0 270916 245564 pts/1 S+ 14:39 0:03 python test_mem.py
ubuntu 9134 0.0 0.0 8104 924 pts/2 S+ 14:40 0:00 grep --color=auto test_mem
ubuntu@my_machine:~$ ps -aux | grep test_mem
Warning: bad ps syntax, perhaps a bogus '-'? See
ubuntu 9122 11.6 0.1 30956 5608 pts/1 S+ 14:39 0:05 python test_mem.py

結論：
以上說明，當調用del時，其實Python並不會真正release內存，而是將其繼續放在其內存池中；只有在顯式調用gc.collect()時，才會真正release內存。

進一步：
其實回到上一篇博客的腳本中，也讓其引入gc.collect()，然後寫個監控腳本監測內存消耗情況：

[plain] view plain
while ((1)); do ps -aux | sort -n -k5,6 | grep my_script; free; sleep 5; done

結果發現：內存並不會在每500個用戶一組執行完後恢復，而是一直持續消耗到僅存約70MB時，gc才好像起作用。本環境中，機器使用的是Cloud instance，總內存2G，可用內存約為1G，本腳本內存常用消耗是900M - 1G。換句話說，對於這個腳本來說，gc並沒有立即起作用，而是在系統可用內存從1 - 1.2G下降到只剩70M左右時，gc才開始發揮作用。這點確實比較奇怪，不知道和該腳本是在Thread中使用的gc.collect()是否有關，或者是gc發揮作用原本就不是可控的。筆者尚未做相關實驗，可能在下篇博客中繼續探討。

但是，可以肯定的是，若不使用gc.collect(), 原腳本將會將系統內存耗盡而被殺死。這一點從syslog中可以明顯看出。

㈦ Python 多進程內存佔用問題

當我們有一個很長很長的任務隊列(mission_list)和閾值對應的一個處理函數(missionFunction)時，我們一般採用如下的方式進行處理：

但是，如果這任務列表很長很長，處理函數很復雜(佔用cpu)時，單核往往需要很長的時間進行處理，此時，Multiprocess便可以極大的提高我們程序的運行速度，相關內容請借鑒 multiprocessing --- 基於進程的並行 — Python 3.10.4 文檔。

以上這種場景下，推薦大家採用最簡單的進程池+map的方法進行處理，標準的寫法， chunksize要借鑒官方的說法，最好大一點 ：

但是！！！！ 如果我們的任務列表非常的長，這會導致多進程還沒跑起來之前，內存已經撐爆了，任務自然沒法完成，此時我們有幾種辦法進行優化：

進程的啟動方法有三種，可參考官方文檔：

[圖片上傳失敗...(image-48cd3c-1650511153989)]

在linux環境下，使用forkserver可以節省很多的內存空間， 因為進程啟動的是一個服務，不會把主進程的數據全部復制

採用imap會極大的節省空間，它返回的是一個迭代器，也就是結果列表：

但注意，以上寫法中，你寫的結果迭代部分必須寫在with下面。或者採用另一種寫法：

還有最後一種，當你的mission list實在太大了，導致你在生成 mission list的時候已經把內存撐爆了，這個時候就得優化 mission_list了，如果你的mission_list是通過一個for循環生成的，你可以使用yield欄位，將其封裝為一個迭代器，傳入進程池：

這樣子，我們就封裝好了mission_list，它是一個可迭代對象，在取數據的時候才會將數據拉到內存

我在項目中結合了後兩種方法，原本256G的內存都不夠用，但在修改後內存只佔用了不到10G。希望能夠幫助到你

㈧ 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關鍵字不變色需要清理系統緩存，是由於內存緩存不足，軟體無法正常運行導致，重啟軟體即可。