`tracemalloc` — Speicherreservierungen aufzeichnen¶

Added in version 3.4.

Das Modul tracemalloc ist ein Werkzeug zur Fehlersuche. Es zeichnet auf, welche Speicherblöcke Python reserviert, und liefert dazu:

den Traceback der Stelle, an der ein Objekt reserviert wurde
Statistiken über reservierte Speicherblöcke je Datei und je Zeilennummer: Gesamtgröße, Anzahl und durchschnittliche Größe der reservierten Speicherblöcke
die Unterschiede zwischen zwei Snapshots, um Speicherlecks zu finden

Damit möglichst viele der von Python reservierten Speicherblöcke erfasst werden, sollte das Modul so früh wie möglich starten: indem du die Umgebungsvariable PYTHONTRACEMALLOC auf 1 setzt oder die Befehlszeilenoption -X tracemalloc verwendest. Zur Laufzeit lässt sich die Aufzeichnung mit tracemalloc.start() starten.

Standardmäßig hält ein Trace zu einem reservierten Speicherblock nur den jüngsten Frame fest, also einen. Um beim Start 25 Frames festzuhalten, setze die Umgebungsvariable PYTHONTRACEMALLOC auf 25 oder verwende die Befehlszeilenoption -X tracemalloc=25.

Beispiele¶

Die zehn größten anzeigen¶

Die zehn Dateien anzeigen, die am meisten Speicher reservieren:

import tracemalloc

tracemalloc.start()

# ... run your application ...

snapshot = tracemalloc.take_snapshot()
top_stats = snapshot.statistics('lineno')

print("[ Top 10 ]")
for stat in top_stats[:10]:
    print(stat)

Beispielausgabe aus der Python-Testsuite:

[ Top 10 ]
<frozen importlib._bootstrap>:716: size=4855 KiB, count=39328, average=126 B
<frozen importlib._bootstrap>:284: size=521 KiB, count=3199, average=167 B
/usr/lib/python3.4/collections/__init__.py:368: size=244 KiB, count=2315, average=108 B
/usr/lib/python3.4/unittest/case.py:381: size=185 KiB, count=779, average=243 B
/usr/lib/python3.4/unittest/case.py:402: size=154 KiB, count=378, average=416 B
/usr/lib/python3.4/abc.py:133: size=88.7 KiB, count=347, average=262 B
<frozen importlib._bootstrap>:1446: size=70.4 KiB, count=911, average=79 B
<frozen importlib._bootstrap>:1454: size=52.0 KiB, count=25, average=2131 B
<string>:5: size=49.7 KiB, count=148, average=344 B
/usr/lib/python3.4/sysconfig.py:411: size=48.0 KiB, count=1, average=48.0 KiB

Man sieht: Python hat 4855 KiB Daten aus Modulen geladen, Bytecode und Konstanten, und das Modul collections hat 244 KiB reserviert, um namedtuple-Typen zu erzeugen.

Weitere Möglichkeiten stehen bei Snapshot.statistics().

Unterschiede berechnen¶

Zwei Snapshots nehmen und die Unterschiede anzeigen:

import tracemalloc
tracemalloc.start()
# ... start your application ...

snapshot1 = tracemalloc.take_snapshot()
# ... call the function leaking memory ...
snapshot2 = tracemalloc.take_snapshot()

top_stats = snapshot2.compare_to(snapshot1, 'lineno')

print("[ Top 10 differences ]")
for stat in top_stats[:10]:
    print(stat)

Beispielausgabe vor und nach einigen Tests aus der Python-Testsuite:

[ Top 10 differences ]
<frozen importlib._bootstrap>:716: size=8173 KiB (+4428 KiB), count=71332 (+39369), average=117 B
/usr/lib/python3.4/linecache.py:127: size=940 KiB (+940 KiB), count=8106 (+8106), average=119 B
/usr/lib/python3.4/unittest/case.py:571: size=298 KiB (+298 KiB), count=589 (+589), average=519 B
<frozen importlib._bootstrap>:284: size=1005 KiB (+166 KiB), count=7423 (+1526), average=139 B
/usr/lib/python3.4/mimetypes.py:217: size=112 KiB (+112 KiB), count=1334 (+1334), average=86 B
/usr/lib/python3.4/http/server.py:848: size=96.0 KiB (+96.0 KiB), count=1 (+1), average=96.0 KiB
/usr/lib/python3.4/inspect.py:1465: size=83.5 KiB (+83.5 KiB), count=109 (+109), average=784 B
/usr/lib/python3.4/unittest/mock.py:491: size=77.7 KiB (+77.7 KiB), count=143 (+143), average=557 B
/usr/lib/python3.4/urllib/parse.py:476: size=71.8 KiB (+71.8 KiB), count=969 (+969), average=76 B
/usr/lib/python3.4/contextlib.py:38: size=67.2 KiB (+67.2 KiB), count=126 (+126), average=546 B

Man sieht: Python hat 8173 KiB Moduldaten geladen, Bytecode und Konstanten, und damit 4428 KiB mehr als vor den Tests, als der vorige Snapshot entstand. Ebenso hat das Modul linecache 940 KiB Python-Quellcode zwischengespeichert, um Tracebacks zu formatieren – alles davon seit dem vorigen Snapshot.

Hat das System wenig freien Speicher, lassen sich Snapshots mit der Methode Snapshot.dump() auf die Platte schreiben und später auswerten. Zum Zurückladen dient die Methode Snapshot.load().

Den Traceback eines Speicherblocks holen¶

Code, der den Traceback des größten Speicherblocks anzeigt:

import tracemalloc

# Store 25 frames
tracemalloc.start(25)

# ... run your application ...

snapshot = tracemalloc.take_snapshot()
top_stats = snapshot.statistics('traceback')

# pick the biggest memory block
stat = top_stats[0]
print("%s memory blocks: %.1f KiB" % (stat.count, stat.size / 1024))
for line in stat.traceback.format():
    print(line)

Beispielausgabe aus der Python-Testsuite, Traceback auf 25 Frames begrenzt:

903 memory blocks: 870.1 KiB
  File "<frozen importlib._bootstrap>", line 716
  File "<frozen importlib._bootstrap>", line 1036
  File "<frozen importlib._bootstrap>", line 934
  File "<frozen importlib._bootstrap>", line 1068
  File "<frozen importlib._bootstrap>", line 619
  File "<frozen importlib._bootstrap>", line 1581
  File "<frozen importlib._bootstrap>", line 1614
  File "/usr/lib/python3.4/doctest.py", line 101
    import pdb
  File "<frozen importlib._bootstrap>", line 284
  File "<frozen importlib._bootstrap>", line 938
  File "<frozen importlib._bootstrap>", line 1068
  File "<frozen importlib._bootstrap>", line 619
  File "<frozen importlib._bootstrap>", line 1581
  File "<frozen importlib._bootstrap>", line 1614
  File "/usr/lib/python3.4/test/support/__init__.py", line 1728
    import doctest
  File "/usr/lib/python3.4/test/test_pickletools.py", line 21
    support.run_doctest(pickletools)
  File "/usr/lib/python3.4/test/regrtest.py", line 1276
    test_runner()
  File "/usr/lib/python3.4/test/regrtest.py", line 976
    display_failure=not verbose)
  File "/usr/lib/python3.4/test/regrtest.py", line 761
    match_tests=ns.match_tests)
  File "/usr/lib/python3.4/test/regrtest.py", line 1563
    main()
  File "/usr/lib/python3.4/test/__main__.py", line 3
    regrtest.main_in_temp_cwd()
  File "/usr/lib/python3.4/runpy.py", line 73
    exec(code, run_globals)
  File "/usr/lib/python3.4/runpy.py", line 160
    "__main__", fname, loader, pkg_name)

Man sieht: Der meiste Speicher wurde im Modul importlib reserviert, um Daten aus Modulen zu laden, Bytecode und Konstanten: 870.1 KiB. Der Traceback zeigt, wo importlib zuletzt Daten geladen hat, nämlich in der Zeile import pdb des Moduls doctest. Der Traceback kann sich ändern, wenn ein neues Modul geladen wird.

