volgens de StackOverflow survey van 2019, Python programmeertaal oogstte 73,1% goedkeuring onder ontwikkelaars. Het staat op de tweede plaats na roesten en blijft domineren in Data Science en Machine Learning (ML).

Python is de favoriet van ontwikkelaars. Het is een taal op hoog niveau die bekend staat om zijn robuustheid en zijn kernfilosofie-eenvoud boven complexiteit. Echter, Python applicatie prestaties is een ander verhaal. Net als elke andere toepassing, het heeft zijn aandeel van de prestaties problemen.

meestal kunnen APM-tools zoals Retrace helpen bij het oplossen van problemen met de prestaties van toepassingen. Maar, wat als uw Python applicatie is uitgevoerd voor vier uur en de server is uit het geheugen? Dat is een specifiek probleem met geheugenbronnen.

Het wordt een geheugenlek genoemd. Ontwikkelaars moeten de dader vinden. Dat is wanneer Python memory profilers komt in.

laten we verder onderzoeken.

Wat zijn Python memory profilers?

Profileringstoepassingen hebben altijd problemen zoals CPU, geheugen, enz. Python-toepassingen zijn echter gevoelig voor problemen met geheugenbeheer. Dit komt vooral omdat Python wordt toegepast op Data Science en ML toepassingen en werkt met enorme hoeveelheden data. Ook, Python vertrouwt op het Geheugenbeheersysteem standaard, in plaats van het aan de gebruiker over te laten.

omdat Python-code werkt binnen containers via een gedistribueerd verwerkingsraamwerk, bevat elke container een vaste hoeveelheid geheugen. Als de uitvoering van de code de geheugenlimiet overschrijdt, wordt de container beëindigd. Dit is wanneer de ontwikkeling ervaart geheugenfouten.

Dit is echter niet altijd het geval. Er zijn gevallen waarin ontwikkelaars niet weten wat er aan de hand is. Misschien hangt een object aan een referentie als het niet hoort te zijn en bouwt het zich op in de loop van de tijd. Zodra het zijn hoogtepunt bereikt, komen geheugenproblemen voor.

de quick-fix oplossing is om de geheugentoewijzing te verhogen. Het is echter niet praktisch, omdat dit kan leiden tot verspilling van middelen. Ook kan het de stabiliteit van de applicatie in gevaar brengen als gevolg van onvoorspelbare geheugenpieken.

daarom hebben we de hulp nodig van Python memory profilers. Het doel van Python memory profilers is om geheugenlekken te vinden en het geheugengebruik in uw Python-toepassingen te optimaliseren. Deze typen Python-geheugenprofilers begrijpen de ruimte-efficiëntie van de gebruikte code en pakketten.

Top Python Memory Profilers

hoewel Python automatisch geheugen beheert, heeft het hulpmiddelen nodig omdat lang lopende Python-taken veel geheugen verbruiken. In de meeste gevallen zullen deze taken het geheugen niet terugsturen naar het besturingssysteem totdat het proces is beëindigd, zelfs als het de vuilnisophaling correct uitvoert.

Hier is een lijst van bekende Python-geheugenprofilers:in augustus 2008 werd Pypler gebouwd door Jean Brouwers, Ludwig Haehne en Robert Schuppenies. Ze introduceerden het proces van pympling, waarbij Pympler details verkrijgt over de grootte en de levensduur van Python-objecten.

Pymbler ‘ s Python memory profiler analyseert het Geheugengedrag van het Python-object in een draaiende toepassing. Het biedt een complete en stand-alone Python memory profiling oplossing. Ook, het projecteert mogelijke fout in runtime gedrag zoals memory bloat en andere “pymples.”

Er zijn drie afzonderlijke modules in Pypler.

• De asizeof-module geeft informatie over de grootte van het Python-object.
• de Muppy-module is geschikt voor de online monitoring van een Python-toepassing.
• De Class Tracker-module biedt off-line analyse van de levensduur van geselecteerde Python-objecten.

laten we eerst asizeof gebruiken om te onderzoeken hoeveel geheugen bepaalde Python objecten verbruiken.

>>> from pympler import asizeof

>>> obj =

>>> asizeof.asizeof(obj)

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

size=192 flatscreen=48

(6, 4) grootte=64 flatscreen=32

‘ik’ size=32 flatscreen=32

3 size=16 flatscreen=16

