`dis` — Disassemblerare för Python bytecode¶

Källkod: Lib/dis.py

Modulen dis stöder analys av CPython bytecode genom att demontera den. CPython-bytekoden som den här modulen tar som indata definieras i filen Include/opcode.h och används av kompilatorn och tolken.

Bytecode är en implementationsdetalj av CPython-tolken. Det finns inga garantier för att bytecode inte kommer att läggas till, tas bort eller ändras mellan olika versioner av Python. Användning av denna modul bör inte anses fungera över Python VM eller Python-versioner.

Ändrad i version 3.6: Använd 2 byte för varje instruktion. Tidigare varierade antalet byte beroende på instruktion.

Ändrad i version 3.10: Argumentet för hopp-, undantagshanterings- och loopinstruktioner är nu instruktionsoffset i stället för byteoffset.

Ändrad i version 3.11: Vissa instruktioner åtföljs av en eller flera inline-cacheposter, som har formen av CACHE-instruktioner. Dessa instruktioner är dolda som standard, men kan visas genom att skicka show_caches=True till valfritt dis-verktyg. Dessutom anpassar tolken nu bytekoden för att specialisera den för olika körtidsförhållanden. Den adaptiva bytekoden kan visas genom att ange adaptive=True.

Ändrad i version 3.12: Argumentet för ett hopp är målinstruktionens offset i förhållande till den instruktion som visas omedelbart efter hoppinstruktionens CACHE-poster.

Följaktligen är förekomsten av instruktionerna CACHE transparent för hopp framåt, men måste tas med i beräkningen när man resonerar om hopp bakåt.

Ändrad i version 3.13: Utdata visar logiska etiketter i stället för instruktionsoffset för hoppmål och undantagshanterare. Kommandoradsalternativet \-O och argumentet show_offsets har lagts till.

Ändrad i version 3.14: Kommandoradsalternativet -P och argumentet show_positions har lagts till.

Kommandoradsalternativet -S har lagts till.

Exempel: Givet funktionen myfunc():

def myfunc(alist):
    returnera len(alist)

följande kommando kan användas för att visa demonteringen av myfunc():

>>> dis.dis(myfunc)
  2           RESUME                   0

  3           LOAD_GLOBAL              1 (len + NULL)
              LOAD_FAST_BORROW         0 (alist)
              CALL                     1
              RETURN_VALUE

(”2” är ett radnummer).

Kommandoradsgränssnitt¶

Modulen dis kan anropas som ett skript från kommandoraden:

python -m dis [-h] [-C] [-O] [-P] [-S] [infile]

Följande alternativ accepteras:

-h, --help¶: Visa användning och avsluta.

-C, --show-caches¶: Visa inline-cacher.

Tillagd i version 3.13.

-O, --show-offsets¶: Visa offsets för instruktioner.

Tillagd i version 3.13.

-P, --show-positions¶: Visa var instruktionerna finns i källkoden.

Tillagd i version 3.14.

-S, --specialized¶: Visa specialiserad bytekod.

Tillagd i version 3.14.

Om infile anges kommer dess demonterade kod att skrivas till stdout. I annat fall utförs demonteringen på kompilerad källkod som tas emot från stdin.

Bytecode-analys¶

Tillagd i version 3.4.

API:et för bytecodeanalys gör att delar av Python-koden kan förpackas i ett Bytecode-objekt som ger enkel åtkomst till detaljer i den kompilerade koden.

class dis.Bytecode(x, *, first_line=None, current_offset=None, show_caches=False, adaptive=False, show_offsets=False, show_positions=False)¶

Analysera bytekoden som motsvarar en funktion, generator, asynkron generator, coroutine, metod, sträng med källkod eller ett kodobjekt (som returneras av compile()).

Detta är en bekväm omslutning av många av de funktioner som anges nedan, särskilt get_instructions(), eftersom iterering över en Bytecode-instans ger bytecode-operationerna som Instruction-instanser.

Om first_line inte är None, anges det radnummer som ska rapporteras för den första källkodsraden i den demonterade koden. I annat fall hämtas informationen om källraden (om sådan finns) direkt från det demonterade kodobjektet.

Om current_offset inte är None, refererar det till en instruktionsoffset i den demonterade koden. Om du ställer in detta betyder det att dis() kommer att visa en ”aktuell instruktion”-markör mot den angivna opkoden.

Om show_caches är True kommer dis() att visa inline-cacheposter som används av tolken för att specialisera bytekoden.

Om adaptive är True kommer dis() att visa specialiserad bytekod som kan skilja sig från den ursprungliga bytekoden.

Om show_offsets är True kommer dis() att inkludera instruktionsoffsets i utdata.

Om show_positions är True kommer dis() att inkludera positioner för instruktionskällkod i utdata.

classmethod from_traceback(tb, *, show_caches=False)¶: Konstruera en Bytecode-instans från den angivna tracebacken, och sätt current_offset till den instruktion som är ansvarig för undantaget.

codeobj¶: Det kompilerade kodobjektet.

first_line¶: Den första källraden i kodobjektet (om den finns tillgänglig)

dis()¶: Returnerar en formaterad vy av bytecode-operationerna (samma som skrivs ut av dis.dis(), men returneras som en sträng med flera rader).

info()¶: Returnerar en formaterad sträng med flera rader med detaljerad information om kodobjektet, som code_info().

Ändrad i version 3.7: Detta kan nu hantera coroutine- och asynkrona generatorobjekt.

Ändrad i version 3.11: Parametrarna show_caches och adaptive har lagts till.

Ändrad i version 3.13: Parametern show_offsets har lagts till

Ändrad i version 3.14: Parametern show_positions har lagts till.

Exempel:

>>> bytecode = dis.Bytecode(myfunc)
>>> for instr in bytecode:
...     print(instr.opname)
...
RESUME
LOAD_GLOBAL
LOAD_FAST_BORROW
CALL
RETURN_VALUE

Analysfunktioner¶

Modulen dis definierar även följande analysfunktioner som omvandlar indata direkt till önskad utdata. De kan vara användbara om endast en enda operation utförs, så att det mellanliggande analysobjektet inte är användbart:

dis.code_info(x)¶

Returnerar en formaterad flerradig sträng med detaljerad kodobjektinformation för den angivna funktionen, generatorn, asynkrongeneratorn, coroutinen, metoden, källkodsträngen eller kodobjektet.

Observera att det exakta innehållet i kodinfosträngarna är mycket beroende av implementationen och att det kan ändras godtyckligt mellan olika Python-VM:er eller Python-utgåvor.

Tillagd i version 3.2.

Ändrad i version 3.7: Detta kan nu hantera coroutine- och asynkrona generatorobjekt.

dis.show_code(x, *, file=None)¶

Skriv ut detaljerad kodobjektinformation för den angivna funktionen, metoden, källkodsträngen eller kodobjektet till file (eller sys.stdout om file inte anges).

Detta är en praktisk kortform för print(code_info(x), file=file), avsedd för interaktiv utforskning vid tolkens prompt.

Tillagd i version 3.2.

Ändrad i version 3.4: Parametern file har lagts till.

dis.dis(x=None, *, file=None, depth=None, show_caches=False, adaptive=False, show_offsets=False, show_positions=False)¶