Hübsche Bestenliste¶

Code, der die zehn Zeilen mit dem meisten reservierten Speicher hübsch ausgibt und dabei die Dateien <frozen importlib._bootstrap> und <unknown> übergeht:

import linecache
import os
import tracemalloc

def display_top(snapshot, key_type='lineno', limit=10):
    snapshot = snapshot.filter_traces((
        tracemalloc.Filter(False, "<frozen importlib._bootstrap>"),
        tracemalloc.Filter(False, "<unknown>"),
    ))
    top_stats = snapshot.statistics(key_type)

    print("Top %s lines" % limit)
    for index, stat in enumerate(top_stats[:limit], 1):
        frame = stat.traceback[0]
        print("#%s: %s:%s: %.1f KiB"
              % (index, frame.filename, frame.lineno, stat.size / 1024))
        line = linecache.getline(frame.filename, frame.lineno).strip()
        if line:
            print('    %s' % line)

    other = top_stats[limit:]
    if other:
        size = sum(stat.size for stat in other)
        print("%s other: %.1f KiB" % (len(other), size / 1024))
    total = sum(stat.size for stat in top_stats)
    print("Total allocated size: %.1f KiB" % (total / 1024))

tracemalloc.start()

# ... run your application ...

snapshot = tracemalloc.take_snapshot()
display_top(snapshot)

Beispielausgabe aus der Python-Testsuite:

Top 10 lines
#1: Lib/base64.py:414: 419.8 KiB
    _b85chars2 = [(a + b) for a in _b85chars for b in _b85chars]
#2: Lib/base64.py:306: 419.8 KiB
    _a85chars2 = [(a + b) for a in _a85chars for b in _a85chars]
#3: collections/__init__.py:368: 293.6 KiB
    exec(class_definition, namespace)
#4: Lib/abc.py:133: 115.2 KiB
    cls = super().__new__(mcls, name, bases, namespace)
#5: unittest/case.py:574: 103.1 KiB
    testMethod()
#6: Lib/linecache.py:127: 95.4 KiB
    lines = fp.readlines()
#7: urllib/parse.py:476: 71.8 KiB
    for a in _hexdig for b in _hexdig}
#8: <string>:5: 62.0 KiB
#9: Lib/_weakrefset.py:37: 60.0 KiB
    self.data = set()
#10: Lib/base64.py:142: 59.8 KiB
    _b32tab2 = [a + b for a in _b32tab for b in _b32tab]
6220 other: 3602.8 KiB
Total allocated size: 5303.1 KiB

Weitere Möglichkeiten stehen bei Snapshot.statistics().

Aktuelle und höchste Größe aller aufgezeichneten Speicherblöcke festhalten¶

Der folgende Code berechnet zwei Summen der Art 0 + 1 + 2 + ... auf umständliche Weise, nämlich über eine Liste dieser Zahlen. Diese Liste braucht vorübergehend viel Speicher. Mit get_traced_memory() und reset_peak() lassen sich der geringe Speicherbedarf nach der Berechnung und der Höchstwert während der Berechnung beobachten:

import tracemalloc

tracemalloc.start()

# Example code: compute a sum with a large temporary list
large_sum = sum(list(range(100000)))

first_size, first_peak = tracemalloc.get_traced_memory()

tracemalloc.reset_peak()

# Example code: compute a sum with a small temporary list
small_sum = sum(list(range(1000)))

second_size, second_peak = tracemalloc.get_traced_memory()

print(f"{first_size=}, {first_peak=}")
print(f"{second_size=}, {second_peak=}")

Ausgabe:

first_size=664, first_peak=3592984
second_size=804, second_peak=29704

Dank reset_peak() ließ sich der Höchstwert während der Berechnung von small_sum genau festhalten, obwohl er weit unter dem Höchstwert aller Speicherblöcke seit dem Aufruf von start() liegt. Ohne den Aufruf von reset_peak() wäre second_peak noch der Höchstwert aus der Berechnung von large_sum, also gleich first_peak. Hier liegen beide Höchstwerte weit über dem Speicherbedarf am Ende, was auf Verbesserungspotenzial hindeutet: Der unnötige Aufruf von list kann weg, es genügt sum(range(...)).

