enligt Stackoverflow survey of 2019 fick Python programmeringsspråk 73,1% godkännande bland utvecklare. Det rankas andra till Rust och fortsätter att dominera inom datavetenskap och maskininlärning(ML).

Python är en utvecklares favorit. Det är ett språk på hög nivå som är känt för sin robusthet och sin kärnfilosofi―enkelhet över komplexitet. Python-applikationens prestanda är dock en annan historia. Precis som alla andra applikationer har den sin andel av prestationsproblem.

För det mesta kan APM-verktyg som Retrace hjälpa till att lösa problem med applikationsprestanda. Men vad händer om din Python-applikation har körts i fyra timmar och servern är ur minnet? Det är ett specifikt problem med minnesresurser.

det kallas en minnesläcka. Utvecklare måste hitta den skyldige. Det är då Python memory profilers kommer in.

låt oss utforska vidare.

Vad är Python memory profilers?

Profileringsapplikationer involverar alltid problem som CPU, minne etc. Python-applikationer är dock benägna att minneshanteringsproblem. Detta beror främst på att Python tillämpas på datavetenskap och ML-applikationer och arbetar med stora mängder data. Python förlitar sig också på sitt Minneshanteringssystem som standard istället för att lämna det till användaren.

eftersom Python-kod fungerar i behållare via ett distribuerat bearbetningsramverk innehåller varje behållare en fast mängd minne. Om kodkörningen överskrider minnesgränsen avslutas behållaren. Det här är när utvecklingen upplever minnesfel.

det är dock inte alltid fallet. Det finns fall där utvecklare inte vet vad som händer. Kanske hänger ett objekt till en referens när det inte ska vara och byggs upp över tiden. När den når sin topp uppstår minnesproblem.

quick-fix-lösningen är att öka minnesallokeringen. Det är dock inte praktiskt eftersom det kan leda till slöseri med resurser. Det kan också äventyra applikationens stabilitet på grund av oförutsägbara minnespikar.

därför behöver vi hjälp av Python-minnesprofilerare. Syftet med Python memory profilers är att hitta minnesläckor och Optimera minnesanvändningen i dina Python-applikationer. Dessa typer av Python-minnesprofilerare förstår utrymmeseffektiviteten för koden och paketen som används.

Top Python Memory Profilers

Även om Python automatiskt hanterar minne behöver det verktyg eftersom långvariga Python-jobb förbrukar mycket minne. I de flesta fall kommer dessa jobb inte att returnera minnet till operativsystemet förrän processen slutar, även om det korrekt utför skräpuppsamling.

Här är en lista över kända Python-minnesprofilerare:

Pympler

Jean Brouwers, Ludwig Haehne och Robert Schuppenies byggde Pympler i augusti 2008. De introducerade processen för pympling, där Pympler erhåller detaljer om storleken och livslängden för Python-objekt.

Pymplers Python – minnesprofil analyserar Python-objektets minnesbeteende i ett program som körs. Det ger en komplett och fristående Python-minnesprofileringslösning. Det projicerar också möjligt fel i runtime-beteende som memory bloat och andra ”pymples.”

det finns tre separata moduler inuti Pympler.

• asizeof-modulen tillhandahåller Python-objektets storleksinformation.
• muppy-modulen riktar sig till on-line övervakning av en Python-applikation.
• klass Tracker-modulen ger off-line analys av livslängden för utvalda Python-objekt.

Låt oss först använda asizeof för att undersöka hur mycket minne vissa Python-objekt förbrukar.

>>> from pympler import asizeof

>>> obj =

>>> asizeof.asizeof(obj)

>>> print (asizeof.asized(obj, detail=1).format())

Storlek=192 platt=48

(6, 4) Storlek=64 platt=32

’i’ storlek=32 platt=32

3 Storlek=16 platt=16

2 Storlek=16 platt=16

1 Storlek=16 platt=16

för det andra, låt oss implementera muppy-modulen:

>>> från pympler import muppy

>>> allobjects = muppy.get_objects()

>>> len(allObjects)

>>> från pympler import sammanfattning

>>> I = sammanfattning.sammanfatta (allObjects)

>>> sammanfattning.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

här kan du se alla Python-objekt i en hög med muppy-modulen. Du kan ringa en annan sammanfattning och jämföra den för att kontrollera om vissa matriser har minnesläckor. Läs mer om muppy-modulen här.

den tredje modulen i Pympler profiler är klass Tracker. Det spårar livslängden för objekt av vissa klasser. 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 ()

— sammanfattning ———————-

Snapshot 1 aktiv 0 B Genomsnittlig PCT

Snapshot 2 aktiv 0 B Genomsnittlig pct

—————————

om du vill veta mer om klass Tracker, klicka här.

Guppy3

Guppy3 (även känd som Heapy) är en Python programmeringsmiljö och en heap analysverktyg. Det är ett paket som innehåller följande underpaket:

• etc-Detta är en stödmodul som har Limprotokollmodulen.
• gsl-underpaketet som innehåller guppy-Specifikationsspråkimplementering. Det skapar dokument och tester från en gemensam källa.
• heapy-heap analysis toolset ger objektinformation om heap och visar informationen.
• sets-detta innehåller Bitsets och nodesets.

Guppy3 är en gaffel av Guppy-PE och byggdes av Sverker Nilsson för Python 2.

Obs: använda denna Python minne profiler kräver Python 3.5, 3.6, 3.7, eller 3.8. Detta paket fungerar endast för CPython. Därför stöds inte pypy och andra Python-kompilatorimplementeringar. För att använda den grafiska webbläsaren behöver den också Tkinter. Dessutom måste gängning vara tillgänglig när du använder en fjärrskärm.

