20220225

https://mp.weixin.qq.com/s/94SmSNEkwmz-Eu-hBUo0Lg
Python的內存管理機制

在windows 中直接在任務管理其中關掉python 進程就好了

https://blog.csdn.net/qq_36387683/article/details/102746501
tasklit findstr “python”
4.通過查看占用端口號的進程，可以直接殺掉進程，
命令行使用taskkill /PID 進程號 -F -T
/PID processid 指定要終止的進程的 PID。
/F 指定強制終止進程。
/T 終止指定的進程和由它啟用的子進程

linux下也一樣

python話說會自己管理內存，實際上，對于占用很大內存的對象，并不會馬上釋放。舉例，a=range(10000*10000)，會發現內存飆升一個多G，del a 或者a=[]都不能將內存降下來。。

del 可以刪除多個變量，del a,b,c,d
辦法：
import gc （garbage collector）
del a
gc.collect()

馬上內存就釋放了。

在IPython中用run運行程序時，都是在獨立的運行環境中運行，結束之后才將程序運行環境中的結果復制到IPython環境中，因此不會有變量被重復調用的問題。

如果你是指在自己的程序中想刪除所有全局變量的話，可以自己編寫一個clear函數，通過globals()獲取全局變量然后將其中不需要的內容刪除，例如下面的程序保留函數，類，模塊，刪除所有其它全局變量：

def clear():

? ? for key, value in globals().items():

? ? ? ? if callable(value) or value.__class__.__name__ == "module":

? ? ? ? ? ? continue

? ? ? ? del globals()[key]

不過程序中應該避免這種對全局變量的依賴。你也可以在IPython下用此函數清空全局變量。

以下參考：http://www.cnblogs.com/CBDoctor/p/3781078.html

先從較淺的層面來說，Python的內存管理機制可以從三個方面來講

（1）垃圾回收

（2）引用計數

（3）內存池機制

一、垃圾回收：

python不像C++，Java等語言一樣，他們可以不用事先聲明變量類型而直接對變量進行賦值。對Python語言來講，對象的類型和內存都是在運行時確定的。這也是為什么我們稱Python語言為動態類型的原因（這里我們把動態類型可以簡單的歸結為對變量內存地址的分配是在運行時自動判斷變量類型并對變量進行賦值）。

二、引用計數：

Python采用了類似Windows內核對象一樣的方式來對內存進行管理。每一個對象，都維護這一個對指向該對對象的引用的計數。如圖所示（圖片來自Python核心編程）

、

x = 3.14

y = x

?

我們首先創建了一個對象3.14， 然后將這個浮點數對象的引用賦值給x，因為x是第一個引用，因此，這個浮點數對象的引用計數為1. 語句y = x創建了一個指向同一個對象的引用別名y，我們發現，并沒有為Y創建一個新的對象，而是將Y也指向了x指向的浮點數對象，使其引用計數為2.

我們可以很容易就證明上述的觀點：

?

變量a 和 變量b的id一致(我們可以將id值想象為C中變量的指針).

我們援引另一個網址的圖片來說明問題：對于C語言來講，我們創建一個變量A時就會為為該變量申請一個內存空間，并將變量值?放入該空間中,當將該變量賦給另一變量B時會為B申請一個新的內存空間，并將變量值放入到B的內存空間中，這也是為什么A和B的指針不一致的原因。如圖：

??????????????

?int A = 1?????????????????????? int A = 2

而Python的情況卻不一樣，實際上，Python的處理方式和Javascript有點類似，如圖所示，變量更像是附在對象上的標簽(和引用的定義類似)。當變量被綁定在一個對象上的時候，該變量的引用計數就是1，(還有另外一些情況也會導致變量引用計數的增加),系統會自動維護這些標簽，并定時掃描，當某標簽的引用計數變為0的時候，該對就會被回收。

??????????????????? ???

????? a = 1?????????????????????????a = 2???????????????????????? b = a

?

?三、內存池機制

?

Python的內存機制以金字塔行，-1，-2層主要有操作系統進行操作，

　　第0層是C中的malloc，free等內存分配和釋放函數進行操作；

　　第1層和第2層是內存池，有Python的接口函數PyMem_Malloc函數實現，當對象小于256K時有該層直接分配內存；

　　第3層是最上層，也就是我們對Python對象的直接操作；

在 C 中如果頻繁的調用 malloc 與 free 時,是會產生性能問題的.再加上頻繁的分配與釋放小塊的內存會產生內存碎片. Python 在這里主要干的工作有:

　　如果請求分配的內存在1~256字節之間就使用自己的內存管理系統,否則直接使用 malloc.

　　這里還是會調用 malloc 分配內存,但每次會分配一塊大小為256k的大塊內存.

　　經由內存池登記的內存到最后還是會回收到內存池,并不會調用 C 的 free 釋放掉.以便下次使用.對于簡單的Python對象，例如數值、字符串，元組（tuple不允許被更改)采用的是復制的方式(深拷貝?)，也就是說當將另一個變量B賦值給變量A時，雖然A和B的內存空間仍然相同，但當A的值發生變化時，會重新給A分配空間，A和B的地址變得不再相同

而對于像字典(dict)，列表(List)等，改變一個就會引起另一個的改變，也稱之為淺拷貝

附：

引用計數增加

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)。

以下摘自vamei：http://www.cnblogs.com/vamei/p/3232088.html

在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。

當垃圾回收啟動時，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)

總結

以上是生活随笔為你收集整理的垃圾回收 内存管理 python的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。