a Stackoverflow 2019-es felmérése szerint a Python programozási nyelv 73,1% – os jóváhagyást kapott a fejlesztők körében. A Rust második helyen áll, és továbbra is uralja az Adattudományt és a gépi tanulást(ML).

a Python a fejlesztők kedvence. Ez egy magas szintű nyelv, amely robusztusságáról és alapvető filozófiájáról ismert-egyszerűség a komplexitás felett. A Python alkalmazás teljesítménye azonban egy másik történet. Csakúgy, mint bármely más alkalmazás, megvan a maga része a teljesítményproblémákban.

legtöbbször az APM eszközök, például a Retrace segíthetnek megoldani az alkalmazás teljesítményével kapcsolatos problémákat. De mi van akkor, ha a Python alkalmazás már négy órája fut, és a szervernek nincs memóriája? Ez egy speciális probléma a memória erőforrásokkal.

memóriaszivárgásnak hívják. A fejlesztőknek meg kell találniuk a tettest. Ez az, amikor Python memória profilozók jön.

vizsgáljuk meg tovább.

mik azok a Python memória profilozók?

Az alkalmazások profilozása mindig olyan problémákat tartalmaz, mint a CPU, a memória stb. A Python alkalmazások azonban hajlamosak a memóriakezelési problémákra. Ez elsősorban azért van, mert a Python az Adattudomány és az ML alkalmazásokban alkalmazható, és hatalmas mennyiségű adattal működik. Ezenkívül a Python alapértelmezés szerint a memóriamenedzsment rendszerére támaszkodik, ahelyett, hogy a felhasználóra bízná.

mivel a Python kód konténereken belül működik elosztott feldolgozási keretrendszeren keresztül, minden tároló rögzített mennyiségű memóriát tartalmaz. Ha a kódfuttatás meghaladja a memória korlátot, akkor a tároló megszűnik. Ez az, amikor a fejlesztés memóriahibákat tapasztal.

Ez azonban nem mindig így van. Vannak esetek, amikor a fejlesztők nem tudják, mi folyik itt. Lehet, hogy egy tárgy lóg egy referencián, amikor nem kellene lennie, és idővel felhalmozódik. Amint eléri a csúcspontját, memóriaproblémák jelentkeznek.

a quick-fix megoldás a memória elosztásának növelése. Ez azonban nem praktikus, mivel ez erőforrások pazarlásához vezethet. Ezenkívül veszélyeztetheti az alkalmazás stabilitását a kiszámíthatatlan memóriacsúcsok miatt.

ezért szükségünk van a Python memória profilozók segítségére. A Python memory profilers célja, hogy megtalálja a memóriaszivárgásokat és optimalizálja a memória használatát a Python alkalmazásokban. Az ilyen típusú Python memóriaprofilozók megértik a használt kód és csomagok térhatékonyságát.

Top Python memória profilozók

bár a Python automatikusan kezeli a memóriát, eszközökre van szüksége, mert a hosszú ideig futó Python feladatok sok memóriát fogyasztanak. A legtöbb esetben ezek a feladatok nem adják vissza a memóriát az operációs rendszernek, amíg a folyamat véget nem ér, még akkor sem, ha megfelelően végrehajtja a szemétgyűjtést.

itt található az ismert Python memória profilozók listája:

Pympler

Jean Brouwers, Ludwig Haehne és Robert Schuppenies 2008 augusztusában építették a Pymplert. Bevezették a pympling folyamatát, ahol a Pympler megkapja a Python objektumok méretének és élettartamának részleteit.

Pympler Python memory profiler elemzi a Python objektum memória viselkedését belül egy futó alkalmazás. Ez biztosítja a teljes és önálló Python memória profilalkotás megoldás. Ezenkívül a futásidejű viselkedés lehetséges hibáit vetíti ki, mint például a memory bloat és más “pymples”.”

három különálló modul van a Pympler belsejében.

• az asizeof modul biztosítja a Python objektum méretinformációját.
• a Muppy modul előírja, hogy az on-line monitoring egy Python alkalmazás.
• A Class Tracker modul off-line elemzést nyújt a kiválasztott Python objektumok élettartamáról.