Här är hur man dra nytta av denna Python minne profiler. Du kan ta en ögonblicksbild av högen före och efter en kritisk process. Jämför sedan det totala minnet och hitta möjliga minnespikar som är involverade i vanliga objekt.

>>> 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. Den övervakar minneskonsumtionen för en Python-jobbprocess. Det utför också en rad-för-rad-analys av programmets minnesförbrukning.

den linje-för-linje minnesanvändning läge fungerar på samma sätt som line_profiler.

1. Det dekorerar funktionen du vill profilera med @profile-funktionen.
2. Du kan köra skriptet med ett specialskript. Använd till exempel specifika argument för Python-tolken.

i följande exempel, låt oss ha en enkel funktion som heter my_func. Den här funktionen skapar en lista med ett angivet intervall.

@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	för i inom intervallet(1000):
5	13,859 MiB	0,000 MiB	a.Lägg till(i)

den första kolumnen är radnumret för den profilerade koden. Mem-användning är minnesanvändningen för Python-tolken efter varje kodkörning. Den tredje kolumnen (inkrement) representerar skillnaden i minnet för den aktuella raden till den sista. Den sista kolumnen (Radinnehåll) visar de profilerade koderna.

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	för i inom intervallet(1000000):
5	33.387 MiB	0.293 MiB	a.Lägg till(i)

linje 4 och 5 visar en ökning av minnesanvändningen, vilket visar att denna profiler utför en rad-för-rad-analys av minnesförbrukningen.

Fil

Fil profiler är en Python-minnesprofil med öppen källkod. Den är lämplig för databehandling och vetenskapliga datortillämpningar. För närvarande är det fortfarande i utvecklingsstadiet och körs endast på Linux och macOS.

de flesta datavetare och Python-utvecklare står inför minnesproblem med Python – datapipelinen. När det använder för mycket minne är det svårt att hitta vart exakt allt minne går.

låt oss till exempel citera två scenarier:

servrar

eftersom servrar körs non-stop är minnesläckor ofta orsaken till prestandafel. Utvecklare försummar små mängder minnesläckage eftersom de flesta servrar bearbetar små mängder data åt gången. Dessa kan dock lägga till upp till tiotusentals samtal. Som ett resultat kan detta skapa allvarliga produktionsproblem över tiden.

datapipelines

vid bearbetning av stora bitar av data medför spikar i minnesanvändningen stora hot mot datapipelines. Till exempel, om din applikation använder 1 GB RAM under en längre tid och sedan plötsligt behöver 16 GB RAM. Det finns ett stort behov av att identifiera vad som orsakar plötsliga minnespikar.

det är Fils huvudmål – att diagnostisera minnesanvändningstoppar, oavsett mängden data som behandlas. Den anger var exakt toppminneanvändningen är och vilken kod som är ansvarig för den spiken.

även om det finns befintliga Python-minnesprofilerare som mäter minnesanvändning, har det begränsningar. En av dem handlar om stora mängder data―batchbehandling. Python-applikationer är mestadels batchbehandlingsapplikationer där de ständigt läser data, bearbetar det och matar ut resultatet.

det problemet besvaras av vår nästa profiler.

Blackfire

För ett mycket dynamiskt språk som Python upplever de flesta utvecklare minnesproblem under distributionen. Detta leder till viss förvirring om vad som händer med minnesanvändning. Utvecklare tenderar att utföra optimeringar men har inte rätt verktyg att använda.

Blackfire är en egen Python minne profiler (kanske den första. Den använder Pythons minneshanterare för att spåra varje minnesblock som tilldelats av Python, inklusive C-tillägg. Blackfire är nytt på fältet och syftar till att lösa problem i minnesläckor som:

• stora objekt i minnet som inte släpps
• referenscykler
• ogiltig referensräkning i C-tillägg som orsakar minnesläckor
• plötsliga minnespikar

med dessa användningsfall försäkrar Blackfire användarna att den har en mycket begränsad kostnad och inte påverkar slutanvändarna eftersom den mäter Python-programmets minnesförbrukning på funktionsanropsnivå.

Blackfire Python memory profiler använder PyMem_SetAllocator API för att spåra minnesallokeringar som tracemalloc. För närvarande stöder Blackfire Python-versioner 3.5 och uppåt. Du kan besöka webbplatsen för att lära dig mer.

profilering med Retrace

om du arbetar med Python upplever du på något sätt att det inte omedelbart släpper minnet tillbaka till operativsystemet. Därför kör du det i en separat process för att säkerställa att minnet släpps efter att ha kört en bit kod. Detta görs genom ett användbart tillvägagångssätt som kallas ” litet testfall.”Denna process tillåter att endast den aktuella minnesläckagekoden körs.

När du hanterar stora mängder data, använd en delmängd av slumpmässigt samplade data. Kör också minnesintensiva uppgifter i separata processer och använd felsökare för att lägga till referenser till objekt. Tänk dock på att använda en brytpunkts debugger som pdb tillåter alla objekt som skapas och refereras manuellt från debugger kommer att finnas kvar i minnesprofilen. Detta kommer att resultera i en falsk känsla av minnesläckor eftersom objekt inte släpps i tid. Dessutom kan du överväga att titta på paket som kan vara läckande. Det finns Python-bibliotek som potentiellt kan ha minnesläckor.

nu vet du redan hur Python-minnesprofilerare fungerar och de vanliga minnesproblemen med Python. Men verktyg som Retrace med centraliserad loggning, felspårning och kodprofilering kan hjälpa dig att diagnostisera Python-problem i större skala. Retrace från Stackify hjälper dig att hantera alla typer av prestandafallgropar och hålla din kod igång bra.

Starta din 14-dagars gratis Retrace-test idag!