python回收

⑴ 如何理解和掌握python垃圾回收機制

現在的高級語言如java，c#等，都採用了垃圾收集機制，而不再是c，c++里用戶自己管理維護內存的方式。自己管理內存極其自由，可以任意申請內存，但如同一把雙刃劍，為大量內存泄露，懸空指針等bug埋下隱患。
對於一個字元串、列表、類甚至數值都是對象，且定位簡單易用的語言，自然不會讓用戶去處理如何分配回收內存的問題。

⑵ 請問各位大佬用python怎麼讀取回收站然後刪除所有回收站里的文件

您好，對於你的遇到的問題，我很高興能為你提供幫助，我之前也遇到過喲，以下是我的個人看法，希望能幫助到你，若有錯誤，還望見諒！。os包的rmdir()函數可以用來刪除一個文件夾，但是文件夾必須是空的。一種可行的方法是讀取文件夾的文件列表，逐個刪除文件夾中的所有文件，然而文件夾中可能還有文件夾，因此這是一個遞歸的操作。
shutil包rmtree()函數就實現了以上功能。shutil是一個高級文件操作的包，實現了文件及文件集合復制與刪除的功能。rmtree()函數接收非空文件夾的路徑這唯一一個參數。示例代碼如下：
import shutil
path = 'g:\'
shutil.rmtree(path)非常感謝您的耐心觀看，如有幫助請採納，祝生活愉快！謝謝！

⑶ Python協程池執行完後怎麼回收

學習python可以去專業機構學，還有項目可以實踐。更有利於個人未來發展更好

⑷ python的回收機制是什麼

Python中的垃圾回收機制總體上有三種，

引用計數

Python語言默認採用的垃圾收集機制是『引用計數法 Reference Counting』，該演算法最早George E. Collins在1960的時候首次提出，50年後的今天，該演算法依然被很多編程語言使用，『引用計數法』的原理是：每個對象維護一個ob_ref欄位，用來記錄該對象當前被引用的次數，每當新的引用指向該對象時，它的引用計數ob_ref加1，每當該對象的引用失效時計數ob_ref減1，一旦對象的引用計數為0，該對象立即被回收，對象佔用的內存空間將被釋放。它的缺點是需要額外的空間維護引用計數，這個問題是其次的，不過最主要的問題是它不能解決對象的「循環引用」，因此，也有很多語言比如Java並沒有採用該演算法做來垃圾的收集機制。

在上圖中，我們把小黑圈視為全局變數，也就是把它作為root object，從小黑圈出發，對象1可直達，那麼它將被標記，對象2、3可間接到達也會被標記，而4和5不可達，那麼1、2、3就是活動對象，4和5是非活動對象會被GC回收。

標記清除演算法作為Python的輔助垃圾收集技術主要處理的是一些容器對象，比如list、dict、tuple，instance等，因為對於字元串、數值對象是不可能造成循環引用問題。Python使用一個雙向鏈表將這些容器對象組織起來。不過，這種簡單粗暴的標記清除演算法也有明顯的缺點：清除非活動的對象前它必須順序掃描整個堆內存，哪怕只剩下小部分活動對象也要掃描所有對象。

分代回收

分代回收是一種以空間換時間的操作方式，Python將內存根據對象的存活時間劃分為不同的集合，每個集合稱為一個代，Python將內存分為了3「代」，分別為年輕代（第0代）、中年代（第1代）、老年代（第2代），他們對應的是3個鏈表，它們的垃圾收集頻率與對象的存活時間的增大而減小。新創建的對象都會分配在年輕代，年輕代鏈表的總數達到上限時，Python垃圾收集機制就會被觸發，把那些可以被回收的對象回收掉，而那些不會回收的對象就會被移到中年代去，依此類推，老年代中的對象是存活時間最久的對象，甚至是存活於整個系統的生命周期內。同時，分代回收是建立在標記清除技術基礎之上。分代回收同樣作為Python的輔助垃圾收集技術處理那些容器對象。

