pdb — Pythons felsökare

Källkod: Lib/pdb.py

Modulen pdb definierar en interaktiv källkodsdebugger för Python-program. Den stöder inställning av (villkorliga) brytpunkter och single stepping på källkodsnivå, inspektion av stapelramar, källkodslistning och utvärdering av godtycklig Python-kod i samband med valfri stapelram. Den stöder också felsökning efter avslutad användning och kan anropas under programkontroll.

Felsökaren är utbyggbar – den är faktiskt definierad som klassen Pdb. Detta är för närvarande odokumenterat men lätt att förstå genom att läsa källan. Gränssnittet för utökning använder modulerna bdb och cmd.

Se även

Modul faulthandler

Används för att dumpa Python-spårningar explicit, vid ett fel, efter en timeout eller vid en användarsignal.

Modul traceback

Standardgränssnitt för att extrahera, formatera och skriva ut stackspår från Python-program.

Den typiska användningen för att bryta sig in i felsökaren är att infoga:

import pdb; pdb.set_trace()

Eller:

breakpoint()

på den plats där du vill bryta dig in i debuggern och kör sedan programmet. Du kan sedan gå igenom koden efter detta uttalande och fortsätta att köra utan debuggern med kommandot continue.

Ändrad i version 3.7: Den inbyggda breakpoint() kan, när den anropas med standardvärden, användas istället för import pdb; pdb.set_trace().

def double(x):
   breakpoint()
   return x * 2
val = 3
print(f"{val} * 2 is {double(val)}")

Felsökarens prompt är (Pdb), vilket är en indikator på att du befinner dig i felsökningsläge:

> ...(2)double()
-> breakpoint()
(Pdb) p x
3
(Pdb) continue
3 * 2 is 6

Ändrad i version 3.3: Tabbkomplettering via modulen readline är tillgänglig för kommandon och kommandonas argument, t.ex. erbjuds de aktuella globala och lokala namnen som argument för kommandot p.

Du kan också anropa pdb från kommandoraden för att felsöka andra skript. Till exempel:

python -m pdb [-c command] (-m module | -p pid | pyfile) [args ...]

När pdb anropas som en modul kommer den automatiskt att gå in i post-mortem-felsökning om det program som felsöks avslutas på ett onormalt sätt. Efter post-mortem-felsökning (eller efter normal avslutning av programmet) kommer pdb att starta om programmet. Automatisk omstart bevarar pdb:s status (t.ex. brytpunkter) och är i de flesta fall mer användbart än att avsluta felsökaren när programmet avslutas.

-c, --command <command>

För att utföra kommandon som om de vore angivna i en .pdbrc-fil; se Kommandon för felsökare.

Ändrad i version 3.2: Alternativet -c har lagts till.

-m <module>

För att exekvera moduler på samma sätt som python -m gör. Precis som med ett skript kommer felsökaren att pausa exekveringen precis före modulens första rad.

Ändrad i version 3.7: Lagt till alternativet -m.

-p, --pid <pid>

Anslut till processen med angiven PID.

Tillagd i version 3.14.

Om du vill koppla till en Python-process som körs för fjärrfelsökning använder du alternativet -p eller --pid med målprocessens PID:

python -m pdb -p 1234

Anteckning

Att ansluta till en process som är blockerad i ett systemanrop eller väntar på I/O fungerar först när nästa bytecode-instruktion utförs eller när processen får en signal.

Typisk användning för att exekvera en sats under kontroll av debuggern är:

>>> import pdb
>>> def f(x):
...     print(1 / x)
>>> pdb.run("f(2)")
> <string>(1)<module>()
(Pdb) continue
0.5
>>>

Den typiska användningen för att inspektera ett kraschat program är:

>>> import pdb
>>> def f(x):
...     print(1 / x)
...
>>> f(0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in f
ZeroDivisionError: division by zero
>>> pdb.pm()
> <stdin>(2)f()
(Pdb) p x
0
(Pdb)

Ändrad i version 3.13: Implementeringen av PEP 667 innebär att namntilldelningar som görs via pdb omedelbart kommer att påverka det aktiva scopet, även när det körs i ett optimized scope.

Modulen definierar följande funktioner, som alla går in i felsökaren på lite olika sätt:

pdb.run(statement, globals=None, locals=None)

Exekverar satsen (angiven som en sträng eller ett kodobjekt) under debuggerkontroll. Du kan sätta brytpunkter och skriva continue, eller så kan du stega genom satsen med step eller next (alla dessa kommandon förklaras nedan). De valfria argumenten globals och locals anger den miljö i vilken koden exekveras; som standard används ordlistan för modulen __main__. (Se förklaringen av de inbyggda funktionerna exec() eller eval())

pdb.runeval(expression, globals=None, locals=None)

Utvärdera uttrycket (givet som en sträng eller ett kodobjekt) under debuggerkontroll. När runeval() returnerar, returnerar den värdet av uttrycket. I övrigt är denna funktion lik run().

pdb.runcall(function, *args, **kwds)

Anropar funktionen (ett funktions- eller metodobjekt, inte en sträng) med de angivna argumenten. När runcall() returneras, returneras det som funktionsanropet returnerade. Felsökarprompten visas så snart funktionen har angetts.

pdb.set_trace(*, header=None, commands=None)

Gå in i debuggern vid den anropande stackramen. Detta är användbart för att hårdkoda en brytpunkt vid en viss punkt i ett program, även om koden inte felsöks på något annat sätt (t.ex. när ett påstående misslyckas). Om header anges skrivs den ut i konsolen precis innan felsökningen påbörjas. Argumentet commands, om det anges, är en lista med kommandon som ska utföras när felsökaren startar.

Ändrad i version 3.7: Argumentet header är endast nyckelord.

Ändrad i version 3.13: set_trace() kommer att gå in i felsökaren omedelbart, snarare än på nästa kodrad som ska exekveras.

Tillagd i version 3.14: Argumentet kommandon.

awaitable pdb.set_trace_async(*, header=None, commands=None)

asynkron version av set_trace(). Denna funktion bör användas inuti en asynkron funktion med await.

async def f():
    await pdb.set_trace_async()

await statements stöds om debuggern anropas av denna funktion.

Tillagd i version 3.14.

pdb.post_mortem(t=None)

Startar felsökning av det angivna undantaget eller traceback-objektet. Om inget värde anges används det undantag som för närvarande hanteras, eller ValueError om det inte finns något.

Ändrad i version 3.13: Stöd för undantagsobjekt har lagts till.

pdb.pm()

Starta felsökning efteråt av undantaget som hittades i sys.last_exc.

pdb.set_default_backend(backend)

Det finns två backends som stöds för pdb: 'settrace' och 'monitoring'. Se bdb.Bdb för mer information. Användaren kan ange vilken standardbackend som ska användas om ingen anges vid instansiering av Pdb. Om ingen backend specificeras är standard 'settrace'.

Anteckning

breakpoint() och set_trace() kommer inte att påverkas av denna funktion. De använder alltid 'monitoring' backend.

Tillagd i version 3.14.

pdb.get_default_backend()

Returnerar standardbackend för pdb.

Tillagd i version 3.14.

Funktionerna run* och set_trace`() är alias för att instansiera klassen Pdb och anropa metoden med samma namn. Om du vill ha tillgång till ytterligare funktioner måste du göra detta själv:

class pdb.Pdb(completekey='tab', stdin=None, stdout=None, skip=None, nosigint=False, readrc=True, mode=None, backend=None, colorize=False)

Pdb är klassen för felsökare.

Argumenten completekey, stdin och stdout skickas till den underliggande cmd.Cmd-klassen; se beskrivningen där.

Argumentet skip, om det anges, måste vara en iterabel av modulnamnsmönster i glob-stil. Felsökaren kommer inte att gå in i ramar som har sitt ursprung i en modul som matchar något av dessa mönster. [1]

Som standard ställer Pdb in en hanterare för SIGINT-signalen (som skickas när användaren trycker på Ctrl-C på konsolen) när du ger ett continue-kommando. Detta gör att du kan bryta dig in i felsökaren igen genom att trycka på Ctrl-C. Om du vill att Pdb inte ska röra SIGINT-hanteraren ska du sätta nosigint till true.

Argumentet readrc är som standard true och styr om Pdb ska läsa in .pdbrc-filer från filsystemet.

Argumentet mode anger hur felsökaren startades. Det påverkar hur vissa kommandon i felsökaren fungerar. Giltiga värden är 'inline' (används av breakpoint() builtin), 'cli' (används av kommandoradsinställningen) eller None (för bakåtkompatibelt beteende, som innan mode-argumentet lades till).

Argumentet backend anger vilken backend som ska användas för felsökaren. Om None skickas, kommer standardbackend att användas. Se set_default_backend(). Annars är de backends som stöds 'settrace' och 'monitoring'.

Argumentet colorize, om det sätts till True, aktiverar färgade utdata i felsökaren, om färg stöds. Detta kommer att markera källkod som visas i pdb.

Exempel på anrop för att aktivera spårning med skip:

import pdb; pdb.Pdb(skip=['django.*']).set_trace()

Utlöser en auditing event pdb.Pdb utan argument.

Ändrad i version 3.1: Lagt till parametern skip.

Ändrad i version 3.2: Parametern nosigint har lagts till. Tidigare ställdes aldrig en SIGINT-hanterare in av Pdb.

Ändrad i version 3.6: Argumentet readrc.

Tillagd i version 3.14: Lagt till argumentet mode.

Tillagd i version 3.14: Lagt till argumentet backend.

Tillagd i version 3.14: Lagt till argumentet colorize.

Ändrad i version 3.14: Inline breakpoints som breakpoint() eller pdb.set_trace() stoppar alltid programmet vid anropande frame och ignorerar skip-mönstret (om sådant finns).

run(statement, globals=None, locals=None)
runeval(expression, globals=None, locals=None)
runcall(function, *args, **kwds)
set_trace()

Se dokumentationen för de funktioner som beskrivs ovan.

Kommandon för felsökare

De kommandon som debuggern känner igen listas nedan. De flesta kommandon kan förkortas till en eller två bokstäver enligt vad som anges; t.ex. betyder h(elp) att antingen h eller help kan användas för att ange hjälpkommandot (men inte he eller hel, inte heller H eller Help eller HELP). Argument till kommandon måste separeras med blanksteg (mellanslag eller tabbar). Valfria argument omsluts av hakparenteser ([]) i kommandosyntaxen; hakparenteserna får inte skrivas. Alternativ i kommandosyntaxen separeras med en vertikal stapel (|).

Om du skriver in en tom rad upprepas det senast inskrivna kommandot. Undantag: om det senaste kommandot var ett list-kommando, listas de kommande 11 raderna.

Kommandon som debuggern inte känner igen antas vara Python-satser och körs i kontexten för det program som debuggas. Python-satser kan också inledas med ett utropstecken (!). Detta är ett kraftfullt sätt att inspektera det program som debuggas; det är till och med möjligt att ändra en variabel eller anropa en funktion. När ett undantag inträffar i ett sådant uttalande skrivs undantagsnamnet ut, men debuggarens tillstånd ändras inte.

Ändrad i version 3.13: Uttryck/satser vars prefix är ett pdb-kommando identifieras och exekveras nu korrekt.

Felsökaren stöder aliaser. Aliaser kan ha parametrar som ger en viss anpassningsförmåga till det sammanhang som undersöks.

Flera kommandon kan anges på en rad, åtskilda av ;;. (En enda ; används inte eftersom det är separatorn för flera kommandon på en rad som skickas till Python-parsern) Ingen intelligens används för att separera kommandona; indata delas upp vid det första ;;-paret, även om det är mitt i en citerad sträng. En lösning för strängar med dubbla semikolon är att använda implicit strängkonkatenering ';'';' eller ";"";".

Om du vill ställa in en tillfällig global variabel använder du en bekvämlighetsvariabel. En bekvämlighetsvariabel är en variabel vars namn börjar med $. Till exempel, $foo = 1 ställer in en global variabel $foo som du kan använda i felsökarsessionen. Bekvämlighetsvariablerna rensas när programmet återupptas, så det är mindre troligt att de stör programmet jämfört med om du använder normala variabler som foo = 1.

Det finns fyra förinställda bekvämlighetsvariabler:

  • $_frame: den aktuella bildrutan som du felsöker

  • $_retval: returvärdet om ramen returnerar

  • $_exception: undantaget om ramen ger upphov till ett undantag

  • $_asynctask: asyncio-uppgiften om pdb stannar i en asynkron funktion

Tillagd i version 3.12: Lagt till funktionen convenience variable.

Tillagd i version 3.14: Lagt till bekvämlighetsvariabeln $_asynctask.

Om filen .pdbrc finns i användarens hemkatalog eller i den aktuella katalogen, läses den med kodningen 'utf-8' och exekveras som om den hade skrivits i debuggerprompten, med undantaget att tomma rader och rader som börjar med # ignoreras. Detta är särskilt användbart för alias. Om båda filerna finns läses den som finns i hemkatalogen först och alias som definieras där kan åsidosättas av den lokala filen.

Ändrad i version 3.2: .pdbrc kan nu innehålla kommandon som fortsätter felsökningen, t.ex. continue eller next. Tidigare hade dessa kommandon ingen effekt.

Ändrad i version 3.11: .pdbrc läses nu med kodningen 'utf-8'. Tidigare lästes den med systemets lokala kodning.

h(elp) [command]

Utan argument skrivs en lista över tillgängliga kommandon ut. Med ett kommando som argument, skriv ut hjälp om det kommandot. help pdb visar den fullständiga dokumentationen (dokumentsträngen för modulen pdb). Eftersom argumentet command måste vara en identifierare måste help exec anges för att få hjälp med kommandot !.

w(here) [count]

Skriv ut en stackspårning, med den senaste ramen längst ned. om count är 0, skriv ut den aktuella ramposten. Om count är negativt, skriv ut de senaste - count ramarna. Om count är positiv, skriv ut de senaste count ramarna. En pil (>) anger aktuell bildruta, som bestämmer sammanhanget för de flesta kommandon.

Ändrad i version 3.14: count-argumentet läggs till.

d(own) [count]

Flytta den aktuella ramen antal (standard ett) nivåer nedåt i stackspårningen (till en nyare ram).

u(p) [count]

Flytta den aktuella ramen antal (standard ett) nivåer uppåt i stackspårningen (till en äldre ram).

b(reak) [([filename:]lineno | function) [, condition]]

Med ett lineno-argument, sätt en brytpunkt på rad lineno i den aktuella filen. Radnumret kan föregås av ett filnamn och ett kolon, för att ange en brytpunkt i en annan fil (eventuellt en som inte har laddats in ännu). Filen söks på sys.path. Godtagbara former av filnamn är /abspath/to/file.py, relpath/file.py, module och package.module.

Med ett function-argument, sätt en paus vid den första körbara satsen i den funktionen. function kan vara vilket uttryck som helst som utvärderas till en funktion i den aktuella namnrymden.

Om det finns ett andra argument är det ett uttryck som måste utvärderas till sant innan brytpunkten respekteras.

Utan argument listas alla brytpunkter, inklusive för varje brytpunkt, antalet gånger brytpunkten har träffats, aktuellt ignoreringsantal och eventuellt associerat villkor.

Varje brytpunkt tilldelas ett nummer som alla andra brytpunktskommandon hänvisar till.

tbreak [([filename:]lineno | function) [, condition]]

Tillfällig brytpunkt, som tas bort automatiskt när den träffas första gången. Argumenten är desamma som för break.

cl(ear) [filename:lineno | bpnumber ...]

Med ett filnamn:lineno-argument rensar du alla brytpunkter på denna rad. Med en mellanslagsseparerad lista med brytpunktsnummer rensas dessa brytpunkter. Utan argument, rensa alla brytpunkter (men be först om bekräftelse).

disable bpnumber [bpnumber ...]

Inaktivera brytpunkterna som anges som en blankstegssorterad lista med brytpunktsnummer. Att inaktivera en brytpunkt innebär att den inte kan orsaka att programmet stoppas, men till skillnad från att rensa en brytpunkt finns den kvar i listan över brytpunkter och kan (åter)aktiveras.

enable bpnumber [bpnumber ...]

Aktivera de angivna brytpunkterna.

ignore bpnumber [count]

Ställ in ignoreringsantalet för det angivna brytpunktsnumret. Om count utelämnas sätts ignoreringsantalet till 0. En brytpunkt blir aktiv när ignoreringsantalet är noll. Om count inte är noll minskas det varje gång brytpunkten nås och brytpunkten inte är inaktiverad och något associerat villkor utvärderas till sant.

condition bpnumber [condition]

Ange ett nytt villkor för brytpunkten, ett uttryck som måste utvärderas till sant innan brytpunkten respekteras. Om condition saknas tas alla befintliga villkor bort, dvs. brytpunkten görs ovillkorlig.

commands [bpnumber]

Ange en lista med kommandon för brytpunktsnummer bpnumber. Själva kommandona visas på följande rader. Skriv en rad som bara innehåller end för att avsluta kommandona. Ett exempel:

(Pdb) kommandon 1
(com) p någon_variabel
(com) slut
(Pdb)

För att ta bort alla kommandon från en brytpunkt, skriv kommandon och följ omedelbart efter med slut, dvs. ge inga kommandon.

Utan argumentet bpnumber hänvisar commands till den senast inställda brytpunkten.

Du kan använda brytpunktskommandon för att starta upp programmet igen. Använd helt enkelt kommandot continue, eller step, eller något annat kommando som återupptar exekveringen.

Om du anger ett kommando som återupptar körningen (för närvarande continue, step, next, return, until, jump, quit och deras förkortningar) avslutas kommandolistan (som om kommandot omedelbart följdes av end). Detta beror på att varje gång du återupptar körningen (även med ett enkelt next eller step) kan du stöta på en annan brytpunkt - som kan ha sin egen kommandolista, vilket leder till tvetydigheter om vilken lista som ska köras.

Om listan med kommandon innehåller kommandot silent, eller ett kommando som återupptar körningen, visas inte brytpunktsmeddelandet med information om ramen.

Ändrad i version 3.14: Raminformation visas inte om ett kommando som återupptar körningen finns i kommandolistan.

s(tep)

Exekvera den aktuella raden, stoppa vid första möjliga tillfälle (antingen i en funktion som anropas eller på nästa rad i den aktuella funktionen).

n(ext)

Fortsätter exekveringen tills nästa rad i den aktuella funktionen nås eller tills den returneras. (Skillnaden mellan next och step är att step stannar inuti en anropad funktion, medan next kör anropade funktioner i (nästan) full hastighet och bara stannar vid nästa rad i den aktuella funktionen)

unt(il) [lineno]

Utan argument fortsätter exekveringen tills raden med ett nummer som är större än det aktuella nås.

Med lineno fortsätter exekveringen tills en rad med ett nummer som är större än eller lika med lineno nås. I båda fallen stoppas också när den aktuella ramen återkommer.

Ändrad i version 3.2: Tillåt att ange ett explicit linjenummer.

r(eturn)

Fortsätt körningen tills den aktuella funktionen återkommer.

c(ont(inue))

Fortsätt exekveringen, stoppa först när en brytpunkt påträffas.

j(ump) lineno

Ange nästa rad som ska köras. Endast tillgängligt i den nedersta ramen. Detta gör att du kan hoppa tillbaka och exekvera kod igen, eller hoppa framåt för att hoppa över kod som du inte vill köra.

Det bör noteras att inte alla hopp är tillåtna – det är t.ex. inte möjligt att hoppa in i mitten av en for-loop eller ut ur en finally-klausul.

l(ist) [first[, last]]

Listar källkoden för den aktuella filen. Utan argument, lista 11 rader runt den aktuella raden eller fortsätt med föregående lista. Med . som argument listas 11 rader runt den aktuella raden. Med ett argument listas 11 rader runt den raden. Med två argument listas det angivna intervallet; om det andra argumentet är mindre än det första tolkas det som en räkning.

Den aktuella raden i den aktuella bildrutan anges med ->. Om ett undantag felsöks, anges raden där undantaget ursprungligen uppstod eller spreds med >>, om den skiljer sig från den aktuella raden.

Ändrad i version 3.2: Lade till markören >>.

ll | longlist

Lista all källkod för den aktuella funktionen eller ramen. Intressanta rader markeras som för list.

Tillagd i version 3.2.

a(rgs)

Skriv ut argumenten för den aktuella funktionen och deras aktuella värden.

p expression

Utvärdera uttryck i det aktuella sammanhanget och skriv ut dess värde.

Anteckning

print() kan också användas, men är inte ett debugger-kommando — detta exekverar Python print()-funktionen.

pp expression

Som kommandot p, förutom att värdet av uttryck skrivs ut med modulen pprint.

whatis expression

Skriv ut typen av uttryck.

source expression

Försök att få fram källkoden för uttryck och visa den.

Tillagd i version 3.2.

display [expression]

Visa värdet på uttryck om det har ändrats, varje gång exekveringen stoppas i den aktuella bildrutan.

Utan uttryck listas alla displayuttryck för den aktuella bildrutan.

Anteckning

Display utvärderar uttryck och jämför med resultatet av den föregående utvärderingen av uttryck, så när resultatet är föränderligt är det inte säkert att displayen kan fånga upp ändringarna.

Exempel:

lst = []
breakpoint()
pass
lst.append(1)
print(lst)

Displayen kommer inte att inse att lst har ändrats eftersom resultatet av utvärderingen modifieras på plats av lst.append(1) innan det jämförs:

> example.py(3)<module>()
-> pass
(Pdb) display lst
display lst: []
(Pdb) n
> example.py(4)<module>()
-> lst.append(1)
(Pdb) n
> example.py(5)<module>()
-> print(lst)
(Pdb)

Du kan göra några trick med kopieringsmekanismen för att få den att fungera:

> example.py(3)<module>()
-> pass
(Pdb) display lst[:]
display lst[:]: []
(Pdb) n
> example.py(4)<module>()
-> lst.append(1)
(Pdb) n
> example.py(5)<module>()
-> print(lst)
display lst[:]: [1]  [old: []]
(Pdb)

Tillagd i version 3.2.

undisplay [expression]

Visa inte uttryck längre i den aktuella bildrutan. Utan uttryck rensas alla visningsuttryck för den aktuella ramen.

Tillagd i version 3.2.

interact

Starta en interaktiv tolk (med modulen code) i en ny global namnrymd som initieras från de lokala och globala namnrymderna för det aktuella området. Använd exit() eller quit() för att avsluta tolken och återgå till felsökaren.

Anteckning

Eftersom interact skapar ett nytt dedikerat namnrymd för exekvering av kod, kommer tilldelningar till variabler inte att påverka de ursprungliga namnrymderna. Modifieringar av alla refererade mutabla objekt kommer dock att återspeglas i de ursprungliga namnrymderna som vanligt.

Tillagd i version 3.2.

Ändrad i version 3.13: exit() och quit() kan användas för att avsluta kommandot interact.

Ändrad i version 3.13: interact styr utdata till debuggarens utdatakanal i stället för till sys.stderr.

alias [name [command]]

Skapa ett alias som heter namn och som utför kommando. kommandot får inte vara omslutet av citationstecken. Ersättningsbara parametrar kan anges med %1, %2, … och %9, medan %* ersätts av alla parametrar. Om kommando utelämnas visas det aktuella aliaset för namn. Om inga argument anges listas alla alias.

Alias kan vara nästlade och kan innehålla vad som helst som lagligen kan skrivas vid pdb-prompten. Observera att interna pdb-kommandon kan åsidosättas av alias. Ett sådant kommando är då dolt tills aliaset tas bort. Alias tillämpas rekursivt på det första ordet i kommandoraden; alla andra ord i raden lämnas obehandlade.

Som exempel kan nämnas två användbara alias (särskilt när de placeras i filen .pdbrc):

# Skriv ut instansvariabler (användning "pi classInst")
alias pi for k in %1.__dict__.keys(): print(f"%1.{k} = {%1.__dict__[k]}")
# Skriv ut instansvariabler i self
alias ps pi själv
unalias name

Ta bort det angivna aliaset namn.

! statement

Exekvera (enradigt) uttalandet i kontexten för den aktuella stackramen. Utropstecknet kan utelämnas om inte det första ordet i satsen liknar ett debugger-kommando, t.ex:

(Pdb) ! n=42
(Pdb)

För att ställa in en global variabel kan du prefixera assignment-kommandot med en global-sats på samma rad, t.ex:

(Pdb) global list_options; list_options = ['-l']
(Pdb)
run [args ...]
restart [args ...]

Startar om det felsökta Python-programmet. Om args anges delas den upp med shlex och resultatet används som ny sys.argv. Historik, brytpunkter, åtgärder och debuggaralternativ bevaras. restart är ett alias för run.

Ändrad i version 3.14: kommandona run och restart inaktiveras när debuggern anropas i 'inline'-läge.

q(uit)

Avsluta från felsökaren. Det program som körs avbryts. En inmatning vid slutet av filen motsvarar quit.

En bekräftelseprompt visas om felsökaren anropas i 'inline'-läge. Antingen y, Y, <Enter> eller EOF kommer att bekräfta avslutningen.

Ändrad i version 3.14: En bekräftelseprompt visas om felsökaren anropas i 'inline'-läge. Efter bekräftelsen anropar felsökaren sys.exit() omedelbart, i stället för bdb.BdbQuit i nästa spårningshändelse.

debug code

Ange en rekursiv felsökare som går igenom kod (vilket är ett godtyckligt uttryck eller en sats som ska utföras i den aktuella miljön).

retval

Skriv ut returvärdet för den sista returen i den aktuella funktionen.

exceptions [excnumber]

Lista eller hoppa mellan kedjade undantag.

När du använder pdb.pm() eller Pdb.post_mortem(...) med ett kedjat undantag istället för en spårning, tillåter det användaren att flytta mellan de kedjade undantagen med kommandot exceptions för att lista undantag och exceptions <number> för att byta till det undantaget.

Exempel:

def out():
    try:
        middle()
    except Exception as e:
        raise ValueError("reraise middle() error") from e

def middle():
    try:
        return inner(0)
    except Exception as e:
        raise ValueError("Middle fail")

def inner(x):
    1 / x

 out()

att anropa pdb.pm() kommer att göra det möjligt att flytta mellan undantag:

> example.py(5)out()
-> raise ValueError("reraise middle() error") from e

(Pdb) exceptions
  0 ZeroDivisionError('division by zero')
  1 ValueError('Middle fail')
> 2 ValueError('reraise middle() error')

(Pdb) exceptions 0
> example.py(16)inner()
-> 1 / x

(Pdb) up
> example.py(10)middle()
-> return inner(0)

Tillagd i version 3.13.

Fotnoter