i henhold til Stackoverløbsundersøgelsen fra 2019 fik Python-programmeringssprog 73,1% godkendelse blandt udviklere. Det rangerer andet end Rust og fortsætter med at dominere inden for datalogi og maskinindlæring(ML).

Python er en udviklers favorit. Det er et sprog på højt niveau kendt for sin robusthed og sin kernefilosofi―enkelhed over kompleksitet. Python-applikationens ydeevne er dog en anden historie. Ligesom enhver anden applikation har den sin andel af ydelsesproblemer.

det meste af tiden kan APM-værktøjer som Retrace hjælpe med at løse problemer med applikationens ydeevne. Men hvad nu hvis din Python-applikation har kørt i fire timer, og serveren er ude af hukommelsen? Det er et specifikt problem, der involverer hukommelsesressourcer.

det kaldes en hukommelseslækage. Udviklere skal finde synderen. Det er når Python memory profilers kommer ind.

lad os undersøge yderligere.

Hvad er Python memory profilers?

Profileringsapplikationer involverer altid problemer som CPU, hukommelse osv. Python-applikationer er dog tilbøjelige til hukommelsesstyringsproblemer. Dette skyldes primært, at Python anvendes til datalogi og ML applikationer og arbejder med store mængder data. Python er også afhængig af sit Hukommelsesstyringssystem som standard i stedet for at overlade det til brugeren.da Python-kode fungerer i containere via en distribueret behandlingsramme, indeholder hver container en fast mængde hukommelse. Hvis kodeudførelsen overstiger hukommelsesgrænsen, ophører beholderen. Dette er når udvikling oplever hukommelsesfejl.

det er dog ikke altid tilfældet. Der er tilfælde, hvor udviklere ikke ved, hvad der foregår. Måske hænger et objekt til en reference, når det ikke skal være og opbygges over tid. Når det når sit højdepunkt, opstår hukommelsesproblemer.

den hurtige løsning er at øge hukommelsesallokeringen. Det er dog ikke praktisk, da dette kan resultere i spild af ressourcer. Det kan også bringe applikationens stabilitet i fare på grund af uforudsigelige hukommelsesspidser.

derfor har vi brug for hjælp fra Python memory profilers. Formålet med Python memory profilers er at finde hukommelseslækager og optimere hukommelsesforbruget i dine Python-applikationer. Disse typer Python-hukommelsesprofiler forstår pladseffektiviteten af den anvendte kode og pakker.

Top Python Memory Profilers

selvom Python automatisk administrerer hukommelse, har den brug for værktøjer, fordi langvarige Python-job bruger meget hukommelse. I de fleste tilfælde returnerer disse job ikke hukommelsen til operativsystemet, før processen slutter, selvom den korrekt udfører affaldsindsamling.

Her er en liste over kendte Python-hukommelsesprofiler:

Pympler

Jean Brouers, Ludvig Haehne og Robert Schuppenies byggede Pympler i August 2008. De introducerede processen med pympling, hvor Pympler opnår detaljer om størrelsen og levetiden for Pythonobjekter.Pympler s Python memory profiler analyserer Python objektets hukommelse adfærd inde i et kørende program. Det giver en komplet og stand-alone Python hukommelse profilering løsning. Også, det projekter mulig fejl i runtime adfærd som hukommelse bloat og andre “pymples.”

der er tre separate moduler inde Pympler.

• modulet indeholder oplysninger om Python-objektets størrelse.
• muppy-modulet henvender sig til onlineovervågning af en Python-applikation.klassen Tracker modul giver off-line analyse af levetiden af udvalgte Python objekter.

lad os først bruge asiteof til at undersøge, hvor meget hukommelse visse Python-objekter bruger.

>>> from pympler import asizeof

>>> obj =

>>> asizeof.asizeof(obj)

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

Størrelse=192 flad=48

(6, 4) Størrelse=64 flad=32

‘i’ størrelse=32 flad=32

3 Størrelse=16 flad=16

2 Størrelse=16 flad=16

1 Størrelse=16 flad=16

sekund, lad os implementere muppy-modulet:

>>> fra pympler import MUPPY

>>allobjects=MUPPY.get_objects()

>>> len(allObjects)

>>> fra pympler importoversigt

>>> i = resume.opsummere (allObjects)

>>> resume.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
frostset |	90 |	16.87 KB

Her kan du se alle Python-objekter i en bunke ved hjælp af MUPPY-modulet. Du kan ringe til et andet resume og sammenligne det for at kontrollere, om nogle arrays har hukommelseslækager. Læs mere om muppy modulet her.

det tredje modul i Pympler profiler er klassen Tracker. Det sporer levetiden for objekter af bestemte 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 ()

— oversigt ———————-

Snapshot 1 Aktiv 0 B gennemsnitlig pct

Snapshot 2 aktiv 0 B gennemsnitlig pct

—————————

for at lære mere om Class Tracker, Klik her.

Guppy3

Guppy3 (også kendt som Heapy) er en Python programmeringsmiljø og en bunke analyse værktøjssæt. Det er en pakke, der indeholder følgende underpakker:

• etc-Dette er et supportmodul, der har Limprotokolmodulet.
• gsl-den underpakke, der indeholder implementeringen af guppy-Specifikationssproget. Det skaber dokumenter og tests fra en fælles kilde.
• heapy-værktøjssættet til heap-analyse giver objektoplysninger om bunken og viser oplysningerne.
• sæt-dette indeholder bitsæt og nodesæt.

Guppy3 er en gaffel af Guppy-PE og blev bygget af Sverker Nilsson til Python 2.

Bemærk: Brug af denne Python memory profiler kræver Python 3.5, 3.6, 3.7 eller 3.8. Denne pakke virker kun for CPython. Derfor understøttes pypy og andre Python compiler implementeringer ikke. Også, for at bruge den grafiske bro.ser, det har brug for Tkinter. Derudover skal gevindskæring være tilgængelig, når du bruger en fjernskærm.

Her er hvordan man kan drage fordel af denne Python hukommelse profiler. Du kan tage et øjebliksbillede af bunken før og efter en kritisk proces. Sammenlign derefter den samlede hukommelse og find mulige hukommelsesspidser involveret i almindelige objekter.

>>> 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. Det overvåger hukommelsesforbruget i en Python-jobproces. Det udfører også en line-by-line analyse af programmets hukommelsesforbrug.

line-by-line hukommelsesbrugstilstand fungerer på samme måde som line_profiler.

1. det dekorerer den funktion, du gerne vil profilere ved hjælp af @profile-funktionen.
2. du kan køre scriptet med et specielt script. Brug for eksempel specifikke argumenter til Python-tolken.

i det følgende eksempel, lad os have en simpel funktion kaldet my_func. Denne funktion opretter en liste med et bestemt interval.

@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	for i inden for rækkevidde(1000):
5	13.859 MiB	0.000 MiB	a.append(i)

den første kolonne er linjenummeret for den profilerede kode. Mem-brug er hukommelsesforbruget af Python-tolken efter hver kodeudførelse. Den tredje kolonne (stigning) repræsenterer forskellen i hukommelsen for den aktuelle linje til den sidste. Den sidste kolonne (Linjeindhold) viser de profilerede koder.

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	for i inden for rækkevidde(1000000):
5	33.387 MiB	0.293 MiB	a.append(i)

linje 4 og 5 viser en stigning i hukommelsesforbruget, hvilket viser, at denne profiler udfører en line-by-line analyse af hukommelsesforbrug.

Fil

Fil profiler er en open source Python hukommelse profiler. Det er velegnet til databehandling og videnskabelig computing applikationer. I øjeblikket er det stadig i udviklingsfasen og kører kun på MacOS og macOS.

de fleste dataforskere og Python-udviklere står over for hukommelsesproblemer med Python data pipeline. Når den bruger for meget hukommelse, er det svært at finde ud af, hvor nøjagtigt al hukommelsen går.

lad os for eksempel citere to scenarier:

servere