először az asizeof segítségével vizsgáljuk meg, hogy bizonyos Python objektumok mennyi memóriát fogyasztanak.

>>> from pympler import asizeof

>>> obj =

>>> asizeof.asizeof(obj)

>>> print (asizeof.asized(obj, detail=1).formátum())

méret=192 lapos=48

(6, 4) méret=64 lapos=32

‘i’ méret=32 lapos=32

3 Méret=16 lapos=16

2 Méret=16 lapos=16

1 Méret=16 lapos=16

másodszor hajtsuk végre a muppy modult:

>>>>>>allobjects = muppy.get_objects()

>>> len(allObjects)

>>> a pympler import összefoglalójából

>>> I = összefoglaló.összegzés (allObjects)

>>> összefoglaló.print_(sum)

types |	# objects |	total size
========================== |	=========== |	============
str |	13262 |	1.01 MB
dict |	2120 |	659.99 KB
code |	3362 |	343.73 KB
list |	2587 |	247.46 KB
type |	639 |	242.61 KB
tuple |	2069 |	58.83 KB
set |	86 |	44.57 KB
wrapper_descriptor |	1247 |	43.84 KB
builtin_function_or_method |	1014 |	35.65 KB
method_descriptor |	937 |	32.94 KB
abc.ABCMeta |	66 |	32.38 KB
weakref |	818 |	28.76 KB
int |	1612 |	24.72 KB
getset_descriptor |	555 |	17,34 KB
	frozenset |	90 |	16,87 KB

itt megtekintheti az összes Python objektumot egy kupacban a muppy modul segítségével. Felhívhat egy másik összefoglalót, és összehasonlíthatja azt, hogy ellenőrizze, hogy egyes tömbökben van-e memóriaszivárgás. Tudjon meg többet a muppy modulról itt.

a pympler profiler harmadik modulja az Osztálykövető. Nyomon követi az egyes osztályok objektumainak élettartamát. Thus, it provides insight into instantiation patterns and helps developers understand how specific objects contribute to the memory footprint in the long run.

>>> tr = classtracker.ClassTracker()

>>> tr.track_class(Document)

>>> tr.create_snapshot(description=’Snapshot 1′)

>>> doc = create_document()

>>> tr.create_snapshot(description=’Snapshot 2′)

>>> tr.stats.print_summary ()

— összegzés ———————-

Pillanatkép 1 aktív 0 b átlagos pct

Pillanatkép 2 aktív 0 B átlagos pct

—————————

Ha többet szeretne megtudni az Osztálykövetőről, kattintson ide.

Guppy3

a Guppy3 (más néven Heapy) egy Python programozási környezet és egy heap elemző eszközkészlet. Ez egy olyan csomag, amely a következő alcsomagokat tartalmazza:

• stb-Ez egy támogató modul, amely rendelkezik a ragasztó protokoll modullal.
• gsl-a guppy specifikáció nyelvi implementációját tartalmazó alcsomag. Dokumentumokat és teszteket hoz létre egy közös forrásból.
• heapy – a heap analysis toolset objektuminformációkat biztosít a heap-ről, és megjeleníti az információkat.
• készletek-ez Bitkészleteket és csomópontkészleteket tartalmaz.

a Guppy3 a Guppy-PE villája, amelyet Sverker Nilsson épített a Python 2 számára.

Megjegyzés: A Python memóriaprofiler használatához Python 3.5, 3.6, 3.7 vagy 3.8 szükséges. Ez a csomag csak a CPython számára működik. Ezért a pypy és más Python fordító implementációk nem támogatottak. A grafikus böngésző használatához Tkinter is szükséges. Ráadásul a menetvágásnak elérhetőnek kell lennie távoli monitor használatakor.

itt van, hogyan kell kihasználni ezt a Python memória profiler. Pillanatfelvételt készíthet a halomról egy kritikus folyamat előtt és után. Ezután hasonlítsa össze a teljes memóriát, és pontosan meghatározza a közös objektumokon belüli lehetséges memóriacsúcsokat.