Python垃圾回收機制--完美講解! 東皇Amrzs

Python中的垃圾回收機制

⑸ python的簡單問題

要把代碼發現來才知道，以下是常見的錯誤下面終於要講到當你用到更多的Python的功能（數據類型，函數，模塊，類等等）時可能碰到的問題了。由於篇幅有限，這里盡量精簡，尤其是對一些高級的概念。要想了解更多的細節，敬請閱讀Learning Python, 2nd Edition的逗小貼士地以及逗Gotchas地章節。 打開文件的調用不使用模塊搜索路徑當你在Python中調用open()來訪問一個外部的文件時，Python不會使用模塊搜索路徑來定位這個目標文件。它會使用你提供的絕對路徑，或者假定這個文件是在當前工作目錄中。模塊搜索路徑僅僅為模塊載入服務的。不同的類型對應的方法也不同列表的方法是不能用在字元串上的，反之亦然。通常情況下，方法的調用是和數據類型有關的，但是內部函數通常在很多類型上都可以使用。舉個例子來說，列表的reverse方法僅僅對列表有用，但是len函數對任何具有長度的對象都適用不能直接改變不可變數據類型記住你沒法直接的改變一個不可變的對象（例如，元組，字元串）： T = (1, 2, 3) T[2] = 4 # 錯誤 用切片，聯接等構建一個新的對象，並根據需求將原來變數的值賦給它。因為Python會自動回收沒有用的內存，因此這沒有看起來那麼浪費： T = T[:2] + (4,) # 沒問題了: T 變成了 (1, 2, 4) 使用簡單的for循環而不是while或者range 當你要從左到右遍歷一個有序的對象的所有元素時，用簡單的for循環（例如，for x in seq:）相比於基於while-或者range-的計數循環而言會更容易寫，通常運行起來也更快。除非你一定需要，盡量避免在一個for循環里使用range：讓Python來替你解決標號的問題。在下面的例子中三個循環結構都沒有問題，但是第一個通常來說更好；在Python里，簡單至上。 S = "lumberjack" for c in S: print c # 最簡單 for i in range(len(S)): print S[i] # 太多了 i = 0 # 太多了 while i len(S): print S[i]; i += 1 不要試圖從那些會改變對象的函數得到結果諸如像方法list.append()和list.sort()一類的直接改變操作會改變一個對象，但不會將它們改變的對象返回出來（它們會返回None）；正確的做法是直接調用它們而不要將結果賦值。經常會看見初學者會寫諸如此類的代碼： mylist = mylist.append(X) 目的是要得到append的結果，但是事實上這樣做會將None賦值給mylist，而不是改變後的列表。更加特別的一個例子是想通過用排序後的鍵值來遍歷一個字典里的各個元素，請看下面的例子： D = {...} for k in D.keys().sort(): print D[k] 差一點兒就成功了——keys方法會創建一個keys的列表，然後用sort方法來將這個列表排序——但是因為sort方法會返回None，這個循環會失敗，因為它實際上是要遍歷None（這可不是一個序列）。要改正這段代碼，將方法的調用分離出來，放在不同的語句中，如下： Ks = D.keys() Ks.sort() for k in Ks: print D[k] 只有在數字類型中才存在類型轉換在Python中，一個諸如123+3.145的表達式是可以工作的——它會自動將整數型轉換為浮點型，然後用浮點運算。但是下面的代碼就會出錯了： S = "42" I = 1 X = S + I # 類型錯誤 這同樣也是有意而為的，因為這是不明確的：究竟是將字元串轉換為數字（進行相加）呢，還是將數字轉換為字元串（進行聯接）呢看在Python中，我們認為逗明確比含糊好地（即，EIBTI（Explicit is better than implicit）），因此你得手動轉換類型： X = int(S) + I # 做加法: 43 X = S + str(I) # 字元串聯接: "421" 循環的數據結構會導致循環盡管這在實際情況中很少見，但是如果一個對象的集合包含了到它自己的引用，這被稱為循環對象（cyclic object）。如果在一個對象中發現一個循環，Python會輸出一個[…]，以避免在無限循環中卡住： >>> L = ['grail'] # 在 L中又引用L自身會 >>> L.append(L) # 在對象中創造一個循環 >>> L ['grail', [...]] 除了知道這三個點在對象中表示循環以外，這個例子也是很值得借鑒的。因為你可能無意間在你的代碼中出現這樣的循環的結構而導致你的代碼出錯。如果有必要的話，維護一個列表或者字典來表示已經訪問過的對象，然後通過檢查它來確認你是否碰到了循環。賦值語句不會創建對象的副本，僅僅創建引用這是Python的一個核心理念，有時候當行為不對時會帶來錯誤。在下面的例子中，一個列表對象被賦給了名為L的變數，然後L又在列表M中被引用。內部改變L的話，同時也會改變M所引用的對象，因為它們倆都指向同一個對象。 >>> L = [1, 2, 3] # 共用的列表對象 >>> M = ['X', L, 'Y'] # 嵌入一個到L的引用 >>> M ['X', [1, 2, 3], 'Y'] >>> L[1] = 0 # 也改變了M >>> M ['X', [1, 0, 3], 'Y'] 通常情況下只有在稍大一點的程序里這就顯得很重要了，而且這些共用的引用通常確實是你需要的。如果不是的話，你可以明確的給他們創建一個副本來避免共用的引用；對於列表來說，你可以通過使用一個空列表的切片來創建一個頂層的副本： >>> L = [1, 2, 3] >>> M = ['X', L[:], 'Y'] # 嵌入一個L的副本 >>> L[1] = 0 # 僅僅改變了L，但是不影響M >>> L [1, 0, 3] >>> M ['X', [1, 2, 3], 'Y'] 切片的范圍起始從默認的0到被切片的序列的最大長度。如果兩者都省略掉了，那麼切片會抽取該序列中的所有元素，並創造一個頂層的副本（一個新的，不被公用的對象）。對於字典來說，使用字典的dict.()方法。靜態識別本地域的變數名 Python默認將一個函數中賦值的變數名視作是本地域的，它們存在於該函數的作用域中並且僅僅在函數運行的時候才存在。從技術上講，Python是在編譯def代碼時，去靜態的識別本地變數，而不是在運行時碰到賦值的時候才識別到的。如果不理解這點的話，會引起人們的誤解。比如，看看下面的例子，當你在一個引用之後給一個變數賦值會怎麼樣： >>> X = 99 >>> def func(): ... print X # 這個時候還不存在 ... X = 88 # 在整個def中將X視作本地變數 ... >>> func( ) # 出錯了！ 你會得到一個逗未定義變數名地的錯誤，但是其原因是很微妙的。當編譯這則代碼時，Python碰到給X賦值的語句時認為在這個函數中的任何地方X會被視作一個本地變數名。但是之後當真正運行這個函數時，執行print語句的時候，賦值語句還沒有發生，這樣Python便會報告一個逗未定義變數名地的錯誤。事實上，之前的這個例子想要做的事情是很模糊的：你是想要先輸出那個全局的X，然後創建一個本地的X呢，還是說這是個程序的錯誤看如果你真的是想要輸出這個全局的X，你需要將它在一個全局語句中聲明它，或者通過包絡模塊的名字來引用它。默認參數和可變對象在執行def語句時，默認參數的值只被解析並保存一次，而不是每次在調用函數的時候。這通常是你想要的那樣，但是因為默認值需要在每次調用時都保持同樣對象，你在試圖改變可變的默認值（mutable defaults）的時候可要小心了。例如，下面的函數中使用一個空的列表作為默認值，然後在之後每一次函數調用的時候改變它的值： >>> def saver(x=[]): # 保存一個列表對象 ... x.append(1) # 並每次調用的時候 ... print x # 改變它的值 ... >>> saver([2]) # 未使用默認值 [2, 1] >>> saver() # 使用默認值 [1] >>> saver() # 每次調用都會增加！ [1, 1] >>> saver() [1, 1, 1] 有的人將這個視作Python的一個特點——因為可變的默認參數在每次函數調用時保持了它們的狀態，它們能提供像C語言中靜態本地函數變數的類似的一些功能。但是，當你第一次碰到它時會覺得這很奇怪，並且在Python中有更加簡單的辦法來在不同的調用之間保存狀態（比如說類）。要擺脫這樣的行為，在函數開始的地方用切片或者方法來創建默認參數的副本，或者將默認值的表達式移到函數裡面；只要每次函數調用時這些值在函數里，就會每次都得到一個新的對象： >>> def saver(x=None): ... if x is None: x = [] # 沒有傳入參數看 ... x.append(1) # 改變新的列表 ... print x ... >>> saver([2]) # 沒有使用默認值 [2, 1] >>> saver() # 這次不會變了 [1] >>> saver() [1] 其他常見的編程陷阱下面列舉了其他的一些在這里沒法詳述的陷阱：在頂層文件中語句的順序是有講究的：因為運行或者載入一個文件會從上到下運行它的語句，所以請確保將你未嵌套的函數調用或者類的調用放在函數或者類的定義之後。 reload不影響用from載入的名字：reload最好和import語句一起使用。如果你使用from語句，記得在reload之後重新運行一遍from，否則你仍然使用之前老的名字。在多重繼承中混合的順序是有講究的：這是因為對superclass的搜索是從左到右的，在類定義的頭部，在多重superclass中如果出現重復的名字，則以最左邊的類名為准。在try語句中空的except子句可能會比你預想的捕捉到更多的錯誤。在try語句中空的except子句表示捕捉所有的錯誤，即便是真正的程序錯誤，和sys.exit()調用，也會被捕捉到。

