Hogyan lehet megtalálni a Python-kód memóriafelhasználási profilját

Mivel a Pythonban „egynél több módszer létezik”, a leginkább memóriatakarékos megközelítés megtalálása bizonyos feladatokhoz kihívást jelenthet. Ebben a memóriaprofilozó segíthet. A szivárgások nyomon követése mellett a kód memóriaprofiljának becslése segít meghatározni, hogy melyik kód memóriatakarékos.

Függetlenül attól, hogy gépi tanulási modellt vagy webhelyet fejleszt Python segítségével, megbecsülheti a szkriptek, egyedi kódsorok vagy funkciók memóriaprofilját.

A teljes kódbázis memóriaprofiljának becslése nem lehet praktikus, mivel ez jelentősen lelassíthatja az alkalmazást. A legjobb, ha szelektíven profilozza azokat a funkciókat vagy módszereket, amelyekről úgy gondolja, hogy több memóriát fogyasztanak. De még akkor is, ha ezt az egész alkalmazásra szeretné megtenni, érdemes egy elkülönített modult szánni ennek kezelésére.

A Pythonban számos profilozó könyvtár található. A legnépszerűbbek közül néhány

memóriaprofil, psutil, Tracemalloc, és pympler. Ez az oktatóanyag használja memóriaprofil és psutil.

Míg psutil ideális egy metódus vagy függvény végrehajtása teljes memóriafelhasználásának becslésére, memóriaprofil részletesebb memóriahasználati információkat ad, beleértve a soronkénti és a funkcionális szintű használati trendeket az idő múlásával.

Az indításhoz telepítse memóriaprofil a Python virtuális környezetébe. Ez is telepíti psutil.

pip install memory_profiler

Szerezze meg a memóriában lévő objektum méretét

A memóriaprofilozást úgy indíthatja el, hogy először kiszámítja a memóriában használni kívánt objektum méretét.

Ez a fajta profilozás a fejlesztés kezdetén hasznos, amikor megpróbálja meghatározni, hogy melyik objektumtípust használja a programban.

Például, ha elakad annak eldöntésében, hogy melyik módszert használja egy feladat elvégzésére, mondjuk a megfelelőt Python adattípus, lekérheti az egyes méreteket bájtokban, hogy meghatározza, melyik a könnyebb az Ön számára ügy.

A sys.getsizeof itt jól jön a beépített módszer:

import sys
nyomtatás(f" lista mérete: {sys.getsizeof([])} bájt")
nyomtatás(f"szótár mérete: {sys.getsizeof (dict)} bájt")
nyomtatás(f" sor mérete: {sys.getsizeof(())} bájt")
nyomtatás(f" beállított méret: {sys.getsizeof({})} bájt")

Íme a kimenet:

Használhatja a sys.getsizeof módszer a beépített és az egyéni függvény memóriaméretének összehasonlítására.

Például hasonlítsa össze ezt az egyéni hosszúságú függvényt Python for ciklust használ a beépítettvel len funkció:

import sys
defgetLength(iterálható):
 szám = 0
számára én ban ben iterálható:
 szám +=1
Visszatérés számol
nyomtatás(f"Beépített hossz funkció: {sys.getsizeof (len)} bájt")
nyomtatás(f"Egyéni hosszúságú függvény: {sys.getsizeof (getLength)} bájt")

A fenti kód a következő kimenetet adja:

Azonban miközben sys.getsizeof méri egy objektum méretét a memóriában, csak magát az objektumot veszi figyelembe, és nem a rá hivatkozókat. Ehhez részletesebb profilalkotási módszerre lesz szüksége.

Keresse meg egy Python-függvény memóriaprofilját

A funkció minden kódsoráról részletesebb memóriaprofilt kaphat a memóriaprofil csomag. Ez magában foglalja a @profil lakberendező az Ön funkciójához vagy módszeréhez:

import pandákat
import numpy
memória_profil importálási profilból
osztály manipulálása:
 @profil
 def manipulateData (self):
 df = pandák. DataFrame({
 'A' :[0, 3, numpy.nan, 10, 3, numpy.nan], 
 'B': [numpy.nan, "Pandas", numpy.nan, "Pandas", "Python", "JavaScript"], 
 })
 df.fillna (method='bfill', inplace=True)
 df.fillna (method='ffill', inplace=True)
 return str (df)
manip = Manipulálás()
nyomtatás (manip.manipulateData())

A fenti kód részletes memóriaprofilt ad az egyes kódsorokról a függvényben, az ábrán látható módon:

A Mem használat oszlop egy adott kódsor memóriahasználatát jelzi, míg a Növekedés oszlop az egyes sorok által fizetett rezsi összeget mutatja. A Esemény oszlop határozza meg, hogy egy kódsor hányszor foglal le vagy szabadít fel memóriát.

