:mod:`dis` --- Disassembler for Python byte code
The :mod:`dis` module supports the analysis of Python byte code by disassembling it. Since there is no Python assembler, this module defines the Python assembly language. The Python byte code which this module takes as an input is defined in the file :file:`Include/opcode.h` and used by the compiler and the interpreter.
Example: Given the function :func:`myfunc`:
def myfunc(alist): return len(alist)
the following command can be used to get the disassembly of :func:`myfunc`:
>>> dis.dis(myfunc) 2 0 LOAD_GLOBAL 0 (len) 3 LOAD_FAST 0 (alist) 6 CALL_FUNCTION 1 9 RETURN_VALUE
(The "2" is a line number).
The :mod:`dis` module defines the following functions and constants:
the line number, for the first instruction of each line
the current instruction, indicated as -->,
a labelled instruction, indicated with >>,
the address of the instruction,
the operation code name,
operation parameters, and
interpretation of the parameters in parentheses.
The parameter interpretation recognizes local and global variable names, constant values, branch targets, and compare operators.
Python Byte Code Instructions
The Python compiler currently generates the following byte code instructions.
Unary Operations take the top of the stack, apply the operation, and push the result back on the stack.
Binary operations remove the top of the stack (TOS) and the second top-most stack item (TOS1) from the stack. They perform the operation, and put the result back on the stack.
In-place operations are like binary operations, in that they remove TOS and TOS1, and push the result back on the stack, but the operation is done in-place when TOS1 supports it, and the resulting TOS may be (but does not have to be) the original TOS1.
The slice opcodes take up to three parameters.
Slice assignment needs even an additional parameter. As any statement, they put nothing on the stack.
All of the following opcodes expect arguments. An argument is two bytes, with the more significant byte last.