⑹ Python的垃圾回收機制（garbage collection）是什麼

這里能說的很多。你應該提到下面幾個主要的點：

Python在內存中存儲了每個對象的引用計數（reference count）。如果計數值變成0，那麼相應的對象就會小時，分配給該對象的內存就會釋放出來用作他用。

偶爾也會出現引用循環（reference cycle）。垃圾回收器會定時尋找這個循環，並將其回收。舉個例子，假設有兩個對象o1和o2，而且符合o1.x == o2和o2.x == o1這兩個條件。如果o1和o2沒有其他代碼引用，那麼它們就不應該繼續存在。但它們的引用計數都是1。來自三人行慕課

Python中使用了某些啟發式演算法（heuristics）來加速垃圾回收。例如，越晚創建的對象更有可能被回收。對象被創建之後，垃圾回收器會分配它們所屬的代（generation）。每個對象都會被分配一個代，而被分配更年輕代的對象是優先被處理的。

⑺ Python垃圾回收機制是什麼樣的

Python垃圾回收機制是通過引用計數來管理的引用計數表示記錄這個對象被引用的次數如果有新的引用指向對象，對象引用計數就加一，引用被銷毀時，對象引用計數減一，當用戶的引用計數為0時，該內存被釋放以上就是Python的垃圾回收機制了 ，在黑馬程序員看過一個視頻，有專門講解的，你可以去看看！謝謝你，如果你有這方面的問題的話，您可以隨時詢問我