>>> from guppy import hpy

>>> h=hpy()

>>> h.heap()

Partition of a set of 34090 objects. Total size = 2366226 bytes.

Index	Count	%	Size	%	Cumulative	%	Kind (class / dict of class)
0	10279	30	666873	28	666873	28	str
1	4697	14	259576	11	926449	39	bytes
2	2413	7	251684	11	1178133	50	types.CodeType
3	6825	20	238084	10	1416217	60	tuple
4	448	1	174868	7	1591085	67	type
5	2208	6	150144	6	1741229	74	function
6	448	1	130964	6	1872193	79	dict of type
7	94	0	83532	4	1955725	83	dict of module
8	242	1	56524	2	2012249	85	dict (no owner)
9	1133	3	40788	2	2053037	87	types.WrapperDescriptorType

<118 more rows. Type e.g. ‘_.more’ to view.>

Memory Profiler

Memory Profiler is a pure Python module that uses the psutil module. Figyeli a Python job folyamat memóriafogyasztását. Ezenkívül soronként elemzi az alkalmazás memóriafelhasználását.

a soronkénti memóriahasználati mód ugyanúgy működik, mint a line_profiler.

1. díszíti azt a funkciót, amelyet profilozni szeretne a @profile funkcióval.
2. a szkriptet egy speciális szkript segítségével futtathatja. Például használjon konkrét argumentumokat a Python tolmácshoz.

a következő példában legyen egy egyszerű függvény, az úgynevezett my_func. Ez a funkció létrehoz egy listát egy meghatározott tartományban.

@profile

def my_func():

a=

for i in range(1000):

a.append(i)

my_func()

This outputs:

Line #	Mem Usage	Increment	Line Contents
1	13.859 MiB	13.859 MiB	@profile
2			def my_func():
3	13.859 MiB	0.000 MiB	a=
4	13.859 MiB	0.000 MiB	I tartományban(1000):
5	13,859 MiB	0,000 MiB	a.append(I)

az első oszlop a profilozott kód sorszáma. A Mem használat a Python tolmács memóriahasználata minden kódfuttatás után. A harmadik oszlop (növekmény) az aktuális sor memóriájának különbségét jelenti az utolsóhoz képest. Az utolsó oszlop (sor tartalma) megjeleníti a profilozott kódokat.

To see how this Python memory profiler works, let’s change the range value to 1000000 in the function above and execute it. Here is the output:

Line #	Mem usage	Increment	Line Contents
1	13.844 MiB	13.844 MiB	@profile
2			def my_func():
3	13.844 MiB	0.000 MiB	a=
4	33.387 MiB	0.016 MiB	I tartományban(1000000):
5	33,387 MiB	0,293 MiB	a.append(I)

a 4.és 5. sor a memóriahasználat növekedését mutatja, bizonyítva, hogy ez a profilozó soronként elemzi a memóriafelhasználást.

Fil

Fil profiler egy nyílt forráskódú Python memória profiler. Alkalmas adatfeldolgozásra és tudományos számítástechnikai alkalmazásokra. Jelenleg még a fejlesztési szakaszban van, és csak Linuxon és macOS-on fut.

a legtöbb adatkutató és Python-fejlesztő memóriaproblémákkal szembesül a Python adatfolyamával. Ha túl sok memóriát használ, nehéz pontosan meghatározni, hogy pontosan hová megy az összes memória.

idézzünk például két forgatókönyvet:

szerverek

mivel a szerverek folyamatosan futnak, a memóriaszivárgás gyakran okozza a teljesítményhibát. A fejlesztők elhanyagolják a kis mennyiségű memóriaszivárgást, mivel a legtöbb szerver egyszerre kis mennyiségű adatot dolgoz fel. Ezek azonban akár több tízezer hívást is elérhetnek. Ennek eredményeként ez idővel súlyos termelési problémákat okozhat.

Adatvezetékek

nagy adatdarabok feldolgozásakor a memóriahasználat megugrása hatalmas veszélyt jelent az adatvezetékekre. Például, ha az alkalmazás jó ideig 1 GB RAM-ot használ, majd hirtelen 16 GB RAM-ra van szüksége. Nagy szükség van annak azonosítására, hogy mi okozza a hirtelen memória tüskéket.

