Ifølge stackoverflow survey of 2019, Python programmeringsspråk fått 73.1% godkjenning blant utviklere. Det rangerer andre Til Rust og fortsetter å dominere I Datavitenskap OG Maskinlæring(ML).
Python er en utviklernes favoritt. Det er et høyt nivå språk kjent for sin robusthet og sin kjernefilosofi-enkelhet over kompleksitet. Python-programmets ytelse er imidlertid en annen historie. Akkurat som alle andre programmer, har den sin andel av ytelsesproblemer. Mesteparten av TIDEN KAN APM-verktøy som Retrace bidra til å løse problemer med programytelsen. Men hva om Python-applikasjonen din har kjørt i fire timer og serveren er tom for minne? Det er et bestemt problem som involverer minne ressurser.
det kalles en minnelekkasje. Utviklere trenger å finne den skyldige. Det er da Python memory profilers kommer inn.
la oss utforske videre.
Hva Er Python minne profiler?
Profilering programmer alltid innebære problemer SOM CPU, minne, etc. Python-applikasjoner er imidlertid utsatt for minnehåndteringsproblemer. Dette er først og FREMST fordi Python brukes Til Datavitenskap OG ML applikasjoner og arbeider med store mengder data. Python er også avhengig av Sitt Minnehåndteringssystem som standard, i stedet for å forlate det til brukeren.
Som Python-kode fungerer i containere via en distribuert behandling rammeverk, inneholder hver beholder en fast mengde minne. Hvis kodekjøringen overskrider minnegrensen, avsluttes beholderen. Dette er når utviklingen opplever minnefeil.
det er Imidlertid Ikke alltid tilfelle. Det er tilfeller der utviklere ikke vet hva som skjer. Kanskje et objekt henger til en referanse når det ikke skal være og bygger opp over tid. Når den når sin topp, oppstår minneproblemer.
quick-fix-løsningen er å øke minnetildelingen. Det er imidlertid ikke praktisk da dette kan føre til sløsing med ressurser. Dessuten kan det sette stabiliteten i programmet på grunn av uforutsigbare minne pigger.
Derfor trenger Vi Hjelp Av Python memory profilers. Formålet Med Python memory profilers er å finne minnelekkasjer og optimalisere minnebruk i Python-applikasjoner. Disse Typer Python-minneprofiler forstår romeffektiviteten til koden og pakkene som brukes.
Top Python Memory Profilers
Selv Om Python automatisk administrerer minne, trenger det verktøy fordi langvarige Python-jobber bruker mye minne. I de fleste tilfeller vil disse jobbene ikke returnere minnet til operativsystemet til prosessen avsluttes, selv om det utfører søppelinnsamling på riktig måte.
her er en liste over Kjente Python-minneprofiler:
Pympler
Jean Brouwers, Ludwig Haehne og Robert Schuppenies bygde Pympler i August 2008. De introduserte prosessen med pympling, hvor Pympler får detaljer om størrelsen og levetiden Til Python-objekter.
Pympler Python memory profiler analyserer Python objektets minne oppførsel inne i et kjørende program. Det gir en komplett Og frittstående Python minne profilering løsning. Også, det prosjekter mulig feil i runtime atferd som minne bloat og andre » pymples.»
det er tre separate moduler inne I Pympler.
- asizeof-modulen gir Informasjon Om Python-objektets størrelse.
- muppy modulen henvender til on-line overvåking Av Et Python-program.
- Klassen Tracker modulen gir off-line analyse av levetiden til utvalgte Python objekter.
Først, la oss bruke asizeof å undersøke hvor mye minne visse Python objekter forbruker.
>>> from pympler import asizeof
>>> obj =
>>> asizeof.asizeof(obj)
>>> print (asizeof.asized(obj, detail=1).format())
størrelse=192 flat=48
(6, 4) størrelse=64 flat=32
‘i’ størrelse=32 flat=32
3 størrelse=16 flat=16
1 størrelse=16 flat=16
Sekund, La oss implementere muppy modulen:
>>>>>>allobjects=muppy.get_objects()
>>>>>>fra pympler import sammendrag
>>i=sammendrag.oppsummer (allObjects)
>>sammendrag.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 |
her kan du se alle python-objekter i en haug ved hjelp av muppy-modulen. Du kan ringe et annet sammendrag og sammenligne det for å sjekke om noen arrays har minnelekkasjer. Lær mer om muppy-modulen her.
den tredje modulen i Pympler profiler er Klassen Tracker. Den sporer levetiden til objekter av 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 ()
— SAMMENDRAG ———————-
Snapshot 1 aktiv 0 b gjennomsnittlig pct
Snapshot 2 aktiv 0 b gjennomsnittlig pct
—————————
For å lære mer Om Class Tracker, klikk her.
Guppy3
Guppy3 (Også Kjent Som Heapy) Er Et Python programmeringsmiljø og et heap analyseverktøy. Det er en pakke som inneholder følgende underpakker:
- etc-dette er en støttemodul som har Limprotokollmodulen.
- gsl-subpackage som inneholder guppy Spesifikasjon Språk implementering. Det skaper dokumenter og tester fra en felles kilde.
- heapy-heap analysis toolset gir objektinformasjon om heap og viser informasjonen.
- sett-dette inneholder Bitsets og nodesets.
Guppy3 er en gaffel Av Guppy-PE og ble bygget Av Sverker Nilsson For Python 2.
Merk: Bruk Av Denne Python-minneprofilen krever Python 3.5, 3.6, 3.7 eller 3.8. Denne pakken fungerer bare For CPython. Derfor Støttes Ikke pypy og Andre Python-kompilatorimplementeringer. Også, for å bruke den grafiske nettleseren, trenger Den Tkinter. I tillegg må threading være tilgjengelig når du bruker en ekstern skjerm.
Her er hvordan du kan dra nytte av Denne Python memory profiler. Du kan ta et øyeblikksbilde av haugen før og etter en kritisk prosess. Deretter sammenligne den totale minne og finne mulige minne pigger involvert i vanlige 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. Den overvåker minneforbruket Av En Python jobb prosess. Det utfører også en line-by-line analyse av minneforbruket av søknaden.
linje-for-linje minnebruk modus fungerer på samme måte som line_profiler.
- den dekorerer funksjonen du vil profilere ved hjelp av @ profilfunksjon.
- du kan kjøre skriptet med et spesialskript. Bruk for eksempel bestemte argumenter til Python-tolken.
i følgende eksempel, la oss ha en enkel funksjon kalt my_func. Denne funksjonen oppretter en liste med et angitt område.
@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 jeg i området(1000): |
| 5 | 13.859 MiB | 0.000 MiB | a.tilføye(i) |
den første kolonnen er linjenummeret til den profilerte koden. Mem-bruk er minnebruk Av Python tolk etter hver kjøring av kode. Den tredje kolonnen (Økning) representerer forskjellen i minnet av den nåværende linjen til den siste. Den siste kolonnen (Linjeinnhold) viser profilerte 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 jeg i området(1000000): |
| 5 | 33.387 MiB | 0.293 MiB | a.tilføye(i) |
linje 4 og 5 viser en økning i minnebruk, noe Som viser At denne profiler utfører en linje-for-linje analyse av minneforbruk.
Fil
Fil profiler er en Åpen Kildekode Python minne profiler. Den er egnet for databehandling og vitenskapelig databehandling applikasjoner. Foreløpig er det fortsatt i utviklingsstadiet og kjører bare På Linux og macOS. De Fleste Datavitenskapere og Python-utviklere står overfor minneproblemer med Python-datarørledningen. Når det bruker for mye minne, er det vanskelig å finne ut hvor nøyaktig alt minnet går. la oss for eksempel sitere to scenarier:
Servere
siden servere kjører non-stop, er minnelekkasjer ofte årsaken til ytelsesfeil. Utviklere forsømmer små mengder minnelekkasje da de fleste servere behandler små mengder data om gangen. Disse kan imidlertid legge opp til titusenvis av samtaler. Som et resultat kan dette skape alvorlige produksjonsproblemer over tid.
datasamlebånd
ved behandling av store biter av data, toppene i minnebruk bringe store trusler mot datasamlebånd. For eksempel, hvis programmet bruker 1GB RAM for en stund og så plutselig trenger 16gb RAM. Det er et stort behov for å identifisere hva som forårsaker plutselige minnespiker.
Det Er Fils hovedmål – å diagnostisere minnebruksspikes, uavhengig av mengden data som behandles. Det peikt hvor nøyaktig peak minnebruk er og hvilken kode er ansvarlig for at pigg.
Selv om Det finnes Eksisterende Python-minneprofiler som måler minnebruk, har den begrensninger. En av dem er å håndtere store mengder data-batch prosessering. Python-applikasjoner er for det meste batchbehandlingsprogrammer hvor de hele tiden leser data, behandler det og sender ut resultatet.
det problemet besvares av vår neste profiler.
Blackfire
for et svært dynamisk språk som Python, opplever de fleste utviklere minneproblemer under distribusjon. Dette fører til litt forvirring om hva som skjer med minnebruk. Utviklere har en tendens til å utføre optimaliseringer, men har ikke de riktige verktøyene å bruke.
Blackfire Er en proprietær Python-minneprofil (kanskje den første. Den bruker Pythons memory manager til å spore hver minneblokk tildelt Av Python, inkludert c-utvidelser. Blackfire er ny på feltet og har som mål å løse problemer i minnelekkasjer som:
- store objekter i minnet som ikke er utgitt
- referansesykluser
- ugyldig referansetelling I c-utvidelser som forårsaker minnelekkasjer
- plutselige minnespikes
Med Disse brukstilfellene sikrer Blackfire brukerne at Den har en svært begrenset overhead og påvirker ikke sluttbrukere fordi den måler Python-programmets minneforbruk på funksjonsanropsnivå. Blackfire Python memory profiler bruker Pymem_setalocator API for å spore minnetildelinger som tracemalloc. I dag Støtter Blackfire Python versjoner 3.5 og opp. Du kan besøke nettstedet for å lære mer.
Profilering Med Retrace
hvis du jobber Med Python, opplever du på en eller annen måte at den ikke umiddelbart slipper minne tilbake til operativsystemet. Derfor kjører du den i en egen prosess for å sikre at minnet frigjøres etter å ha utført et stykke kode. Dette gjøres gjennom en nyttig tilnærming kalt » small test case.»Denne prosessen gjør det mulig å kjøre bare minnelekkasjekoden i spørsmålet.
når du arbeider med store datamengder, bruker du et delsett av de tilfeldig samplede dataene. Kjør også minneintensive oppgaver i separate prosesser, og bruk feilsøkere til å legge til referanser til objekter. Vær imidlertid oppmerksom på at bruk av et avbruddspunkt-debugger, for eksempel pdb, tillater at objekter som opprettes og refereres manuelt fra debuggeren, forblir i minneprofilen. Dette vil resultere i en falsk følelse av minnelekkasjer siden objekter ikke slippes i tide. I tillegg bør du vurdere å se på pakker som kan lekke. Det Er Python-biblioteker som potensielt kan ha minnelekkasjer.
nå vet du allerede Hvordan Python memory profilers fungerer og de vanlige minneproblemene Med Python. Men verktøy som Retrace med sentralisert logging, feilsporing og kodeprofilering kan hjelpe deg med å diagnostisere Python-problemer i større skala. Retrace Fra Stackify vil hjelpe deg å håndtere alle typer ytelse fallgruver og holde koden kjører godt.
Start 14-dagers Gratis Retrace rettssaken i dag!