Demontera x-objektet. x kan beteckna antingen en modul, en klass, en metod, en funktion, en generator, en asynkron generator, en coroutine, ett kodobjekt, en sträng med källkod eller en byte-sekvens med rå bytecode. För en modul demonteras alla funktioner. För en klass demonteras alla metoder (inklusive klass- och statiska metoder). För ett kodobjekt eller en sekvens av rå bytecode skrivs en rad per bytecode-instruktion ut. Den demonterar även nästlade kodobjekt rekursivt. Dessa kan inkludera generatoruttryck, nästlade funktioner, kropparna i nästlade klasser och de kodobjekt som används för annotation scopes. Strängar kompileras först till kodobjekt med den inbyggda funktionen compile() innan de plockas isär. Om inget objekt anges, demonterar denna funktion det senaste traceback.

Demonteringen skrivs som text till det medföljande file-argumentet om det tillhandahålls och till sys.stdout annars.

Det maximala djupet för rekursion begränsas av depth om det inte är None. depth=0 innebär ingen rekursion.

Om show_caches är True, kommer denna funktion att visa inline cache-poster som används av tolken för att specialisera bytekoden.

Om adaptive är True, kommer denna funktion att visa specialiserad bytecode som kan skilja sig från den ursprungliga bytecoden.

Ändrad i version 3.4: Parametern file har lagts till.

Ändrad i version 3.7: Implementerade rekursiv demontering och lade till parametern depth.

Ändrad i version 3.7: Detta kan nu hantera coroutine- och asynkrona generatorobjekt.

Ändrad i version 3.11: Parametrarna show_caches och adaptive har lagts till.

Ändrad i version 3.13: Parametern show_offsets har lagts till.

Ändrad i version 3.14: Parametern show_positions har lagts till.

dis.distb(tb=None, *, file=None, show_caches=False, adaptive=False, show_offset=False, show_positions=False)¶

Demontera funktionen högst upp i stapeln för en spårning, med hjälp av den sista spårningen om ingen har skickats. Den instruktion som orsakade undantaget anges.

Demonteringen skrivs som text till det medföljande file-argumentet om det tillhandahålls och till sys.stdout annars.

Ändrad i version 3.4: Parametern file har lagts till.

Ändrad i version 3.11: Parametrarna show_caches och adaptive har lagts till.

Ändrad i version 3.13: Parametern show_offsets har lagts till.

Ändrad i version 3.14: Parametern show_positions har lagts till.

dis.disassemble(code, lasti=-1, *, file=None, show_caches=False, adaptive=False, show_offsets=False, show_positions=False)¶

dis.disco(code, lasti=-1, *, file=None, show_caches=False, adaptive=False, show_offsets=False, show_positions=False)¶

Demontera ett kodobjekt och ange den sista instruktionen om lasti har angetts. Utmatningen är uppdelad i följande kolumner:

instruktionens plats i källkoden. Fullständig platsinformation visas om show_positions är true. Annars (standard) visas endast radnumret.
den aktuella instruktionen, angiven som \-->,
en märkt instruktion, markerad med >>,
adressen till instruktionen,
operationens kodnamn,
driftsparametrar, och
tolkning av parametrarna inom parentes.

Parametertolkningen känner igen lokala och globala variabelnamn, konstantvärden, förgreningsmål och jämförelseoperatorer.

Demonteringen skrivs som text till det medföljande file-argumentet om det tillhandahålls och till sys.stdout annars.

Ändrad i version 3.4: Parametern file har lagts till.

Ändrad i version 3.11: Parametrarna show_caches och adaptive har lagts till.

Ändrad i version 3.13: Parametern show_offsets har lagts till.

Ändrad i version 3.14: Parametern show_positions har lagts till.

dis.get_instructions(x, *, first_line=None, show_caches=False, adaptive=False)¶

Returnerar en iterator över instruktionerna i den angivna funktionen, metoden, källkodsträngen eller kodobjektet.

Iteratorn genererar en serie Instruction-namngivna tuples som ger detaljerna för varje operation i den medföljande koden.

Om first_line inte är None, anges det radnummer som ska rapporteras för den första källkodsraden i den demonterade koden. I annat fall hämtas informationen om källraden (om sådan finns) direkt från det demonterade kodobjektet.

Parametern adaptive fungerar som den gör i dis().

Tillagd i version 3.4.

Ändrad i version 3.11: Parametrarna show_caches och adaptive har lagts till.

Ändrad i version 3.13: Parametern show_caches är föråldrad och har ingen effekt. Iteratorn genererar Instruction-instanser med fältet cache_info ifyllt (oavsett värdet på show_caches) och den genererar inte längre separata objekt för cache-posterna.

dis.findlinestarts(code)¶: Denna generatorfunktion använder metoden co_lines() i code object code för att hitta de offsets som är början på rader i källkoden. De genereras som par av typen (offset, lineno).

Ändrad i version 3.6: Linjenummer kan vara minskande. Tidigare var de alltid ökande.

Ändrad i version 3.10: Metoden PEP 626 co_lines() används istället för attributen co_firstlineno och co_lnotab i codeobjekt.

Ändrad i version 3.13: Radnummer kan vara None för bytecode som inte mappas till källkodsrader.

dis.findlabels(code)¶: Detektera alla offsets i den råa kompilerade bytecode-strängen code som är hoppmål och returnera en lista över dessa offsets.

dis.stack_effect(opcode, oparg=None, *, jump=None)¶

Beräkna stapeleffekten av opcode med argumentet oparg.

Om koden har ett hoppmål och jump är True, kommer stack_effect() att returnera stapeleffekten av att hoppa. Om jump är False, kommer den att returnera stapeleffekten av att inte hoppa. Och om jump är None (standard), kommer den att returnera den maximala stapeleffekten av båda fallen.

Tillagd i version 3.4.

Ändrad i version 3.8: Lagt till parametern jump.

Ändrad i version 3.13: Om oparg utelämnas (eller None), returneras nu stackeffekten för oparg=0. Tidigare var detta ett fel för opkoder som använder sitt arg. Det är inte heller längre ett fel att skicka ett heltal oparg när opcode inte använder det; oparg ignoreras i detta fall.

Instruktioner för Python Bytecode¶

Funktionen get_instructions() och klassen Bytecode ger detaljer om bytecode-instruktioner som Instruction-instanser:

class dis.Instruction¶

Detaljer för en bytecode-operation

opcode¶: numerisk kod för operationen, som motsvarar de opcode-värden som anges nedan och bytecode-värdena i Opcode-samlingar.

opname¶: mänskligt läsbart namn för operationen

baseopcode¶: numerisk kod för basoperationen om operationen är specialiserad; annars lika med opcode

baseopname¶: mänskligt läsbart namn för basoperationen om operationen är specialiserad; annars lika med opname

arg¶: numeriskt argument till operationen (om sådant finns), annars None

oparg¶: alias för arg

argval¶: löst arg-värde (om sådant finns), annars None

argrepr¶: mänsklig läsbar beskrivning av operationsargumentet (om sådant finns), annars en tom sträng.

offset¶: startindex för operation inom bytecode-sekvens

start_offset¶: startindex för operation inom bytecode-sekvens, inklusive prefixet EXTENDED_ARG om sådant finns; annars lika med offset

cache_offset¶: startindex för de cacheposter som följer efter operationen

end_offset¶: slutindex för de cacheposter som följer på operationen

