python釋放資源

⑴ python如何讓程序一直運行且內存資源自動釋放

這當然是和代碼寫法有關，不貼出來就無法解決

⑵ python如何清理內存

引用計數，這是 Python 的垃圾回收策略。補充一下。

解釋器（也就是你說的 Shell）負責跟蹤對象的引用計數，垃圾收集器負責釋放內存。

如何釋放？可以通過銷毀對象的引用，使引用計數減少至 0。假設 x = 3，以下情況會使 3 這個整型對象的引用計數減少；

函數運行結束，所有局部變數都被銷毀，對象的引用計數也就隨之減少。例如 foo(x) 運行結束，x 被銷毀；當變數被賦值給另一個對象
時，原對象的引用計數也會減少。例如 x = 4，這時候 3 這個對象的引用計數就減 1 了；

使用 del 刪除一個變數也會導致對象引用減少。例如 del x；

對象從集合對象中移除。例如 lst.remove(x)；

包含對象的集合對象被銷毀。例如 del lst；

這些操作都可能使對象變成垃圾回收對象，由垃圾收集器負責收集，當然垃圾收集器也負責處理循環引用對象。
推薦學習《python教程》。

⑶ python定義清理行為的使用

8.6. 定義清理行為
try 語句還有另一個可選的子句，目的在於定義在任何情況下都一定要執行的功能。例如:
>>> try:
... raise KeyboardInterrupt
... finally:
... print('Goodbye, world!')
Goodbye, world!
KeyboardInterrupt
Traceback (most recent call last):
File "
", line 2, in ?
不管有沒有發生異常，finally子句 在程序離開 try 後都一定會被執行。當 try 語句中發生了未被 except 捕獲的異常（或者它發生在 except 或 else 子句中），在 finally 子句執行完後它會被重新拋出。 try 語句經由 break ，continue 或 return 語句退 出也一樣會執行 finally 子句。以下是一個更復雜些的例子:
>>> def divide(x, y):
... try:
... result = x / y
... except ZeroDivisionError:
... print("division by zero!")
... else:
... print("result is", result)
... finally:
... print("executing finally clause")
>>> divide(2, 1)
result is 2
executing finally clause
>>> divide(2, 0)
division by zero!
executing finally clause
>>> divide("2", "1")
executing finally clause
Traceback (most recent call last):
File "
", line 1, in ?
File "
", line 3, in divide
TypeError: unsupported operand type(s) for /: 'str' and 'str'
如你所見， finally 子句在任何情況下都會執行。TypeError 在兩個字元串相除的時候拋出，未被 except 子句捕獲，因此在 finally 子句執行完畢後重新拋出。
在真實場景的應用程序中，finally 子句用於釋放外部資源（文件 或網路連接之類的），無論它們的使用過程中是否出錯。
8.7. 預定義清理行為
有些對象定義了標準的清理行為，無論對象操作是否成功，不再需要該對象的時候就會起作用。以下示例嘗試打開文件並把內容列印到屏幕上。
for line in open("myfile.txt"):
print(line)
這段代碼的問題在於在代碼執行完後沒有立即關閉打開的文件。這在簡單的腳本里沒什麼，但是大型應用程序就會出問題。with 語句使得文件之類的對象可以 確保總能及時准確地進行清理。
with open("myfile.txt") as f:
for line in f:
print(line)
語句執行後，文件 f 總會被關閉，即使是在處理文件中的數據時出錯也一樣。其它對象是否提供了預定義的清理行為要查看它們的文檔。
Next Previous

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

⑸ Python 在打開文件後為什麼要close（），如果不關有什麼危害

close()是為了釋放資源。
如果不close()，那就要等到垃圾回收時，自動釋放資源。垃圾回收的時機是不確定的，也無法控制的。

如果程序是一個命令，很快就執行完了，那麼可能影響不大（注意：並不是說就保證沒問題）。
但如果程序是一個服務，或是需要很長時間才能執行完，或者很大並發執行，就可能導致資源被耗盡，也有可能導致死鎖。

⑹ 如何手動釋放Python的內存

象的引用計數減少；

函數運行結束，所有局部變數都被銷毀，對象的引用計數也就隨之減少。例如 foo(x) 運行結束，x 被銷毀；
當變數被賦值給另一個對象時，原對象的引用計數也會減少。例如 x = 4，這時候 3 這個對象的引用計數就減 1 了；

使用 del 刪除一個變數也會導致對象引用減少。例如 del x；

對象從集合對象中移除。例如 lst.remove(x)；

包含對象的集合對象被銷毀。例如 del lst；
這些操作都可能使對象變成垃圾回收對象，由垃圾收集器負責收集，當然垃圾收集器也負責處理循環引用對象。
要立即釋放，可以使用下面的代碼
import gc
gc.collect()

⑺ python中可以用del釋放資源

del是刪除對象
一般都是自動垃圾回收

⑻ 如何在Python中打開文件後釋放內存

f = open('name', 'r', 'utf-8')
do something
f.close()

⑼ python 怎麼在循環中釋放內存

python 怎麼在循環中釋放內存
#include"stdio.h"
main()
{
char st[15];
printf("input string:\n");
gets(st);
puts(st);
}
可以看出當輸入的字元串中含有空格時，輸出仍為全部字元串。說明gets函數並不以空格作為字元串輸入結束的標志，而只以回車作為輸入結束。這是與scanf函數不同的。
3. 字元串連接函數strcat
格式： strcat (字元數組名1，字元數組名2)
功能：把字元數組2中的字元串連接到字元數組1 中字元串的後面，並刪去字元串1後的串標志「\0」。本函數返回值是字元數組1的首地址。
【例7.14】