⑻ Python里的垃圾回收機制是什麼意思，搞不懂

如果你用C++寫程序的話 有時候需要動態內存 就是在你需要的時候給你分配空間 但是如果你忘記把它釋放或者你把指向那塊內存的指針給搞丟了，那麼那塊內存就不能夠再使用。如果你的程序不斷的申請但又不釋放內存，那麼電腦內存的使用就越來越高。最後直接99% 程序崩潰電腦卡死
但是java就不會了 她回主動幫你釋放不用的內存 就是垃圾回收機制 但是這個回收時間 回收哪裡也是有講究的，這里就不細說了。
總之，java比其他語言比如c c++安全 但是相應的效率就沒有那麼高了
程序 就是個時間空間的交換游戲嘛！

⑼ 為什麼Python工程師很少像Java工程師那樣討論垃圾回收

Python本身的垃圾回收機制優化得非常好，一般來講，不需要再做單獨處理，這也是Python的一大優勢。

⑽ python 什麼時候 垃圾回收

Python中的垃圾回收是以引用計數為主，分代收集為輔。引用計數的缺陷是循環引用的問題。
在Python中，如果一個對象的引用數為0，Python虛擬機就會回收這個對象的內存。
#encoding=utf-8
__author__ = '[email protected]'

class ClassA():
def __init__(self):
print 'object born,id:%s'%str(hex(id(self)))
def __del__(self):
print 'object del,id:%s'%str(hex(id(self)))