starts_line¶: True om denna opcode startar en källkodsrad, annars False

line_number¶: källans radnummer associerat med denna opcode (om det finns någon), annars None

is_jump_target¶: True om annan kod hoppar till här, annars False

jump_target¶: bytecode-index för hoppmålet om detta är en hoppoperation, annars None

positions¶: dis.Positions-objekt som innehåller de start- och slutpositioner som omfattas av denna instruktion.

cache_info¶: Information om instruktionens cacheposter, som tripletter av formen (name, size, data), där name och size beskriver cacheformatet och data är innehållet i cachen. cache_info är None om instruktionen inte har några cacheminnen.

Tillagd i version 3.4.

Ändrad i version 3.11: Fältet positions har lagts till.

Ändrad i version 3.13: Ändrat fält starts_line.

Lagt till fälten start_offset, cache_offset, end_offset, baseopname, baseopcode, jump_target, oparg, line_number och cache_info.

class dis.Positions¶

Om informationen inte är tillgänglig kan vissa fält vara None.

lineno¶

end_lineno¶

col_offset¶

end_col_offset¶

Tillagd i version 3.11.

Python-kompilatorn genererar för närvarande följande bytecode-instruktioner.

Allmänna instruktioner

I det följande kommer vi att referera till tolkens stack som STACK och beskriva operationer på den som om den vore en Python-lista. Toppen av stacken motsvarar STACK[-1] i detta språk.

NOP¶: Gör ingenting-kod. Används som platshållare av bytekodsoptimeraren och för att generera linjespårningshändelser.

POP_TOP¶

Tar bort det översta objektet i stapeln:

STACK.pop()

END_FOR¶: Tar bort det översta objektet i stapeln. Motsvarar POP_TOP. Används för att städa upp i slutet av loopar, därav namnet.

Tillagd i version 3.12.

END_SEND¶: Implementerar del STACK[-2]. Används för att städa upp när en generator lämnar.

Tillagd i version 3.12.

COPY(i)¶

Lägg det i:te föremålet överst i högen utan att ta bort det från dess ursprungliga plats:

assert i > 0
STACK.append(STACK[-i])

Tillagd i version 3.11.

SWAP(i)¶

Byt ut toppen av stacken mot det i:e elementet:

STACK[-i], STACK[-1] = STACK[-1], STACK[-i]

Tillagd i version 3.11.

CACHE¶

I stället för att vara en faktisk instruktion används denna opcode för att markera extra utrymme för tolken att cacha användbara data direkt i själva bytekoden. Den döljs automatiskt av alla dis verktyg, men kan visas med show_caches=True.

Logiskt sett är detta utrymme en del av den föregående instruktionen. Många opkoder förväntar sig att följas av ett exakt antal cacher, och instruerar tolken att hoppa över dem vid körning.

Fyllda cacheminnen kan se ut som godtyckliga instruktioner, så stor försiktighet bör iakttas vid läsning eller modifiering av rå, adaptiv bytecode som innehåller quickened data.

Tillagd i version 3.11.

Unära operationer

Unära operationer tar toppen av stapeln, tillämpar operationen och skjuter tillbaka resultatet på stapeln.

UNARY_NEGATIVE¶: Tillämpar STACK[-1] = -STACK[-1].

UNARY_NOT¶: Tillämpar STACK[-1] = not STACK[-1].

Ändrad i version 3.13: Denna instruktion kräver nu ett exakt bool-operand.

UNARY_INVERT¶: Tillämpar STACK[-1] = ~STACK[-1].

GET_ITER¶: Tillämpar STACK[-1] = iter(STACK[-1]).

GET_YIELD_FROM_ITER¶: Om STACK[-1] är ett generator iterator eller coroutine objekt lämnas det som det är. I annat fall implementeras STACK[-1] = iter(STACK[-1]).

Tillagd i version 3.5.

TO_BOOL¶: Tillämpar STACK[-1] = bool(STACK[-1]).

Tillagd i version 3.13.

Binär- och platsoperationer

Binära operationer tar bort de två översta objekten från stacken (STACK[-1] och STACK[-2]). De utför operationen och lägger sedan tillbaka resultatet på stapeln.

In-place-operationer är som binära operationer, men operationen görs in-place när STACK[-2] stöder det, och den resulterande STACK[-1] kan vara (men behöver inte vara) den ursprungliga STACK[-2].

BINARY_OP(op)¶

Implementerar binära och in-place-operatorer (beroende på värdet av op):

rhs = STACK.pop()
lhs = STACK.pop()
STACK.append(lhs op rhs)

Tillagd i version 3.11.

Ändrad i version 3.14: Med oparg :NB_SUBSCR, implementerar binärt subscript (ersätter opcode BINARY_SUBSCR)

STORE_SUBSCR¶

Implementerar:

key = STACK.pop()
container = STACK.pop()
value = STACK.pop()
container[key] = value

DELETE_SUBSCR¶

Implementerar:

key = STACK.pop()
container = STACK.pop()
del container[key]

BINARY_SLICE¶

Implementerar:

end = STACK.pop()
start = STACK.pop()
container = STACK.pop()
STACK.append(container[start:end])

Tillagd i version 3.12.

STORE_SLICE¶

Implementerar:

end = STACK.pop()
start = STACK.pop()
container = STACK.pop()
values = STACK.pop()
container[start:end] = value

Tillagd i version 3.12.

Coroutine-operationskoder

GET_AWAITABLE(where)¶

Implementerar STACK[-1] = get_awaitable(STACK[-1]), där get_awaitable(o) returnerar o om o är ett coroutine-objekt eller ett generatorobjekt med CO_ITERABLE_COROUTINE-flaggan, eller löser o.__await__.

Om operanden where inte är noll anger den var instruktionen inträffar:

1: Efter ett samtal till __aenter__

2: Efter ett anrop till __aexit__

Tillagd i version 3.5.

Ändrad i version 3.11: Tidigare hade denna instruktion inte någon oparg.

GET_AITER¶: Tillämpar STACK[-1] = STACK[-1].__aiter__().

Tillagd i version 3.5.

Ändrad i version 3.7: Att returnera väntande objekt från __aiter__ stöds inte längre.

GET_ANEXT¶: Implementera STACK.append(get_awaitable(STACK[-1].__anext__())) till stacken. Se GET_AWAITABLE för detaljer om get_awaitable.

Tillagd i version 3.5.

END_ASYNC_FOR¶: Avslutar en async for-slinga. Hanterar ett undantag som uppstår i väntan på nästa objekt. Stapeln innehåller den asynkrona iterabeln i STACK[-2] och det undantag som uppstod i STACK[-1]. Båda poppas. Om undantaget inte är StopAsyncIteration, tas det upp igen.

Tillagd i version 3.8.

Ändrad i version 3.11: Undantagsrepresentationen på stacken består nu av ett, inte tre, objekt.

CLEANUP_THROW¶: Hanterar ett undantag som uppstår under ett anrop av throw() eller close() genom den aktuella ramen. Om STACK[-1] är en instans av StopIteration, popa tre värden från stacken och pusha dess value medlem. I annat fall höjer du STACK[-1] igen.

Tillagd i version 3.12.

Diverse opkoder

SET_ADD(i)¶

Implementerar:

item = STACK.pop()
set.add(STACK[-i], item)