API¶

Funktionen¶

tracemalloc.clear_traces()¶

Verwirft die Traces der von Python reservierten Speicherblöcke.

Siehe auch stop().

tracemalloc.get_object_traceback(obj)¶

Holt den Traceback der Stelle, an der das Python-Objekt obj reserviert wurde. Zurückgegeben wird eine Instanz von Traceback oder None, wenn das Modul tracemalloc keine Reservierungen aufzeichnet oder die Reservierung dieses Objekts nicht aufgezeichnet hat.

Siehe auch die Funktionen gc.get_referrers() und sys.getsizeof().

tracemalloc.get_traceback_limit()¶

Holt die größte Anzahl an Frames, die im Traceback eines Traces festgehalten werden.

Das Modul tracemalloc muss Reservierungen aufzeichnen, damit sich die Grenze holen lässt, sonst wird eine Ausnahme ausgelöst.

Die Grenze setzt die Funktion start().

tracemalloc.get_traced_memory()¶: Holt die aktuelle und die höchste Größe der vom Modul tracemalloc aufgezeichneten Speicherblöcke als Tupel (current: int, peak: int).

tracemalloc.reset_peak()¶

Setzt die höchste Größe der vom Modul tracemalloc aufgezeichneten Speicherblöcke auf die aktuelle Größe.

Tut nichts, wenn das Modul tracemalloc keine Reservierungen aufzeichnet.

Diese Funktion ändert nur den festgehaltenen Höchstwert. Anders als clear_traces() ändert oder verwirft sie keine Traces. Snapshots von take_snapshot() vor einem Aufruf von reset_peak() lassen sich daher sinnvoll mit Snapshots nach dem Aufruf vergleichen.

Siehe auch get_traced_memory().

Added in version 3.9.

tracemalloc.get_tracemalloc_memory()¶: Holt den Speicherbedarf des Moduls tracemalloc in Byte, den es zum Festhalten der Traces von Speicherblöcken braucht. Zurückgegeben wird ein int.

tracemalloc.is_tracing()¶

True, wenn das Modul tracemalloc Reservierungen von Python-Speicher aufzeichnet, sonst False.

Siehe auch die Funktionen start() und stop().

tracemalloc.start(nframe: int = 1)¶

Beginnt, Reservierungen von Python-Speicher aufzuzeichnen: Dazu werden Einhängepunkte in den Speicherverwaltungen von Python gesetzt. Die gesammelten Tracebacks der Traces sind auf nframe Frames begrenzt. Standardmäßig hält ein Trace zu einem Speicherblock nur den jüngsten Frame fest, die Grenze ist also 1. nframe muss größer oder gleich 1 sein.

Wie viele Frames der Traceback ursprünglich hatte, lässt sich weiterhin am Attribut Traceback.total_nframe ablesen.

Mehr als 1 Frame festzuhalten lohnt nur für Statistiken, die nach 'traceback' gruppiert sind, oder für kumulierte Statistiken. Siehe die Methoden Snapshot.compare_to() und Snapshot.statistics().

Mehr Frames festzuhalten erhöht den Speicher- und Rechenaufwand des Moduls tracemalloc. Wie viel Speicher das Modul tracemalloc braucht, misst die Funktion get_tracemalloc_memory().

Mit der Umgebungsvariablen PYTHONTRACEMALLOC (PYTHONTRACEMALLOC=NFRAME) und der Befehlszeilenoption -X tracemalloc=NFRAME lässt sich die Aufzeichnung schon beim Start beginnen.

Siehe auch die Funktionen stop(), is_tracing() und get_traceback_limit().

tracemalloc.stop()¶

Beendet die Aufzeichnung von Reservierungen in Python-Speicher: Die Einhängepunkte in den Speicherverwaltungen von Python werden entfernt. Außerdem werden alle bisher gesammelten Traces von Python reservierter Speicherblöcke verworfen.