2 size=16 flatscreen=16

1 size=16 flatscreen=16

ten Tweede, laten we de uitvoering van de muppy module:

>>> van pympler importeren muppy

>>> allObjects = muppy.get_objects()

>>> len(allObjects)

>>> van pympler importeren samenvatting

>>> I = samenvatting.samenvatten (allObjects)

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

Hier kunt u alle Python objecten in een hoop van de muppy module. U kunt een andere samenvatting aanroepen en deze vergelijken om te controleren of sommige arrays geheugenlekken hebben. Meer informatie over de Muppy module vindt u hier.

de derde module in de Pypler profiler is de Class Tracker. Het volgt de levensduur van objecten van bepaalde klassen. 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 ()

— SUMMARY ———————-

Snapshot 1 actief 0 b gemiddelde pct

Snapshot 2 actief 0 b gemiddelde pct

—————————

voor meer informatie over Class Tracker, Klik hier.

Guppy3

Guppy3 (ook bekend als Heapy) is een Python programmeeromgeving en een heap analysis toolset. Het is een pakket dat de volgende subpakketten bevat:

• etc-Dit is een ondersteuningsmodule met de module Glue protocol.
• gsl – het subpakket dat de guppy specificatie taal implementatie bevat. Het creëert documenten en tests uit een gemeenschappelijke bron.
• heapy – de heap analysis toolset geeft objectinformatie over de heap en geeft de informatie weer.
• sets – dit bevat Bitsets en nodesets.

Guppy3 is een fork van Guppy-PE en werd gebouwd door Sverker Nilsson voor Python 2.

opmerking: het gebruik van deze Python memory profiler vereist Python 3.5, 3.6, 3.7, of 3.8. Dit pakket werkt alleen voor CPython. Daarom worden PyPy en andere Python compiler implementaties niet ondersteund. Ook, om de grafische browser te gebruiken, heeft het Tkinter nodig. Bovendien moet threading beschikbaar zijn bij gebruik van een externe monitor.

Hier is hoe te profiteren van deze Python memory profiler. U kunt een momentopname maken van de heap voor en na een kritisch proces. Vergelijk dan het totale geheugen en lokaliseer mogelijke geheugenpieken die betrokken zijn bij Gemeenschappelijke objecten.

>>> 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. Het controleert het geheugengebruik van een Python-taakproces. Ook voert het een line-by-line analyse uit van het geheugenverbruik van de applicatie.

de regel-voor-regel geheugengebruiksmodus werkt op dezelfde manier als de line_profiler.

1. het siert de functie die u wilt profileren met behulp van de functie @profile.
2. u kunt het script uitvoeren met een speciaal script. Gebruik bijvoorbeeld specifieke argumenten voor de Python interpreter.

in het volgende voorbeeld hebben we een eenvoudige functie genaamd my_func. Deze functie maakt een lijst met een opgegeven bereik.

@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	voor i in bereik(1000):
5	13.859 MiB	0.000 MiB	a.append(i)

de eerste kolom is het regelnummer van de geprofileerde code. Mem gebruik is het geheugengebruik van de Python interpreter na elke code uitvoering. De derde kolom (Increment) vertegenwoordigt het verschil in geheugen van de huidige regel tot de laatste. De laatste kolom (inhoud van de regel) toont de geprofileerde codes.

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	voor i in bereik(1000000):
5	33.387 MiB	0,293 MiB	a.append(i)

regel 4 en 5 tonen een toename van het geheugengebruik, wat bewijst dat deze Profiler een regel-voor-regel analyse van het geheugengebruik uitvoert.

Fil

fil profiler is een open-source Python memory profiler. Het is geschikt voor gegevensverwerking en wetenschappelijke computertoepassingen. Momenteel is het nog in de ontwikkelingsfase en draait het alleen op Linux en macOS.

De meeste datawetenschappers en Python-ontwikkelaars worden geconfronteerd met geheugenproblemen met de Python-datapijplijn. Wanneer het te veel geheugen gebruikt, is het moeilijk om te bepalen waar precies al het geheugen naartoe gaat.

laten we bijvoorbeeld twee scenario ‘ s noemen:

Servers