Används för att implementera set comprehensions.

LIST_APPEND(i)¶

Implementerar:

item = STACK.pop()
list.append(STACK[-i], item)

Används för att implementera listförståelse.

MAP_ADD(i)¶

Implementerar:

value = STACK.pop()
key = STACK.pop()
dict.__setitem__(STACK[-i], key, value)

Används för att implementera diktförståelse.

Tillagd i version 3.1.

Ändrad i version 3.8: Kartans värde är STACK[-1] och kartans nyckel är STACK[-2]. Tidigare var de omvända.

För alla instruktionerna SET_ADD, LIST_APPEND och MAP_ADD, medan det tillagda värdet eller nyckel/värde-paret poppas ut, ligger containerobjektet kvar på stacken så att det är tillgängligt för ytterligare iterationer av loopen.

RETURN_VALUE¶: Returneras med STACK[-1] till den som anropar funktionen.

YIELD_VALUE¶: Ger STACK.pop() från en generator.

Ändrad i version 3.11: oparg satt till att vara stackdjupet.

Ändrad i version 3.12: oparg satt till att vara undantagsblockets djup, för effektiv stängning av generatorer.

Ändrad i version 3.13: oparg är 1 om denna instruktion är en del av en yield-from eller await, och 0 annars.

SETUP_ANNOTATIONS¶: Kontrollerar om __annotations__ är definierad i locals(), om inte sätts den upp till en tom dict. Denna opcode skickas endast ut om en klass eller modul innehåller variable annotations statiskt.

Tillagd i version 3.6.

POP_EXCEPT¶: Plockar upp ett värde från stacken, som används för att återställa undantagstillståndet.

Ändrad i version 3.11: Undantagsrepresentationen på stacken består nu av ett, inte tre, objekt.

RERAISE¶: Återupptar undantaget som för närvarande ligger överst på stacken. Om oparg inte är noll, plockas ett ytterligare värde från stacken som används för att ställa in f_lasti för den aktuella ramen.

Tillagd i version 3.9.

Ändrad i version 3.11: Undantagsrepresentationen på stacken består nu av ett, inte tre, objekt.

PUSH_EXC_INFO¶: Plockar ett värde från stacken. Flyttar det aktuella undantaget till toppen av stacken. Skjuter tillbaka det ursprungligen poppade värdet till stacken. Används i undantagshanterare.

Tillagd i version 3.11.

CHECK_EXC_MATCH¶: Utför undantagsmatchning för except. Testar om STACK[-2] är ett undantag som matchar STACK[-1]. Plockar upp STACK[-1] och lägger till det booleska resultatet av testet.

Tillagd i version 3.11.

CHECK_EG_MATCH¶

Utför undantagsmatchning för except*. Tillämpar split(STACK[-1]) på den undantagsgrupp som representerar STACK[-2].

Vid en matchning plockas två objekt från stacken och den icke-matchande undergruppen (None vid fullständig matchning) skjuts upp, följt av den matchande undergruppen. När det inte finns någon matchning, plockas ett objekt (matchningstypen) ut och None skjuts in.

Tillagd i version 3.11.

WITH_EXCEPT_START¶: Anropar funktionen i position 4 på stacken med argument (type, val, tb) som representerar undantaget högst upp på stacken. Används för att implementera anropet context_manager.__exit__(*exc_info()) när ett undantag har inträffat i en with-sats.

Tillagd i version 3.9.

Ändrad i version 3.11: Funktionen __exit__ ligger på position 4 i stacken i stället för 7. Undantagsrepresentationen på stacken består nu av ett objekt i stället för tre.

LOAD_COMMON_CONSTANT¶: Skjuter upp en vanlig konstant på stacken. Tolken innehåller en hårdkodad lista över konstanter som stöds av denna instruktion. Används av assert-satsen för att ladda AssertionError.

Tillagd i version 3.14.

LOAD_BUILD_CLASS¶: Lägger builtins.__build_class__() på stacken. Den anropas senare för att konstruera en klass.

GET_LEN¶: Utför STACK.append(len(STACK[-1])). Används i match-satser där jämförelse med mönstrets struktur behövs.

Tillagd i version 3.10.

MATCH_MAPPING¶: Om STACK[-1] är en instans av collections.abc.Mapping (eller, mer tekniskt: om den har Py_TPFLAGS_MAPPING flaggan inställd i sin tp_flags), lägg True på stacken. Annars läggs False till.

Tillagd i version 3.10.

MATCH_SEQUENCE¶: Om STACK[-1] är en instans av collections.abc.Sequence och inte är en instans av str/bytes/bytearray (eller, mer tekniskt: om den har Py_TPFLAGS_SEQUENCE flaggan inställd i sin tp_flags), lägg True på stacken. Annars läggs False till.

Tillagd i version 3.10.

MATCH_KEYS¶: STACK[-1] är en tupel med mappningsnycklar och STACK[-2] är matchningsobjektet. Om STACK[-2] innehåller alla nycklar i STACK[-1], pushar du en tuple som innehåller motsvarande värden. I annat fall skickas None.

Tillagd i version 3.10.

Ändrad i version 3.11: Tidigare skickade denna instruktion också ett booleskt värde som indikerade framgång (True) eller misslyckande (False).

STORE_NAME(namei)¶: Implementerar name = STACK.pop(). namei är indexet för name i attributet co_names i code object. Kompilatorn försöker använda STORE_FAST eller STORE_GLOBAL om möjligt.

DELETE_NAME(namei)¶: Implementerar del name, där namei är indexet i attributet co_names i code object.

UNPACK_SEQUENCE(count)¶

Packar upp STACK[-1] till antal enskilda värden, som läggs på stacken från höger till vänster. Kräver att det finns exakt antal värden:

assert(len(STACK[-1]) == count)
STACK.extend(STACK.pop()[:-count-1:-1])

UNPACK_EX(counts)¶

Implementerar assignment med ett stjärnmärkt mål: Packar upp en iterabel i STACK[-1] i enskilda värden, där det totala antalet värden kan vara mindre än antalet objekt i iterabeln: ett av de nya värdena kommer att vara en lista över alla kvarvarande objekt.

Antalet värden före och efter listvärdet är begränsat till 255.

Antalet värden före listvärdet kodas i opkodens argument. Antalet värden efter listan, om det finns några, kodas med hjälp av en EXTENDED_ARG. Som en följd av detta kan argumentet ses som ett värde på två byte där den låga byten i counts är antalet värden före listvärdet, den höga byten i counts är antalet värden efter det.

De extraherade värdena läggs på stacken från höger till vänster, dvs. a, *b, c = d kommer efter exekvering att lagras som STACK.extend((a, b, c)).

STORE_ATTR(namei)¶

Implementerar:

obj = STACK.pop()
value = STACK.pop()
obj.name = value

där namei är index för namn i co_names för code object.

DELETE_ATTR(namei)¶

Implementerar:

obj = STACK.pop()
del obj.name

där namei är index för namn i co_names för code object.

STORE_GLOBAL(namei)¶: Fungerar som STORE_NAME, men lagrar namnet som en global.

DELETE_GLOBAL(namei)¶: Fungerar som DELETE_NAME, men raderar ett globalt namn.

LOAD_CONST(consti)¶: Lägger co_consts[consti] på stacken.