da servere kører non-stop, er hukommelseslækager ofte årsagen til ydelsesfejl. Udviklere forsømmer små mængder hukommelseslækage, da de fleste servere behandler små mængder data ad gangen. Disse kan dog tilføje op til titusinder af opkald. Som et resultat kan dette skabe alvorlige produktionsproblemer over tid.

Data rørledninger

Ved behandling af store klumper af data, pigge i hukommelsesforbrug bringe enorme trusler mod data rørledninger. For eksempel, hvis din applikation bruger 1 GB RAM i nogen tid og derefter pludselig har brug for 16 GB RAM. Der er et stort behov for at identificere, hvad der forårsager pludselige hukommelsesspidser.

det er Fils hovedmål―at diagnosticere hukommelsesbrugsspidser, uanset mængden af data, der behandles. Det angiver, hvor nøjagtigt den maksimale hukommelsesforbrug er, og hvilken kode der er ansvarlig for den spike.

selvom der findes eksisterende Python-hukommelsesprofiler, der måler hukommelsesforbrug, har den begrænsninger. Hvoraf den ene beskæftiger sig med store mængder data―batchbehandling. Python-applikationer er for det meste batchbehandlingsapplikationer, hvor de konstant læser data, behandler dem og udsender resultatet.

dette problem besvares af vores næste profiler.

Blackfire

for et meget dynamisk sprog som Python oplever de fleste udviklere hukommelsesproblemer under implementeringen. Dette fører til en vis forvirring om, hvad der sker med hukommelsesforbrug. Udviklere har tendens til at udføre optimeringer, men har ikke de rigtige værktøjer til at bruge.

Blackfire er en proprietær Python memory profiler (måske den første. Det bruger Pythons hukommelseshåndtering til at spore hver hukommelsesblok, der er tildelt af Python, inklusive C-udvidelser. Blackfire er ny på banen og sigter mod at løse problemer i hukommelseslækager som:

• store objekter i hukommelsen, som ikke frigives
• referencecyklusser
• ugyldig referencetælling i C-udvidelser, der forårsager hukommelseslækager
• pludselige hukommelsesspidser

Med disse brugssager forsikrer Blackfire brugerne om, at det har en meget begrænset omkostning og ikke påvirker slutbrugerne, fordi det måler Python-applikationens Hukommelsesforbrug på funktionsopkaldsniveauet. Blackfire Python memory profiler bruger PYMEM_SETALLOCATOR API til at spore hukommelsesallokeringer som tracemalloc. På nuværende tidspunkt understøtter Blackfire Python versioner 3.5 og op. Du kan besøge sin hjemmeside for at lære mere.

profilering med Retrace

Hvis du arbejder med Python, oplever du på en eller anden måde, at det ikke straks frigiver hukommelsen tilbage til operativsystemet. Derfor kører du det i en separat proces for at sikre, at hukommelsen frigives efter udførelse af et stykke kode. Dette gøres gennem en nyttig tilgang kaldet ” small test case.”Denne proces tillader kun at køre den pågældende hukommelseslækagekode.

Når du beskæftiger dig med store mængder data, skal du bruge en delmængde af de tilfældigt samplede data. Kør også hukommelsesintensive opgaver i separate processer, og brug debuggere til at tilføje referencer til objekter. Overvej dog, at brug af en breakpoint debugger som f.eks pdb tillader, at objekter, der oprettes og refereres manuelt fra debuggeren, forbliver i hukommelsesprofilen. Dette vil resultere i en falsk følelse af hukommelseslækager, da objekter ikke frigives til tiden. Derudover overveje at undersøge pakker, der kan være utætte. Der er Python-biblioteker, der potentielt kan have hukommelseslækager.

nu ved du allerede, hvordan Python-hukommelsesprofiler fungerer, og de almindelige hukommelsesproblemer med Python. Men værktøjer som Retrace med centraliseret logning, fejlsporing og kodeprofilering kan hjælpe dig med at diagnosticere Python-problemer i større skala. Retrace fra Stackify vil hjælpe dig med at håndtere enhver form for ydeevne faldgruber og holde din kode kører godt.

Start din 14-dages gratis Retrace-prøveperiode i dag!