Mit der Funktion take_snapshot() lässt sich vor dem Verwerfen ein Snapshot der Traces nehmen.

Siehe auch die Funktionen start(), is_tracing() und clear_traces().

tracemalloc.take_snapshot()¶

Nimmt einen Snapshot der Traces von Python reservierter Speicherblöcke. Zurückgegeben wird eine neue Instanz von Snapshot.

Speicherblöcke, die vor dem Beginn der Aufzeichnung durch das Modul tracemalloc reserviert wurden, enthält der Snapshot nicht.

Die Tracebacks der Traces sind auf get_traceback_limit() Frames begrenzt. Für mehr Frames dient der Parameter nframe der Funktion start().

Das Modul tracemalloc muss Reservierungen aufzeichnen, damit sich ein Snapshot nehmen lässt. Siehe die Funktion start().

Siehe auch die Funktion get_object_traceback().

DomainFilter¶

class tracemalloc.DomainFilter(inclusive: bool, domain: int)¶

Filtert Traces von Speicherblöcken nach ihrem Adressraum (Domain).

Added in version 3.6.

inclusive¶

Ist inclusive gleich True (einschließen), passen die Speicherblöcke, die im Adressraum domain reserviert wurden.

Ist inclusive gleich False (ausschließen), passen die Speicherblöcke, die nicht im Adressraum domain reserviert wurden.

domain¶: Adressraum eines Speicherblocks (int). Nur lesbares Property.

Filter¶

class tracemalloc.Filter(inclusive: bool, filename_pattern: str, lineno: int = None, all_frames: bool = False, domain: int = None)¶

Filter für Traces von Speicherblöcken.

Die Syntax von filename_pattern steht bei der Funktion fnmatch.fnmatch(). Die Dateiendung '.pyc' wird durch '.py' ersetzt.

Beispiele:

Filter(True, subprocess.__file__) schließt nur Traces des Moduls subprocess ein
Filter(False, tracemalloc.__file__) schließt Traces des Moduls tracemalloc aus
Filter(False, "<unknown>") schließt leere Tracebacks aus

Geändert in Version 3.5: Die Dateiendung '.pyo' wird nicht mehr durch '.py' ersetzt.

Geändert in Version 3.6: Das Attribut domain wurde hinzugefügt.

domain¶

Adressraum eines Speicherblocks (int oder None).

tracemalloc verwendet die Domain 0, um Reservierungen von Python aufzuzeichnen. C-Erweiterungen können andere Domains nutzen, um andere Ressourcen aufzuzeichnen.

inclusive¶

Ist inclusive gleich True (einschließen), passen nur die Speicherblöcke, die in einer Datei mit einem zu filename_pattern passenden Namen in Zeile lineno reserviert wurden.

Ist inclusive gleich False (ausschließen), bleiben die Speicherblöcke außer Betracht, die in einer Datei mit einem zu filename_pattern passenden Namen in Zeile lineno reserviert wurden.

lineno¶: Zeilennummer (int) des Filters. Ist lineno gleich None, passt der Filter auf jede Zeilennummer.

filename_pattern¶: Dateinamensmuster des Filters (str). Nur lesbares Property.

all_frames¶

Ist all_frames gleich True, werden alle Frames des Tracebacks geprüft. Ist all_frames gleich False, nur der jüngste Frame.

Dieses Attribut bleibt ohne Wirkung, wenn die Traceback-Grenze 1 ist. Siehe die Funktion get_traceback_limit() und das Attribut Snapshot.traceback_limit.

Frame¶

class tracemalloc.Frame¶

Frame eines Tracebacks.

Die Klasse Traceback ist eine Sequenz von Frame-Instanzen.

filename¶: Dateiname (str).

lineno¶: Zeilennummer (int).

Snapshot¶

class tracemalloc.Snapshot¶

Snapshot der Traces von Python reservierter Speicherblöcke.

Die Funktion take_snapshot() erzeugt eine Snapshot-Instanz.