LOAD_SMALL_INT(i)¶: Skjuter upp heltalet i på stacken. i måste ligga inom intervall(256)

Tillagd i version 3.14.

LOAD_NAME(namei)¶: Lägger det värde som associeras med co_names[namei] på stacken. Namnet söks upp i de lokala, sedan i de globala och sedan i de inbyggda.

LOAD_LOCALS¶: Lägger en referens till locals-ordlistan på stacken. Detta används för att förbereda namnrymdsordböcker för LOAD_FROM_DICT_OR_DEREF och LOAD_FROM_DICT_OR_GLOBALS.

Tillagd i version 3.12.

LOAD_FROM_DICT_OR_GLOBALS(i)¶: Plockar upp en mappning från stacken och letar upp värdet för co_names[namei]. Om namnet inte hittas där, letar det upp det i de globala variablerna och sedan i de inbyggda variablerna, liknande LOAD_GLOBAL. Detta används för att ladda globala variabler i annotation scopes inom klasskroppar.

Tillagd i version 3.12.

BUILD_TEMPLATE¶

Konstruerar en ny Template -instans från en tupel av strängar och en tupel av interpolationer och lägger det resulterande objektet i stacken:

interpolations = STACK.pop()
strings = STACK.pop()
STACK.append(_build_template(strings, interpolations))

Tillagd i version 3.14.

BUILD_INTERPOLATION(format)¶

Konstruerar en ny Interpolation -instans från ett värde och dess källuttryck och lägger det resulterande objektet i stacken.

Om ingen konvertering eller formatspecifikation finns, sätts format till 2.

Om den låga biten i format är inställd, indikerar det att interpoleringen innehåller en formatspecifikation.

Om format >> 2 är icke-noll, indikerar det att interpoleringen innehåller en konvertering. Värdet på format >> 2 är konverteringstypen (0 för ingen konvertering, 1 för !s, 2 för !r och 3 för !a):

conversion = format >> 2
if format & 1:
    format_spec = STACK.pop()
else:
    format_spec = None
expression = STACK.pop()
value = STACK.pop()
STACK.append(_build_interpolation(value, expression, conversion, format_spec))

Tillagd i version 3.14.

BUILD_TUPLE(count)¶

Skapar en tupel som använder antal objekt från stacken, och lägger den resulterande tupeln på stacken:

if count == 0:
    value = ()
else:
    value = tuple(STACK[-count:])
    STACK = STACK[:-count]

STACK.append(value)

BUILD_LIST(count)¶: Fungerar som BUILD_TUPLE, men skapar en lista.

BUILD_SET(count)¶: Fungerar som BUILD_TUPLE, men skapar en uppsättning.

BUILD_MAP(count)¶: Lägger ett nytt ordboksobjekt på stacken. Popar upp 2 * count objekt så att ordboken innehåller count poster: {..., STACK[-4]: STACK[-3], STACK[-2]: STACK[-1]}.

Ändrad i version 3.5: Ordboken skapas från stapelobjekt istället för att skapa en tom ordbok som är förstorad för att rymma antal objekt.

BUILD_STRING(count)¶: Sammanfogar antal strängar från stacken och lägger den resulterande strängen på stacken.

Tillagd i version 3.6.

LIST_EXTEND(i)¶

Implementerar:

seq = STACK.pop()
list.extend(STACK[-i], seq)

Används för att bygga listor.

Tillagd i version 3.9.

SET_UPDATE(i)¶

Implementerar:

seq = STACK.pop()
set.update(STACK[-i], seq)

Används för att bygga set.

Tillagd i version 3.9.

DICT_UPDATE(i)¶

Implementerar:

map = STACK.pop()
dict.update(STACK[-i], map)

Används för att bygga dikter.

Tillagd i version 3.9.

DICT_MERGE(i)¶: Som DICT_UPDATE men ger upphov till ett undantag för dubbla nycklar.

Tillagd i version 3.9.

LOAD_ATTR(namei)¶

Om den låga biten i namei inte är inställd, ersätts STACK[-1] med getattr(STACK[-1], co_names[namei>>1]).

Om den låga biten i namei är satt, kommer detta att försöka ladda en metod med namnet co_names[namei>>1] från STACK[-1]-objektet. STACK[-1] poppas. Denna bytecode skiljer på två fall: om STACK[-1] har en metod med rätt namn, pushar bytecoden den obundna metoden och STACK[-1]. STACK[-1] kommer att användas som det första argumentet (self) av CALL eller CALL_KW när den obundna metoden anropas. Annars skjuts NULL och det objekt som returneras av attributuppslagningen.

Ändrad i version 3.12: Om den låga biten i namei är satt, läggs en NULL eller self till stacken före attributet respektive den obundna metoden.

LOAD_SUPER_ATTR(namei)¶

Denna opcode implementerar super(), både i dess nollargument- och tvåargumentform (t.ex. super().method(), super().attr och super(cls, self).method(), super(cls, self).attr).

Den plockar ut tre värden från stacken (från toppen av stacken och nedåt):

self: det första argumentet till den aktuella metoden
cls: den klass inom vilken den aktuella metoden definierades
den globala super

När det gäller dess argument fungerar den på samma sätt som LOAD_ATTR, förutom att namei vänsterförskjuts med 2 bitar istället för 1.

Den låga biten i namei signalerar att man ska försöka ladda en metod, som med LOAD_ATTR, vilket resulterar i att NULL och den laddade metoden skjuts upp. När den inte är inställd flyttas ett enda värde till stacken.

Den näst lägsta biten i namei, om den är satt, betyder att detta var ett anrop med två argument till super() (om den inte är satt betyder det noll argument).

Tillagd i version 3.12.

COMPARE_OP(opname)¶: Utför en boolesk operation. Operationsnamnet kan hittas i cmp_op[opname >> 5]. Om den femte lägsta biten i opname är inställd (opname & 16), bör resultatet tvingas till bool.

Ändrad i version 3.13: Den femte lägsta biten i oparget indikerar nu en tvingad konvertering till bool.

IS_OP(invert)¶: Utför jämförelse med is, eller is not om invert är 1.

Tillagd i version 3.9.

CONTAINS_OP(invert)¶: Utför jämförelse in, eller not in om invert är 1.

Tillagd i version 3.9.

IMPORT_NAME(namei)¶: Importerar modulen co_names[namei]. STACK[-1] och STACK[-2] poppas och ger argumenten fromlist och level i __import__(). Modulobjektet skjuts upp på stacken. Den aktuella namnrymden påverkas inte: för en korrekt importsats modifieras namnrymden av en efterföljande STORE_FAST -instruktion.

IMPORT_FROM(namei)¶: Läser in attributet co_names[namei] från den modul som finns i STACK[-1]. Det resulterande objektet läggs på stacken, för att sedan lagras med en STORE_FAST -instruktion.

JUMP_FORWARD(delta)¶: Ökar bytekodsräknaren med delta.

JUMP_BACKWARD(delta)¶: Minskar bytekodsräknaren med delta. Kontrollerar för avbrott.

Tillagd i version 3.11.

JUMP_BACKWARD_NO_INTERRUPT(delta)¶: Minskar bytekodsräknaren med delta. Kontrollerar inte för avbrott.

Tillagd i version 3.11.

POP_JUMP_IF_TRUE(delta)¶: Om STACK[-1] är true, ökas bytecode-räknaren med delta. om STACK[-1] är poppad.

