PricingLoginStart free
Python Academy · leksjon

Minneprofilering med tracemalloc

Spor minneallokeringer og finn lekkasjer med tracemalloc.

Leksjon 4 av 413 trinn

Minneprofilering med tracemalloc er en gratis leksjon i Python Academy på CoddyKit. Dette er leksjon 4 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Python Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Python Academy inneholder totalt 4 leksjoner.

Hva er tracemalloc?

tracemalloc er en modul i standardbiblioteket som sporer Python-minneallokeringer etter fil og linjenummer.

import tracemalloc

tracemalloc.start()

x = [i for i in range(100_000)]

current, peak = tracemalloc.get_traced_memory()
tracemalloc.stop()

print(f"Current: {current/1024:.1f} KB")
print(f"Peak:    {peak/1024:.1f} KB")

Ta øyeblikksbilder

Et øyeblikksbilde registrerer alle nåværende allokeringer på et bestemt tidspunkt. Sammenlign to øyeblikksbilder for å finne ut hva som ble allokert mellom dem.

import tracemalloc

tracemalloc.start()

snap1 = tracemalloc.take_snapshot()

data = [{"key": str(i)} for i in range(10_000)]

snap2 = tracemalloc.take_snapshot()

stats = snap2.compare_to(snap1, "lineno")
for stat in stats[:5]:
    print(stat)

Filtrere øyeblikksbilder

Filtrer statistikken slik at den bare viser programmets egen kode, og utelater standardbiblioteket.

import tracemalloc

tracemalloc.start()
leak_function()
snap = tracemalloc.take_snapshot()

filters = [tracemalloc.Filter(True, "*/myapp/*")]
stats = snap.filter_traces(filters).statistics("lineno")
for stat in stats[:10]:
    print(stat)

Største allokeringer

Bruk snapshot.statistics("lineno") eller "traceback" for å se de største minneforbrukerne etter linje eller fullstendig sporingsinformasjon.

import tracemalloc

tracemalloc.start(nframe=10)   # track 10 frames deep

big_list = [i**2 for i in range(500_000)]

snap = tracemalloc.take_snapshot()
for stat in snap.statistics("traceback")[:3]:
    print(stat)
    for line in stat.traceback.format():
        print("  ", line)

Finne minnelekkasjer

Ta to øyeblikksbilder rundt en mistenkt lekkasje, og sammenlign dem. Økende statistikk mellom øyeblikksbildene tyder på en lekkasje.

import tracemalloc

tracemalloc.start()
snap_before = tracemalloc.take_snapshot()

for _ in range(100):
    suspected_leaky_function()

snap_after = tracemalloc.take_snapshot()
diff = snap_after.compare_to(snap_before, "lineno")
for stat in diff[:5]:
    print(stat)

get_traced_memory()

tracemalloc.get_traced_memory() returnerer (current, peak) byte – nyttig for enkle kontroller før og etter.

import tracemalloc

tracemalloc.start()
before, _ = tracemalloc.get_traced_memory()

do_something()

after, peak = tracemalloc.get_traced_memory()
tracemalloc.stop()

print(f"Delta: {(after-before)/1024:.1f} KB, Peak: {peak/1024:.1f} KB")

memory_profiler

memory_profiler viser minnebruk linje for linje, på samme måte som line_profiler viser CPU-bruk.

# pip install memory_profiler
from memory_profiler import profile

@profile
def build_data():
    data = [i**2 for i in range(100_000)]
    filtered = [x for x in data if x % 2 == 0]
    return filtered

build_data()
# python -m memory_profiler script.py

memray

memray (fra Bloomberg) er en rask Python-minneprofiler med flammegrafresultat.

# pip install memray
# python -m memray run script.py
# python -m memray flamegraph memray-script.py.bin

# Generates an interactive HTML flamegraph
# showing allocations by call stack

Redusere minnebruk

Vanlige teknikker er å bruke generatorer i stedet for lister, __slots__, array-modulen for numeriske data, numpy-arrayer og å unngå å holde store objekter i live i closures.

# Instead of:
data = [process(x) for x in huge_list]   # all in memory

# Use a generator:
def gen_data(lst):
    for x in lst:
        yield process(x)

for item in gen_data(huge_list):
    consume(item)   # one at a time

sys.getsizeof()

sys.getsizeof(obj) returnerer minnet et objekt bruker, i byte (overfladisk – inkluderer ikke refererte objekter).

import sys

print(sys.getsizeof([]))          # 56
print(sys.getsizeof([1,2,3]))     # 88
print(sys.getsizeof("hello"))     # 54
print(sys.getsizeof({}))          # 64

# For deep size, use recursive measurement:
def deep_size(obj):
    return sys.getsizeof(obj) + sum(
        sys.getsizeof(v) for v in vars(obj).values()
        if hasattr(obj, "__dict__")
    )

Profilering i produksjon

Kjør tracemalloc med et begrenset antall nframes i produksjon for å minimere belastningen. Lagre øyeblikksbilder i en fil for offline-analyse.

import tracemalloc, pickle

tracemalloc.start(nframe=5)   # low overhead

# ... serve some requests ...

snap = tracemalloc.take_snapshot()
with open("snap.pkl","wb") as f:
    pickle.dump(snap, f)
# Analyse later offline

Hurtigsjekk

Hva representerer de to verdiene som returneres av tracemalloc.get_traced_memory()?

Besvar den i den interaktive leksjonen

Oppsummering

Bruk tracemalloc.start() og øyeblikksbilder for å finne minnelekkasjer. Sammenlign øyeblikksbilder med compare_to(). Bruk memory_profiler for minnebruk linje for linje og memray for flammegrafer. Reduser minnebruken med generatorer, __slots__ og NumPy-arrayer.

Gratis å komme i gang

Lær deg Python med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs
76
Leksjoner
320
Start læringen gratisSe hele kurset

Ofte stilte spørsmål

Er leksjonen «Minneprofilering med tracemalloc» gratis?

Ja – hele teksten i «Minneprofilering med tracemalloc» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Python Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Python Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Minneprofilering med tracemalloc»?

Spor minneallokeringer og finn lekkasjer med tracemalloc. Du øver på Python Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Python Academy?

Ingen tidligere erfaring er nødvendig. Python Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 4 av 4.

Hvor lang tid tar leksjonen «Minneprofilering med tracemalloc»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Python Academy-leksjonen?

Ja. Alle Python Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

  1. Referansetelling i CPython
  2. Garbage collector og sykliske referanser
  3. Profilering med cProfile og line_profiler
  4. Minneprofilering med tracemalloc
← Tilbake til Python Academy