Ez a Fil fő célja―a memóriahasználati tüskék diagnosztizálása, függetlenül a feldolgozott adatok mennyiségétől. Pontosan meghatározza, hogy hol van a csúcs memóriahasználat, és milyen kód felelős a tüskéért.

bár léteznek Python memória profilozók, amelyek mérik a memóriahasználatot, vannak korlátai. Az egyik nagy mennyiségű adat-kötegelt feldolgozás-kezelésével foglalkozik. A Python alkalmazások többnyire kötegelt feldolgozási alkalmazások, amelyekben folyamatosan olvassák az adatokat, feldolgozzák és kiadják az eredményt.

erre a problémára a következő profilozónk válaszol.

Blackfire

egy olyan rendkívül dinamikus nyelv esetében, mint a Python, a legtöbb fejlesztő memóriaproblémákat tapasztal a telepítés során. Ez némi zavart okoz abban, hogy mi történik a memóriahasználattal. A fejlesztők hajlamosak optimalizálni, de nem rendelkeznek a megfelelő eszközökkel.

Blackfire egy szabadalmaztatott Python memória profiler (talán az első. A Python memóriamenedzserét használja a Python által kiosztott összes memóriablokk nyomon követésére, beleértve a C kiterjesztéseket is. A Blackfire új a területen, célja a memóriaszivárgások problémáinak megoldása, például:

• nagy objektumok a memóriában, amelyek nem kerülnek kiadásra
• referencia ciklusok
• érvénytelen referenciaszámlálás a C kiterjesztésekben, ami memóriaszivárgást okoz
• hirtelen memória tüskék

ezekkel a használati esetekkel a Blackfire biztosítja a felhasználókat, hogy nagyon korlátozott a rezsi, és nem befolyásolja a végfelhasználókat, mert a Python alkalmazás memóriafelhasználását a függvényhívás szintjén méri.

Blackfire Python memory profiler használ PyMem_SetAllocator API nyomon követni memória allokációk, mint tracemalloc. Jelenleg a Blackfire támogatja a Python 3.5-ös vagy újabb verzióit. Látogasson el a webhelyére, hogy többet megtudjon.

profilozás a Retrace segítségével

ha Pythonnal dolgozik, akkor valahogy azt tapasztalja, hogy az nem azonnal engedi vissza a memóriát az operációs rendszerbe. Ezért külön folyamatban futtatja annak biztosítása érdekében, hogy a memória felszabaduljon egy kód végrehajtása után. Ez egy “kis tesztesetnek” nevezett hasznos megközelítésen keresztül történik.”Ez a folyamat csak a kérdéses memóriaszivárgási kód futtatását teszi lehetővé.

nagy mennyiségű adat kezelésekor használja a véletlenszerűen kiválasztott adatok egy részhalmazát. Ezenkívül futtasson memóriaigényes feladatokat külön folyamatokban, és hibakeresőkkel adjon hozzá hivatkozásokat az objektumokhoz. Vegye figyelembe azonban, hogy egy töréspont-hibakereső, például pdb használata lehetővé teszi, hogy a hibakeresőből manuálisan létrehozott és hivatkozott objektumok a memóriaprofilban maradjanak. Ez hamis memóriaszivárgást eredményez, mivel az objektumokat nem szabadítják fel időben. Ezenkívül fontolja meg a szivárgó csomagok vizsgálatát. Vannak Python könyvtárak, amelyek potenciálisan memóriaszivárgást okozhatnak.

mostanra már tudod, hogyan működnek a Python memória profilozók és a Python közös memóriaproblémái. De az olyan eszközök, mint a Retrace központosított naplózással, hibakövetéssel és kódprofilozással, segíthetnek a Python-problémák nagyobb mértékű diagnosztizálásában. Retrace a Stackify segít kezelni bármilyen teljesítmény buktatókat, és tartsa a kódot jól működik.

indítsa el a 14 napos ingyenes Retrace próbaverziót még ma!