Ändrad i version 3.11: Oparget är nu ett relativt delta snarare än ett absolut mål. Denna opcode är en pseudo-instruktion som i den slutliga bytekoden ersätts av de riktade versionerna (framåt/bakåt).

Ändrad i version 3.12: Detta är inte längre en pseudo-instruktion.

Ändrad i version 3.13: Denna instruktion kräver nu ett exakt bool-operand.

POP_JUMP_IF_FALSE(delta)¶: Om STACK[-1] är false, ökas bytecode-räknaren med delta. STACK[-1] är poppad.

Ändrad i version 3.11: Oparget är nu ett relativt delta snarare än ett absolut mål. Denna opcode är en pseudo-instruktion som i den slutliga bytekoden ersätts av de riktade versionerna (framåt/bakåt).

Ändrad i version 3.12: Detta är inte längre en pseudo-instruktion.

Ändrad i version 3.13: Denna instruktion kräver nu ett exakt bool-operand.

POP_JUMP_IF_NOT_NONE(delta)¶: Om STACK[-1] inte är None, ökas bytekodräknaren med delta. STACK[-1] poppas.

Tillagd i version 3.11.

Ändrad i version 3.12: Detta är inte längre en pseudo-instruktion.

POP_JUMP_IF_NONE(delta)¶: Om STACK[-1] är None, ökas bytekodsräknaren med delta. STACK[-1] är poppat.

Tillagd i version 3.11.

Ändrad i version 3.12: Detta är inte längre en pseudo-instruktion.

FOR_ITER(delta)¶: STACK[-1] är en iterator. Anropa dess __next__()-metod. Om detta ger ett nytt värde, lägg det på stacken (och lämna iteratorn under det). Om iteratorn indikerar att den är uttömd ökas bytekodsräknaren med delta.

Ändrad i version 3.12: Fram till 3.11 poppades iteratorn när den var uttömd.

LOAD_GLOBAL(namei)¶: Läser in den globala filen med namnet co_names[namei>>1] på stacken.

Ändrad i version 3.11: Om den låga biten i namei är inställd, skjuts en NULL till stacken före den globala variabeln.

LOAD_FAST(var_num)¶: Lägger en referens till den lokala co_varnames[var_num] på stacken.

Ändrad i version 3.12: Denna opcode används nu endast i situationer där den lokala variabeln garanterat kommer att initialiseras. Den kan inte ge upphov till UnboundLocalError.

LOAD_FAST_BORROW(var_num)¶: Lägger en lånad referens till den lokala co_varnames[var_num] på stacken.

Tillagd i version 3.14.

LOAD_FAST_LOAD_FAST(var_nums)¶: Flyttar referenser till co_varnames[var_nums >> 4] och co_varnames[var_nums & 15] till stacken.

Tillagd i version 3.13.

LOAD_FAST_BORROW_LOAD_FAST_BORROW(var_nums)¶: Lägger upp lånade referenser till co_varnames[var_nums >> 4] och co_varnames[var_nums & 15] på stacken.

Tillagd i version 3.14.

LOAD_FAST_CHECK(var_num)¶: Lägger en referens till den lokala co_varnames[var_num] på stacken, vilket ger upphov till UnboundLocalError om den lokala variabeln inte har initialiserats.

Tillagd i version 3.12.

LOAD_FAST_AND_CLEAR(var_num)¶: Lägger en referens till den lokala co_varnames[var_num] på stacken (eller lägger NULL på stacken om den lokala variabeln inte har initialiserats) och sätter co_varnames[var_num] till NULL.

Tillagd i version 3.12.

STORE_FAST(var_num)¶: Lagrar STACK.pop() i den lokala co_varnames[var_num].

STORE_FAST_STORE_FAST(var_nums)¶: Lagrar STACK[-1] i co_varnames[var_nums >> 4] och STACK[-2] i co_varnames[var_nums & 15].

Tillagd i version 3.13.

STORE_FAST_LOAD_FAST(var_nums)¶: Lagrar STACK.pop() i den lokala co_varnames[var_nums >> 4] och lägger en referens till den lokala co_varnames[var_nums & 15] på stacken.

Tillagd i version 3.13.

DELETE_FAST(var_num)¶: Raderar lokala co_varnames[var_num].

MAKE_CELL(i)¶: Skapar en ny cell i slot i. Om den platsen inte är tom lagras värdet i den nya cellen.

Tillagd i version 3.11.

LOAD_DEREF(i)¶: Laddar cellen som finns på plats i i ”fast locals”-lagret. Lägger en referens till det objekt som cellen innehåller på stacken.

Ändrad i version 3.11: i kompenseras inte längre av längden på co_varnames.

LOAD_FROM_DICT_OR_DEREF(i)¶: Tar en mappning från stacken och letar upp det namn som är associerat med plats i i ”fast locals”-lagret i denna mappning. Om namnet inte hittas där, laddas det från cellen som finns i slot i, liknande LOAD_DEREF. Detta används för att läsa in closure variables i class bodies (som tidigare använde LOAD_CLASSDEREF) och i annotation scopes inom class bodies.

Tillagd i version 3.12.

STORE_DEREF(i)¶: Lagrar STACK.pop() i cellen som finns på plats i i ”fast locals”-lagret.

Ändrad i version 3.11: i kompenseras inte längre av längden på co_varnames.

DELETE_DEREF(i)¶: Tömmer cellen som finns i plats i i lagret för ”snabba lokala”. Används av del-satsen.

Tillagd i version 3.2.

Ändrad i version 3.11: i kompenseras inte längre av längden på co_varnames.

COPY_FREE_VARS(n)¶: Kopierar n free (closure) variables från closure till frame. Tar bort behovet av specialkod på anroparens sida vid anrop av closures.

Tillagd i version 3.11.

RAISE_VARARGS(argc)¶

Utlöser ett undantag med hjälp av en av de tre formerna av raise-satsen, beroende på värdet på argc:

0: raise (åter höja tidigare undantag)
1: raise STACK[-1] (skapa undantag för instans eller typ vid STACK[-1])
2: raise STACK[-2] from STACK[-1] (raise exception instance or type at STACK[-2] with __cause__ set to STACK[-1])

CALL(argc)¶

Anropar ett anropsbart objekt med det antal argument som anges av argc. På stacken finns (i stigande ordning):

Den infordringsbara
self eller NULL
De återstående positionella argumenten

argc är summan av de positionella argumenten, exklusive self.

CALL plockar alla argument och det anropbara objektet från stacken, anropar det anropbara objektet med dessa argument och flyttar returvärdet som returneras av det anropbara objektet.

Tillagd i version 3.11.

Ändrad i version 3.13: Det anropbara objektet visas nu alltid på samma plats i stacken.

Ändrad i version 3.13: Anrop med nyckelordsargument hanteras nu av CALL_KW.

CALL_KW(argc)¶

Anropar ett anropsbart objekt med det antal argument som anges av argc, inklusive ett eller flera namngivna argument. På stacken finns (i stigande ordning):

Den infordringsbara
self eller NULL
De återstående positionella argumenten
De namngivna argumenten
En tupel av nyckelordsargumentnamn

argc är summan av de positionella och namngivna argumenten, exklusive self. Längden på tupeln med nyckelordsargumentnamn är antalet namngivna argument.