compare_to(old_snapshot: Snapshot, key_type: str, cumulative: bool = False)¶

Berechnet die Unterschiede zu einem älteren Snapshot. Geliefert wird eine nach key_type gruppierte, sortierte Liste von StatisticDiff-Instanzen.

Zu den Parametern key_type und cumulative siehe die Methode Snapshot.statistics().

Das Ergebnis ist absteigend sortiert nach: Betrag von StatisticDiff.size_diff, StatisticDiff.size, Betrag von StatisticDiff.count_diff, Statistic.count und schließlich StatisticDiff.traceback.

dump(filename)¶

Schreibt den Snapshot in eine Datei.

Zum Zurückladen des Snapshots dient load().

filter_traces(filters)¶

Erzeugt eine neue Snapshot-Instanz mit gefilterter traces-Sequenz. filters ist eine Liste von DomainFilter- und Filter-Instanzen. Ist filters eine leere Liste, kommt eine neue Snapshot-Instanz mit einer Kopie der Traces zurück.

Alle einschließenden Filter greifen zugleich. Ein Trace bleibt außer Betracht, wenn kein einschließender Filter auf ihn passt. Ein Trace bleibt ebenso außer Betracht, wenn mindestens ein ausschließender Filter auf ihn passt.

Geändert in Version 3.6: In filters sind jetzt auch DomainFilter-Instanzen erlaubt.

classmethod load(filename)¶

Lädt einen Snapshot aus einer Datei.

Siehe auch dump().

statistics(key_type: str, cumulative: bool = False)¶

Liefert eine nach key_type gruppierte, sortierte Liste von Statistic-Instanzen:

key_type	Beschreibung
`'filename'`	Dateiname
`'lineno'`	Dateiname und Zeilennummer
`'traceback'`	Traceback

Ist cumulative gleich True, werden Größe und Anzahl der Speicherblöcke über alle Frames des Tracebacks eines Traces summiert, nicht nur über den jüngsten Frame. Dieser kumulierende Modus ist nur mit key_type gleich 'filename' oder 'lineno' möglich.

Das Ergebnis ist absteigend sortiert nach: Statistic.size, Statistic.count und schließlich Statistic.traceback.

traceback_limit¶: Größte Anzahl an Frames, die im Traceback von traces festgehalten sind: das Ergebnis von get_traceback_limit() zum Zeitpunkt des Snapshots.

traces¶

Traces aller von Python reservierten Speicherblöcke: eine Sequenz von Trace-Instanzen.

Die Reihenfolge der Sequenz ist nicht festgelegt. Eine sortierte Liste von Statistiken liefert die Methode Snapshot.statistics().

Statistic¶

class tracemalloc.Statistic¶

Statistik über Speicherreservierungen.

Snapshot.statistics() gibt eine Liste von Statistic-Instanzen zurück.

Siehe auch die Klasse StatisticDiff.

count¶: Anzahl der Speicherblöcke (int).

size¶: Gesamtgröße der Speicherblöcke in Byte (int).

traceback¶: Traceback der Stelle, an der der Speicherblock reserviert wurde. Eine Instanz von Traceback.

StatisticDiff¶

class tracemalloc.StatisticDiff¶

Unterschied der Statistik über Speicherreservierungen zwischen einer älteren und einer neueren Snapshot-Instanz.

Snapshot.compare_to() gibt eine Liste von StatisticDiff-Instanzen zurück. Siehe auch die Klasse Statistic.

count¶: Anzahl der Speicherblöcke im neuen Snapshot (int): 0, wenn die Speicherblöcke im neuen Snapshot freigegeben sind.

count_diff¶: Unterschied in der Anzahl der Speicherblöcke zwischen altem und neuem Snapshot (int).

size¶: Gesamtgröße der Speicherblöcke in Byte im neuen Snapshot (int): 0, wenn die Speicherblöcke im neuen Snapshot freigegeben sind.

size_diff¶: Unterschied in der Gesamtgröße der Speicherblöcke in Byte zwischen altem und neuem Snapshot (int).

traceback¶: Traceback der Stelle, an der die Speicherblöcke reserviert wurden. Eine Instanz von Traceback.