def f1():
while True:
c1=ClassA()
del c1

執行f1()會循環輸出這樣的結果，而且進程佔用的內存基本不會變動
object born,id:0x237cf58
object del,id:0x237cf58

c1=ClassA()會創建一個對象，放在0x237cf58內存中，c1變數指向這個內存，這時候這個內存的引用計數是1
del c1後，c1變數不再指向0x237cf58內存，所以這塊內存的引用計數減一，等於0，所以就銷毀了這個對象，然後釋放內存。
1、導致引用計數+1的情況

對象被創建，例如a=23
對象被引用，例如b=a
對象被作為參數，傳入到一個函數中，例如func(a)
對象作為一個元素，存儲在容器中，例如list1=[a,a]

2、導致引用計數-1的情況

對象的別名被顯式銷毀，例如del a
對象的別名被賦予新的對象，例如a=24
一個對象離開它的作用域，例如f函數執行完畢時，func函數中的局部變數（全局變數不會）
對象所在的容器被銷毀，或從容器中刪除對象

demo
def func(c,d):
print 'in func function', sys.getrefcount(c) - 1

print 'init', sys.getrefcount(11) - 1
a = 11
print 'after a=11', sys.getrefcount(11) - 1
b = a
print 'after b=1', sys.getrefcount(11) - 1
func(11)
print 'after func(a)', sys.getrefcount(11) - 1
list1 = [a, 12, 14]
print 'after list1=[a,12,14]', sys.getrefcount(11) - 1
a=12
print 'after a=12', sys.getrefcount(11) - 1
del a
print 'after del a', sys.getrefcount(11) - 1
del b
print 'after del b', sys.getrefcount(11) - 1
# list1.pop(0)
# print 'after pop list1',sys.getrefcount(11)-1
del list1
print 'after del list1', sys.getrefcount(11) - 1

輸出
init 24
after a=11 25
after b=1 26
in func function 28
after func(a) 26
after list1=[a,12,14] 27
after a=12 26
after del a 26
after del b 25
after del list1 24

問題：為什麼調用函數會令引用計數+2
3、查看一個對象的引用計數
sys.getrefcount(a)可以查看a對象的引用計數，但是比正常計數大1，因為調用函數的時候傳入a，這會讓a的引用計數+1
二.循環引用導致內存泄露

def f2():
while True:
c1=ClassA()
c2=ClassA()
c1.t=c2
c2.t=c1
del c1
del c2

執行f2()，進程佔用的內存會不斷增大。
object born,id:0x237cf30
object born,id:0x237cf58

創建了c1，c2後，0x237cf30（c1對應的內存，記為內存1）,0x237cf58（c2對應的內存，記為內存2）這兩塊內存的引用計數都是1，執行c1.t=c2和c2.t=c1後，這兩塊內存的引用計數變成2.
在del c1後，內存1的對象的引用計數變為1，由於不是為0，所以內存1的對象不會被銷毀，所以內存2的對象的引用數依然是2，在del c2後，同理，內存1的對象，內存2的對象的引用數都是1。
雖然它們兩個的對象都是可以被銷毀的，但是由於循環引用，導致垃圾回收器都不會回收它們，所以就會導致內存泄露。
三.垃圾回收