CALL_KW plockar alla argument, nyckelordsnamnen och det anropbara objektet från stacken, anropar det anropbara objektet med dessa argument och flyttar returvärdet som returneras av det anropbara objektet.

Tillagd i version 3.13.

CALL_FUNCTION_EX(flags)¶: Anropar ett anropsbart objekt med en variabel uppsättning positions- och nyckelordsargument. Om den lägsta biten i flags är inställd, innehåller toppen av stacken ett mappningsobjekt som innehåller ytterligare nyckelordsargument. Innan den anropbara funktionen anropas ”packas” mappningsobjektet och iterable-objektet upp och deras innehåll skickas in som nyckelords- respektive positionsargument. CALL_FUNCTION_EX plockar alla argument och det anropbara objektet från stacken, anropar det anropbara objektet med dessa argument och flyttar returvärdet som returneras av det anropbara objektet.

Tillagd i version 3.6.

PUSH_NULL¶: Skickar en NULL till stacken. Används i anropssekvensen för att matcha den NULL som pushas av LOAD_METHOD för icke-metodanrop.

Tillagd i version 3.11.

MAKE_FUNCTION¶: Lägger ett nytt funktionsobjekt på stacken som byggts upp från kodobjektet på STACK[-1].

Ändrad i version 3.10: Flaggvärdet 0x04 är en tupel av strängar istället för en ordbok

Ändrad i version 3.11: Kvalificerat namn vid STACK[-1] togs bort.

Ändrad i version 3.13: Extra funktionsattribut på stacken, som signaleras av oparg-flaggor, har tagits bort. De använder nu SET_FUNCTION_ATTRIBUTE.

SET_FUNCTION_ATTRIBUTE(flag)¶

Ställer in ett attribut på ett funktionsobjekt. Förväntar sig funktionen på STACK[-1] och attributvärdet som ska sättas på STACK[-2]; konsumerar båda och lämnar funktionen på STACK[-1]. Flaggan avgör vilket attribut som ska ställas in:

0x01 en tupel av standardvärden för parametrar som endast är positionella och positionella eller nyckelord i positionell ordning
0x02 en ordbok med standardvärden för parametrar som endast innehåller nyckelord
0x04 en tupel av strängar som innehåller parametrarnas anteckningar
0x08 en tupel som innehåller celler för fria variabler, vilket ger en stängning

Tillagd i version 3.13.

BUILD_SLICE(argc)¶

Skjuter upp ett slice-objekt på stacken. argc måste vara 2 eller 3. Om det är 2, implementeras:

slut = STACK.pop()
start = STACK.pop()
STACK.append(slice(start, slut))

om det är 3, implementerar:

steg = STACK.pop()
slut = STACK.pop()
start = STACK.pop()
STACK.append(slice(start, slut, steg))

Se den inbyggda funktionen slice() för mer information.

EXTENDED_ARG(ext)¶: Prefix för alla op-koder som har ett argument som är för stort för att rymmas i den standardiserade en byte. ext innehåller ytterligare en byte som fungerar som högre bitar i argumentet. För varje opcode tillåts högst tre prefixala EXTENDED_ARG, som bildar ett argument från två byte till fyra byte.

CONVERT_VALUE(oparg)¶

Konverterar värdet till en sträng, beroende på oparg:

värde = STACK.pop()
resultat = func(värde)
STACK.append(resultat)

oparg == 1: anropa str() på värde
oparg == 2: anropa repr() på värde
oparg == 3: anropa ascii() på värde

Används för att implementera formaterade stränglitteraler (f-strings).

Tillagd i version 3.13.

FORMAT_SIMPLE¶

Formaterar värdet på toppen av stapeln:

värde = STACK.pop()
resultat = värde.__format__("")
STACK.append(resultat)

Används för att implementera formaterade stränglitteraler (f-strings).

Tillagd i version 3.13.

FORMAT_WITH_SPEC¶

Formaterar det angivna värdet med det angivna formatet spec:

spec = STACK.pop()
värde = STACK.pop()
resultat = värde.__format__(spec)
STACK.append(resultat)

Används för att implementera formaterade stränglitteraler (f-strings).

Tillagd i version 3.13.

MATCH_CLASS(count)¶

STACK[-1] är en tupel av nyckelordsattributnamn, STACK[-2] är den klass som matchningen görs mot och STACK[-3] är matchningsobjektet. count är antalet positionella undermönster.

Popa STACK[-1], STACK[-2] och STACK[-3]. Om STACK[-3] är en instans av STACK[-2] och har de positions- och nyckelordsattribut som krävs av count och STACK[-1], pushar du en tupel av extraherade attribut. I annat fall, skicka None.

Tillagd i version 3.10.

Ändrad i version 3.11: Tidigare skickade denna instruktion också ett booleskt värde som indikerade framgång (True) eller misslyckande (False).

RESUME(context)¶

Ingen funktion. Utför interna spårnings-, felsöknings- och optimeringskontroller.

Operanden context består av två delar. De två lägsta bitarna anger var RESUME sker:

0 Början på en funktion, som varken är en generator, coroutine eller en async-generator
1 Efter ett yield-uttryck
2 Efter ett yield from-uttryck
3 Efter ett await-uttryck

Nästa bit är 1 om RESUME är på except-depth 1, och 0 annars.

Tillagd i version 3.11.

Ändrad i version 3.13: Oparg-värdet ändrades för att inkludera information om except-depth

RETURN_GENERATOR¶: Skapa en generator, coroutine eller async-generator från den aktuella bildrutan. Används som första opcode i in code-objektet för ovan nämnda callables. Rensa den aktuella ramen och returnera den nyskapade generatorn.

Tillagd i version 3.11.

SEND(delta)¶

Motsvarar STACK[-1] = STACK[-2].send(STACK[-1]). Används i yield from och await-satser.

Om anropet ger upphov till StopIteration, plockas det översta värdet från stacken, undantagets value-attribut skjuts upp och bytekodsräknaren ökas med delta.

Tillagd i version 3.11.

HAVE_ARGUMENT¶

Detta är egentligen inte en opcode. Den identifierar skiljelinjen mellan opkoder i intervallet [0,255] som inte använder sitt argument och de som gör det (< HAVE_ARGUMENT respektive >= HAVE_ARGUMENT).

Om ditt program använder pseudoinstruktioner eller specialinstruktioner, använd hasarg-samlingen istället.

Ändrad i version 3.6: Nu har varje instruktion ett argument, men opkoderna < HAVE_ARGUMENT ignorerar det. Tidigare hade endast opkoderna >= HAVE_ARGUMENT ett argument.

Ändrad i version 3.12: Pseudoinstruktioner lades till i modulen dis, och för dem är det inte sant att jämförelse med HAVE_ARGUMENT visar om de använder sitt arg.

Föråldrad sedan version 3.13: Använd hasarg istället.

CALL_INTRINSIC_1¶

Anropar en egen funktion med ett argument. Anropar STACK[-1] som argument och sätter STACK[-1] till resultatet. Används för att implementera funktionalitet som inte är prestandakritisk.

Operanden avgör vilken egen funktion som anropas:

Operand	Beskrivning
`INTRINSIC_1_INVALID`	Ej giltig
`INTRINSIC_PRINT`	Skriver ut argumentet till standardutskrift. Används i REPL.
`INTRINSIC_IMPORT_STAR`	Utför `import *` för den namngivna modulen.
`INTRINSIC_STOPITERATION_ERROR`	Extraherar returvärdet från ett `StopIteration`-undantag.
`INTRINSIC_ASYNC_GEN_WRAP`	Omsluter ett asynkront generatorvärde
`INTRINSIC_UNARY_POSITIVE`	Utför den unära `+`-operationen
`INTRINSIC_LIST_TO_TUPLE`	Konverterar en lista till en tupel
`INTRINSIC_TYPEVAR`	Skapar en `typing.TypeVar`
`INTRINSIC_PARAMSPEC`	Skapar en `typing.ParamSpec`
`INTRINSIC_TYPEVARTUPLE`	Skapar en `typing.TypeVarTuple`
`INTRINSIC_SUBSCRIPT_GENERIC`	Returnerar `typing.Generic` subskriberad med argumentet
`INTRINSIC_TYPEALIAS`	Skapar en `typing.TypeAliasType`; som används i `type`-satsen. Argumentet är en tupel av typaliasets namn, typparametrar och värde.

Tillagd i version 3.12.

CALL_INTRINSIC_2¶

Anropar en inneboende funktion med två argument. Används för att implementera funktionalitet som inte är prestandakritisk:

arg2 = STACK.pop()
arg1 = STACK.pop()
resultat = intrinsic2(arg1, arg2)
STACK.append(resultat)

Operanden avgör vilken egen funktion som anropas:

Operand	Beskrivning
`INTRINSIC_2_INVALID`	Ej giltig
`INTRINSIC_PREP_RERAISE_STAR`	Beräknar den `ExceptionGroup` som ska tas fram från ett `try-except*`.
`INTRINSIC_TYPEVAR_WITH_BOUND`	Skapar en `typing.TypeVar` med en bound.
`INTRINSIC_TYPEVAR_WITH_CONSTRAINTS`	Skapar en `typing.TypeVar` med begränsningar.
`INTRINSIC_SET_FUNCTION_TYPE_PARAMS`	Ställer in attributet `__type_params__` för en funktion.

Tillagd i version 3.12.

LOAD_SPECIAL¶: Utför en speciell metoduppslagning på STACK[-1]. Om type(STACK[-1]).__xxx__ är en metod, lämna type(STACK[-1]).__xxx__; STACK[-1] på stacken. Om type(STACK[-1]).__xxx__ inte är en metod, lämna STACK[-1].__xxx__; NULL på stacken.

Tillagd i version 3.14.

Pseudo-instruktioner

Dessa opkoder visas inte i Python bytecode. De används av kompilatorn men ersätts av riktiga opkoder eller tas bort innan bytekoden genereras.

SETUP_FINALLY(target)¶: Skapa en undantagshanterare för följande kodblock. Om ett undantag inträffar återställs värde-stacknivån till sitt aktuella tillstånd och kontrollen överförs till undantagshanteraren i target.

SETUP_CLEANUP(target)¶: Som SETUP_FINALLY, men i händelse av ett undantag flyttas även den sista instruktionen (lasti) till stacken så att RERAISE kan återställa den. Om ett undantag inträffar återställs värdet på stacknivån och den sista instruktionen på ramen till sitt nuvarande tillstånd och kontrollen överförs till undantagshanteraren på target.

SETUP_WITH(target)¶

Som SETUP_CLEANUP, men i händelse av ett undantag poppas ytterligare ett objekt från stacken innan kontrollen överförs till undantagshanteraren i target.

Den här varianten används i konstruktionerna with och async with, som flyttar returvärdet för kontexthanterarens __enter__() eller __aenter__() till stacken.

POP_BLOCK¶: Markerar slutet på det kodblock som är associerat med den senaste SETUP_FINALLY, SETUP_CLEANUP eller SETUP_WITH.

JUMP¶

JUMP_NO_INTERRUPT¶: Oriktade relativa hoppinstruktioner som ersätts av sina riktade (framåt/bakåt) motsvarigheter av assemblerprogrammet.

JUMP_IF_TRUE¶

JUMP_IF_FALSE¶: Villkorliga hopp som inte påverkar stacken. Ersätts av sekvensen COPY 1, TO_BOOL, POP_JUMP_IF_TRUE/FALSE.

LOAD_CLOSURE(i)¶

Skickar en referens till den cell som finns på plats i i lagret ”Fast Locals”.

Observera att LOAD_CLOSURE ersätts med LOAD_FAST i assemblern.

Ändrad i version 3.13: Denna opkod är nu en pseudo-instruktion.

LOAD_METHOD¶: Optimerad uppslagning av obunden metod. Utfärdas som en LOAD_ATTR opcode med en flagga inställd i arg.

Opcode-samlingar¶

Dessa samlingar tillhandahålls för automatisk introspektion av bytecode-instruktioner:

Ändrad i version 3.12: Samlingarna innehåller nu även pseudoinstruktioner och instrumenterade instruktioner. Dessa är opkoder med värdena >= MIN_PSEUDO_OPCODE och >= MIN_INSTRUMENTED_OPCODE.

dis.opname¶: Sekvens av operationsnamn, indexerbara med hjälp av bytekoden.

dis.opmap¶: Ordbok som mappar operationsnamn till bytecodes.

dis.cmp_op¶: Sekvens av alla namn på jämförelseoperationer.

dis.hasarg¶: Sekvens av bytecodes som använder argumentet.

Tillagd i version 3.12.

dis.hasconst¶: Sekvens av bytekoder som har tillgång till en konstant.

dis.hasfree¶: Sekvens av bytekoder som har tillgång till en free (closure) variabel. ”free” i detta sammanhang avser namn i det aktuella omfånget som refereras av inre omfång eller namn i yttre omfång som refereras från detta omfång. Det inkluderar inte referenser till globala eller inbyggda scope.

dis.hasname¶: Sekvens av bytecodes som öppnar ett attribut med namn.

dis.hasjump¶: Sekvens av bytecodes som har ett hoppmål. Alla hopp är relativa.

Tillagd i version 3.13.

dis.haslocal¶: Sekvens av bytekoder som har åtkomst till en lokal variabel.

dis.hascompare¶: Sekvens av bytecodes för booleska operationer.

dis.hasexc¶: Sekvens av bytecodes som anger en undantagshanterare.

Tillagd i version 3.12.

dis.hasjrel¶: Sekvens av bytecodes som har ett relativt hoppmål.

Föråldrad sedan version 3.13: Alla hopp är nu relativa. Använd hasjump.

dis.hasjabs¶: Sekvens av bytecodes som har ett absolut hoppmål.

Föråldrad sedan version 3.13: Alla hopp är nu relativa. Denna lista är tom.

`dis` — Disassemblerare för Python bytecode¶

Kommandoradsgränssnitt¶

Bytecode-analys¶

Analysfunktioner¶

Instruktioner för Python Bytecode¶

Opcode-samlingar¶

Innehåll

Föregående ämne

Nästa ämne

Denna sidan

dis — Disassemblerare för Python bytecode¶

Kommandoradsgränssnitt¶

Bytecode-analys¶

Analysfunktioner¶

Instruktioner för Python Bytecode¶

Opcode-samlingar¶

`dis` — Disassemblerare för Python bytecode¶