Például a fenti kimenetben a 11. sor kétszer fordult elő 0,1 MiB (Mebibyte) memórianövekedéssel, ami 55,4 MiB-ra növelte a memóriahasználatot. A 19. és 22. sor szintén 0,2 MiB-tal, illetve 0,3 MiB-tal járult hozzá, így a memóriahasználat összesen 55,9 MiB-ot tett ki.

Keresse meg egy Python-szkript memóriaprofilját időbélyeggel

A teljes Python-szkript memóriaprofilját is megbecsülheti a memóriaprofil futtatásával a mprof parancs a terminálban az ábrán látható módon:

mprof futtassa a script_name.py fájlt

A fenti parancs 0,1 másodpercenként mintát vesz a megadott szkriptből, és automatikusan létrehozza a .dat fájlt az aktuális projektkönyvtárban.

Az alábbi ábrák a MEM A jelölések a Python-szkript memóriahasználati profiljai egy adott időintervallumban. A jobb oldali utolsó számok azt az időbélyeget jelentik, amelyet a profilkészítő rögzített az egyes memóriahasználatokhoz.

A memóriaprofil diagramját is megkaphatja. Ehhez a telepítés szükséges matplotlib:

pip install matplotlib

A telepítés után futtassa a mprof parancsoljon így:

mprof telek

Íme a kimenet ebben az esetben:

Futtassa a Script memóriaprofilt egy dedikált Python-fájlban

Előfordulhat, hogy különböző Python-szkriptekhez szeretne profilt készíteni. Meg tudod csinálni dedikált Python modul használatával Pythonon keresztül részfolyamat.

Így elválaszthatja a memóriaprofilozót a kódbázistól, és a grafikon kimenetét helyileg mentheti:

import részfolyamat
subprocess.run([
"mprof", 'fuss', '--beleértve-gyerekek', "missing.py"
])
# mentse el a plot outputot helyileg
subprocess.run(["mprof", 'cselekmény', "--output=output.jpg"])

A szkript memóriaprofiljának futtatásához csak a fenti kódot tartalmazó Python-fájlt kell futtatnia. Ez létrehoz egy memóriaprofil diagramot (output.jpg) a fájlkönyvtárban:

Keresse meg a függvényvégrehajtás során felhasznált memória mennyiségét

Egy metódus vagy függvény teljes memóriaprofilját a végrehajtás során találhatja meg a psutil csomag.

Például az előző profiljához Pandas DataFrame manipuláció metódus egy másik Python-fájlban:

import psutil
import sys
import os
sys.path.append (sys.path[0] + "/..")
# importálja a metódusát tartalmazó osztályt
tól től valami kód.hiányzik import Manipulálni
# példányosítsa az osztályt
manip = Manipulálás()
folyamat = psutil. Folyamat (os.getpid())
kezdeti_memória = process.memory_info().rss
# futtassa a célmódszert:
manip.manipulateData()
# végrehajtás után megkapja a memóriainformációkat
final_memory = process.memory_info().rss
memória_felhasznált = végső_memória – kezdeti_memória
memory_consumed_mb = memória_felhasznált / (1024 * 1024)
nyomtatás(f"A függvény által felhasznált memória: {memory_consumed_mb:.2f} MB")

A fentiek a metódus teljes memóriaprofilját becsülik megabájtban (MB), az alábbi módon:

Keresse meg egy kódsor memóriaprofilját a Jupyter Notebookban

Ha az iPythont használja a Jupyter Notebookban, akkor kiszámíthatja az egysoros memóriaprofilt a memóriaprofil. Csak tölteni kell memóriaprofil egy cellában. Ezután adjuk hozzá a %memit mágikus funkciót a kódhoz a következő cellákban; ez visszaadja a kód csúcsmemóriáját és megnövekedett méretét.

Ez a módszer nem működik normál Python-szkriptekkel, kivéve az iPythont a Jupyter Notebookban.

Például:

Használhatja a %memit mágikus funkció a Jypyter Notebookban a függvény memóriájának profilálásához futás közben:

Javítsa a memória hatékonyságát Python-kódjában

Figyelembe véve azokat a nagy teherbírású adatfeltöltési feladatokat, amelyekhez gyakran használjuk a Pythont, minden kódsort megfelelő optimalizálással kell kezelni a memóriahasználat kezeléséhez. Míg a Python számos beépített Python-függvényt tartalmaz, a nem hivatkozott objektumok memóriaszivárgást okoznak.

Ha minden működő Python-szintaxist kihagyott a kódbázisba anélkül, hogy figyelembe vette volna a memóriahasználatot, érdemes visszanéznie, mielőtt túl messzire megy.