Trace¶

class tracemalloc.Trace¶

Trace eines Speicherblocks.

Das Attribut Snapshot.traces ist eine Sequenz von Trace-Instanzen.

Geändert in Version 3.6: Das Attribut domain wurde hinzugefügt.

domain¶

Adressraum eines Speicherblocks (int). Nur lesbares Property.

tracemalloc verwendet die Domain 0, um Reservierungen von Python aufzuzeichnen. C-Erweiterungen können andere Domains nutzen, um andere Ressourcen aufzuzeichnen.

size¶: Größe des Speicherblocks in Byte (int).

traceback¶: Traceback der Stelle, an der der Speicherblock reserviert wurde. Eine Instanz von Traceback.

Traceback¶

class tracemalloc.Traceback¶

Sequenz von Frame-Instanzen, sortiert vom ältesten zum jüngsten Frame.

Ein Traceback enthält mindestens 1 Frame. Konnte das Modul tracemalloc einen Frame nicht ermitteln, wird der Dateiname "<unknown>" mit Zeilennummer 0 verwendet.

Beim Nehmen eines Snapshots werden die Tracebacks der Traces auf get_traceback_limit() Frames begrenzt. Siehe die Funktion take_snapshot(). Die ursprüngliche Anzahl der Frames steht im Attribut Traceback.total_nframe. Daran lässt sich erkennen, ob die Traceback-Grenze einen Traceback abgeschnitten hat.

Das Attribut Trace.traceback ist eine Instanz von Traceback.

Geändert in Version 3.7: Frames sind jetzt vom ältesten zum jüngsten sortiert, nicht mehr vom jüngsten zum ältesten.

total_nframe¶: Gesamtzahl der Frames, aus denen der Traceback vor dem Abschneiden bestand. Dieses Attribut kann None sein, wenn die Information nicht vorliegt.

Geändert in Version 3.9: Das Attribut Traceback.total_nframe wurde hinzugefügt.

format(limit=None, most_recent_first=False)¶

Formatiert den Traceback als Liste von Zeilen. Die Zeilen des Quellcodes holt das Modul linecache. Ist limit gesetzt und positiv, werden die limit jüngsten Frames formatiert, andernfalls die abs(limit) ältesten. Ist most_recent_first gleich True, wird die Reihenfolge der formatierten Frames umgekehrt, der jüngste Frame steht dann zuerst statt zuletzt.

Ähnlich wie die Funktion traceback.format_tb(), nur enthält format() keine Zeilenumbrüche.

Beispiel:

print("Traceback (most recent call first):")
for line in traceback.format(most_recent_first=True):
    print(line)

Ausgabe:

Traceback (most recent call first):
  File "test.py", line 9
    obj = Object()
  File "test.py", line 12
    tb = tracemalloc.get_object_traceback(f())

`tracemalloc` — Speicherreservierungen aufzeichnen¶

Beispiele¶

Die zehn größten anzeigen¶

Unterschiede berechnen¶

Den Traceback eines Speicherblocks holen¶

Hübsche Bestenliste¶

Aktuelle und höchste Größe aller aufgezeichneten Speicherblöcke festhalten¶

API¶

Funktionen¶

DomainFilter¶

Filter¶

Frame¶

Snapshot¶

Statistic¶

StatisticDiff¶

Trace¶

Traceback¶

Inhaltsverzeichnis

Vorheriges Thema

Nächstes Thema

Diese Seite

tracemalloc — Speicherreservierungen aufzeichnen¶

Beispiele¶

Die zehn größten anzeigen¶

Unterschiede berechnen¶

Den Traceback eines Speicherblocks holen¶

Hübsche Bestenliste¶

Aktuelle und höchste Größe aller aufgezeichneten Speicherblöcke festhalten¶

API¶

Funktionen¶

DomainFilter¶

Filter¶

Frame¶

Snapshot¶

Statistic¶

StatisticDiff¶

Trace¶

Traceback¶

`tracemalloc` — Speicherreservierungen aufzeichnen¶