❶ 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 的內存管理機制
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垃圾回收的簡單介紹，當然，深入研究肯定不止這些內容，目前，了解到這個程度也足夠了。
❸ Python3 & TCP協議和UDP協議的特點和區別
優點：
（1）TCP是面向連接的運輸層協議；
（2）每一條TCP連接只能有兩個端點（即兩個套接字），只能是點對點的；
（3）TCP提供可靠的傳輸服務。傳送的數據無差錯、不丟失、不重復、按序到達；
（4）TCP提供全雙工通信。允許通信雙方的應用進程在任何時候都可以發送數據，因為兩端都設有發送緩存和接受緩存；
（5）面向位元組流。雖然應用程序與TCP交互是一次一個大小不等的數據塊，但TCP把這些數據看成一連串無結構的位元組流，它不保證接收方收到的數據塊和發送方發送的數據塊具有對應大小關系，例如，發送方應用程序交給發送方的TCP10個數據塊，但就受訪的TCP可能只用了4個數據塊久保收到的位元組流交付給上層的應用程序，但位元組流完全一樣。
缺點：
慢，效率低，佔用系統資源高，易被攻擊 TCP在傳遞數據之前，要先建連接，這會消耗時間，在數據傳遞時，確認機制、重傳機制、擁塞控制機制等都會消耗大量的時間，而且要在每台設備上維護所有的傳輸連接。事實上，每個連接都會佔用系統的CPU、內存等硬體資源。因為TCP有確認機制、三次握手機制，這些也導致TCP容易被人利用，實現DOS、DDOS、CC等攻擊。
TCP的應用場景:
當對網路通訊質量有要求的時候。例如：整個數據要准確無誤的傳遞給對方，這往往用於一些要求可靠的應用。如：用於文件傳輸（FTP HTTP 對數據准確性要求高，速度可以相對慢），發送或接收郵件（POP IMAP SMTP 對數據准確性要求高，非緊急應用），遠程登錄（TELNET SSH 對數據准確性有一定要求，有連接的概念）等等。
優點：
（1）UDP是無連接的傳輸層協議；
（2）UDP使用盡最大努力交付，不保證可靠交付；
（3）UDP是面向報文的，對應用層交下來的報文，不合並，不拆分，保留原報文的邊界；
（4）UDP沒有擁塞控制，因此即使網路出現擁塞也不會降低發送速率；
（5）UDP支持一對一一對多多對多的交互通信；
（6）UDP的首部開銷小，只有8位元組．
缺點：
不可靠，不穩定。 因為UDP沒有TCP那些可靠的機制，在數據傳遞時，如果網路質量不好，就會很容易丟包。
UDP的應用場景：
當對網路通訊質量要求不高的時候，要求網路通訊速度能盡量的快，這時就可以使用UDP。 UDP一般用於即時通信（QQ聊天 對數據准確性和丟包要求比較低，但速度必須快），在線視頻（RTSP 速度一定要快，保證視頻連續，但是偶爾花了一個圖像幀，人們還是能接受的），網路語音電話（VoIP 語音數據包一般比較小，需要高速發送，偶爾斷音或串音也沒有問題）等等。
（1）TCP面向連接（如打電話要先撥號建立連接）;UDP是無連接的，即發送數據之前不需要建立連接
（2）TCP提供可靠的服務。也就是說，通過TCP連接傳送的數據，無差錯，不丟失，不重復，且按序到達;UDP盡最大努力交付，即不保證可靠交付
（3）TCP面向位元組流，實際上是TCP把數據看成一連串無結構的位元組流;UDP是面向報文的UDP沒有擁塞控制，因此網路出現擁塞不會使源主機的發送速率降低（對實時應用很有用，如IP電話，實時視頻會議等）
（4）每一條TCP連接只能是點到點的;UDP支持一對一，一對多，多對一和多對多的交互通信
（5）TCP首部開銷20位元組;UDP的首部開銷小，只有8個位元組
（6）TCP的邏輯通信信道是全雙工的可靠信道，UDP則是不可靠信道
HTTP、HTTPS、FTP、TELNET、SMTP(簡單郵件傳輸協議)協議基於可靠的TCP協議。TFTP、DNS、DHCP、TFTP、SNMP(簡單網路管理協議)、RIP基於不可靠的UDP協議
❹ 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大數據， 一些簡單的操作
#coding:utf-8
#file: FileSplit.py
import os,os.path,time
def FileSplit(sourceFile, targetFolder):
sFile = open(sourceFile, 'r')
number = 100000 #每個小文件中保存100000條數據
dataLine = sFile.readline()
tempData = [] #緩存列表
fileNum = 1
if not os.path.isdir(targetFolder): #如果目標目錄不存在，則創建
os.mkdir(targetFolder)
while dataLine: #有數據
for row in range(number):
tempData.append(dataLine) #將一行數據添加到列表中
dataLine = sFile.readline()
if not dataLine :
break
tFilename = os.path.join(targetFolder,os.path.split(sourceFile)[1] + str(fileNum) + ".txt")
tFile = open(tFilename, 'a+') #創建小文件
tFile.writelines(tempData) #將列表保存到文件中
tFile.close()
tempData = [] #清空緩存列表
print(tFilename + " 創建於: " + str(time.ctime()))
fileNum += 1 #文件編號
sFile.close()
if __name__ == "__main__" :
FileSplit("access.log","access")
#coding:utf-8
#file: Map.py
import os,os.path,re
def Map(sourceFile, targetFolder):
sFile = open(sourceFile, 'r')
dataLine = sFile.readline()
tempData = {} #緩存列表
if not os.path.isdir(targetFolder): #如果目標目錄不存在，則創建
os.mkdir(targetFolder)
while dataLine: #有數據
p_re = re.compile(r'(GET|POST)\s(.*?)\sHTTP/1.[01]',re.IGNORECASE) #用正則表達式解析數據
match = p_re.findall(dataLine)
if match:
visitUrl = match[0][1]
if visitUrl in tempData:
tempData[visitUrl] += 1
else:
tempData[visitUrl] = 1
dataLine = sFile.readline() #讀入下一行數據
sFile.close()
tList = []
for key,value in sorted(tempData.items(),key = lambda k:k[1],reverse = True):
tList.append(key + " " + str(value) + '\n')
tFilename = os.path.join(targetFolder,os.path.split(sourceFile)[1] + "_map.txt")
tFile = open(tFilename, 'a+') #創建小文件
tFile.writelines(tList) #將列表保存到文件中
tFile.close()
if __name__ == "__main__" :
Map("access\\access.log1.txt","access")
Map("access\\access.log2.txt","access")
Map("access\\access.log3.txt","access")
#coding:utf-8
#file: Rece.py
import os,os.path,re
def Rece(sourceFolder, targetFile):
tempData = {} #緩存列表
p_re = re.compile(r'(.*?)(\d{1,}$)',re.IGNORECASE) #用正則表達式解析數據
for root,dirs,files in os.walk(sourceFolder):
for fil in files:
if fil.endswith('_map.txt'): #是rece文件
sFile = open(os.path.abspath(os.path.join(root,fil)), 'r')
dataLine = sFile.readline()
while dataLine: #有數據
subdata = p_re.findall(dataLine) #用空格分割數據
#print(subdata[0][0]," ",subdata[0][1])
if subdata[0][0] in tempData:
tempData[subdata[0][0]] += int(subdata[0][1])
else:
tempData[subdata[0][0]] = int(subdata[0][1])
dataLine = sFile.readline() #讀入下一行數據
sFile.close()
tList = []
for key,value in sorted(tempData.items(),key = lambda k:k[1],reverse = True):
tList.append(key + " " + str(value) + '\n')
tFilename = os.path.join(sourceFolder,targetFile + "_rece.txt")
tFile = open(tFilename, 'a+') #創建小文件
tFile.writelines(tList) #將列表保存到文件中
tFile.close()
if __name__ == "__main__" :
Rece("access","access")
❻ python怎麼進行內存管理的
Python作為一種動態類型的語言，其對象和引用分離。這與曾經的面向過程語言有很大的區別。為了有效的釋放內存，Python內置了垃圾回收的支持。Python採取了一種相對簡單的垃圾回收機制，即引用計數，並因此需要解決孤立引用環的問題。Python與其它語言既有共通性，又有特別的地方。對該內存管理機制的理解，是提高Python性能的重要一步。