aangezien servers non-stop draaien, zijn geheugenlekken vaak de oorzaak van prestatiefouten. Ontwikkelaars verwaarlozen kleine hoeveelheden geheugenlekkage omdat de meeste servers kleine hoeveelheden gegevens tegelijk verwerken. Echter, deze kunnen oplopen tot tienduizenden gesprekken. Dit kan leiden tot ernstige productieproblemen in de loop van de tijd.

Data pipelines

bij het verwerken van grote stukken data brengen pieken in het geheugengebruik enorme bedreigingen voor data pipelines. Bijvoorbeeld, als uw applicatie gebruikt 1GB RAM voor een tijdje en dan plotseling nodig heeft 16GB RAM. Er is een grote behoefte om te identificeren wat veroorzaakt plotselinge geheugen pieken.

dat is Fil ‘ s belangrijkste doel―om pieken in het geheugengebruik te diagnosticeren, ongeacht de hoeveelheid data die wordt verwerkt. Het geeft aan waar precies het piekgeheugengebruik is en welke code verantwoordelijk is voor die piek.

hoewel er bestaande Python-geheugenprofilers zijn die het geheugengebruik meten, heeft het beperkingen. Een daarvan is het omgaan met enorme hoeveelheden data-batch verwerking. Python toepassingen zijn meestal batch processing applicaties waarin ze voortdurend lezen gegevens, verwerken, en de output van het resultaat.

dat probleem wordt beantwoord door onze volgende profiler.

Blackfire

voor een zeer dynamische taal zoals Python ervaren de meeste ontwikkelaars geheugenproblemen tijdens de implementatie. Dit leidt tot enige verwarring over wat er gebeurt met het geheugengebruik. Ontwikkelaars hebben de neiging om optimalisaties uit te voeren, maar hebben niet de juiste tools om te gebruiken.

Blackfire is een eigen Python memory profiler (misschien wel de eerste. Het maakt gebruik van Python ‘ s memory manager om elk geheugenblok toegewezen door Python te traceren, inclusief C-extensies. Blackfire is nieuw in het veld en is gericht op het oplossen van problemen in geheugenlekken zoals:

• grote objecten in het geheugen die niet worden vrijgegeven
• referentiecycli
• ongeldige referentietelling in C-extensies die geheugenlekken veroorzaken
• plotselinge geheugenpieken

Met deze use cases verzekert Blackfire gebruikers dat het een zeer beperkte overhead heeft en geen invloed heeft op eindgebruikers omdat het het geheugenverbruik van de Python-toepassing meet op het functieniveau.

Blackfire Python memory profiler gebruikt PYMEM_SETALLOCATOR API om geheugentoewijzingen zoals tracemalloc te traceren. Op dit moment ondersteunt Blackfire Python versies 3.5 en hoger. U kunt de site bezoeken om meer te leren.

profilering met Retrace

als u met Python werkt, ervaart u op de een of andere manier dat het geheugen niet onmiddellijk vrijmaakt naar het besturingssysteem. Daarom, je draait het in een apart proces om ervoor te zorgen dat het geheugen wordt vrijgegeven na het uitvoeren van een stuk code. Dit wordt gedaan door middel van een nuttige aanpak genaamd “kleine test case.”Dit proces maakt het mogelijk om alleen de memory leakage code in kwestie.

gebruik bij het omgaan met grote hoeveelheden gegevens een subset van de willekeurig verzamelde gegevens. Voer ook geheugenintensieve taken uit in afzonderlijke processen en gebruik debuggers om verwijzingen naar objecten toe te voegen. Houd er echter rekening mee dat met behulp van een breekpunt debugger zoals pdb alle objecten die handmatig zijn gemaakt en waarnaar wordt verwezen vanuit de debugger in het geheugenprofiel blijven. Dit zal resulteren in een vals gevoel van geheugenlekken omdat objecten niet op tijd worden vrijgegeven. Bovendien, overwegen te kijken naar pakketten die lek kunnen zijn. Er zijn Python bibliotheken die mogelijk geheugenlekken kunnen hebben.

inmiddels weet je al hoe Python-geheugenprofilers werken en de veelvoorkomende geheugenproblemen met Python. Maar tools zoals Retrace met gecentraliseerde logging, foutregistratie en code profilering kunnen u helpen om Python problemen op grotere schaal te diagnosticeren. Retrace van Staccify zal u helpen omgaan met alle soorten van de prestaties valkuilen en houd uw code goed draait.

Start uw 14-daagse gratis Retrace-proef vandaag nog!