deff3():
# print gc.collect()
c1=ClassA()
c2=ClassA()
c1.t=c2
c2.t=c1
del c1
del c2
print gc.garbage
print gc.collect() #顯式執行垃圾回收
print gc.garbage
time.sleep(10)
if __name__ == '__main__':
gc.set_debug(gc.DEBUG_LEAK) #設置gc模塊的日誌
f3()

輸出：
gc: uncollectable <ClassA instance at 0230E918>
gc: uncollectable <ClassA instance at 0230E940>
gc: uncollectable <dict 0230B810>
gc: uncollectable <dict 02301ED0>
object born,id:0x230e918
object born,id:0x230e940
4

垃圾回收後的對象會放在gc.garbage列表裡面
gc.collect()會返回不可達的對象數目，4等於兩個對象以及它們對應的dict
有三種情況會觸發垃圾回收：

1.調用gc.collect(),
2.當gc模塊的計數器達到閥值的時候。
3.程序退出的時候
四.gc模塊常用功能解析
gc模塊提供一個介面給開發者設置垃圾回收的選項。上面說到，採用引用計數的方法管理內存的一個缺陷是循環引用，而gc模塊的一個主要功能就是解決循環引用的問題。
常用函數：
1、gc.set_debug(flags)
設置gc的debug日誌，一般設置為gc.DEBUG_LEAK
2、gc.collect([generation])
顯式進行垃圾回收，可以輸入參數，0代表只檢查第一代的對象，1代表檢查一，二代的對象，2代表檢查一，二，三代的對象，如果不傳參數，執行一個full collection，也就是等於傳2。
返回不可達（unreachable objects）對象的數目
3、gc.set_threshold(threshold0[, threshold1[, threshold2])
設置自動執行垃圾回收的頻率。
4、gc.get_count()
獲取當前自動執行垃圾回收的計數器，返回一個長度為3的列表
5、gc模塊的自動垃圾回收機制
必須要import gc模塊，並且is_enable()=True才會啟動自動垃圾回收。
這個機制的主要作用就是發現並處理不可達的垃圾對象。
垃圾回收=垃圾檢查+垃圾回收
在Python中，採用分代收集的方法。把對象分為三代，一開始，對象在創建的時候，放在一代中，如果在一次一代的垃圾檢查中，改對象存活下來，就會被放到二代中，同理在一次二代的垃圾檢查中，該對象存活下來，就會被放到三代中。
gc模塊裡面會有一個長度為3的列表的計數器，可以通過gc.get_count()獲取。
例如(488,3,0)，其中488是指距離上一次一代垃圾檢查，Python分配內存的數目減去釋放內存的數目，注意是內存分配，而不是引用計數的增加。例如：
print gc.get_count() # (590, 8, 0)
a = ClassA()
print gc.get_count() # (591, 8, 0)
del a
print gc.get_count() # (590, 8, 0)

3是指距離上一次二代垃圾檢查，一代垃圾檢查的次數，同理，0是指距離上一次三代垃圾檢查，二代垃圾檢查的次數。
gc模快有一個自動垃圾回收的閥值，即通過gc.get_threshold函數獲取到的長度為3的元組，例如(700,10,10)
每一次計數器的增加，gc模塊就會檢查增加後的計數是否達到閥值的數目，如果是，就會執行對應的代數的垃圾檢查，然後重置計數器
例如，假設閥值是(700,10,10)：
當計數器從(699,3,0)增加到(700,3,0)，gc模塊就會執行gc.collect(0),即檢查一代對象的垃圾，並重置計數器為(0,4,0)
當計數器從(699,9,0)增加到(700,9,0)，gc模塊就會執行gc.collect(1),即檢查一、二代對象的垃圾，並重置計數器為(0,0,1)
當計數器從(699,9,9)增加到(700,9,9)，gc模塊就會執行gc.collect(2),即檢查一、二、三代對象的垃圾，並重置計數器為(0,0,0)