Exploring Python Code Objects: A Deep Dive

Rate this post

πŸ’‘ Problem Formulation: When working with Python, developers often need to interact with the code objects that represent blocks of executable code, or the “bytecode.” This article will discuss methods for examining and manipulating these code objects, with an aim to give programmers a better understanding of what happens under the hood of Python execution. Suppose you have a function f() and you want to examine its bytecode for optimization or introspection purposes; the following methods will show you how to achieve that.

Method 1: Using the compile() Function

The compile() function is a built-in Python method that compiles source code into a code object which can then be executed by the exec() function. It’s valuable for creating code objects dynamically or analyzing source code statically. The function takes the source code as a string, the filename (which can be arbitrary when not executing from a file), and the mode which should be ‘exec’ if it’s a block of code.

Here’s an example:

source_code = "a = 5\\nb = 10\\nprint(a + b)"
compiled_code = compile(source_code, 'sum.py', 'exec')



The given example takes a string representing Python code that adds two numbers and prints the result. It then compiles this source into a code object and executes it. Executing the compiled code outputs the sum of the two numbers, in this case, 15.

Method 2: Accessing the __code__ Attribute

Every Python function has an associated code object which is accessed via the __code__ attribute. This object contains compiled bytecode that can be inspected. This method is particularly useful for introspection, allowing developers to examine properties such as the function’s argument count, local variables, and constants.

Here’s an example:

def add(a, b):
    return a + b

code_obj = add.__code__
print(code_obj.co_name, code_obj.co_varnames)


('add', ('a', 'b'))

This snippet creates a simple function add() and retrieves its code object. It then prints the function name and variable names found in the code object, which provides introspection into the function’s structure without executing it.

Method 3: Using the dis Module for Disassembly

The dis module in Python is a disassembler for Python bytecode. It allows developers to disassemble code objects and understand the low-level instructions that Python executes. It’s useful for learning how Python works and optimizing code by analyzing the bytecode instructions.

Here’s an example:

import dis

def greet(name):
    return f'Hello, {name}!'



  2           0 LOAD_CONST               1 ('Hello, ')
              2 LOAD_FAST                0 (name)
              4 FORMAT_VALUE             0
              6 BUILD_STRING             2
              8 RETURN_VALUE

The example defines a function greet() and uses dis.dis() to disassemble it. The output shows the sequence of bytecode operations that are performed when the function is called. This helps in understanding what Python is doing under the hood.

Method 4: Modifying Code Objects with types.CodeType()

Python allows code objects to be replaced or modified using the types.CodeType() constructor. This advanced method is used when you need to alter the execution of code at runtime dynamically. Caution is advised since this can lead to very unpredictable results if not used carefully.

Here’s an example:

import types

def subtract(a, b):
    return a - b

# original bytecode
original_bytecode = subtract.__code__.co_code

# creating a new code object with swapped operands (a, b) -> (b, a)
new_bytecode = bytearray(original_bytecode)
new_bytecode[2] = 101  # LOAD_FAST instruction with 101 opcode (for 'b')

new_code_obj = types.CodeType(subtract.__code__.co_argcount,

subtract.__code__ = new_code_obj
print(subtract(10, 5))



In this example, we create a function subtract() and then modify its bytecode to swap the operands, so it effectively performs b - a instead of a - b. After replacing the code object, calling subtract(10, 5) results in -5 instead of the original 5.

Bonus One-Liner Method 5: Inspecting Code Objects with lambda

A one-liner for quickly inspecting a code object can be a lambda function that prints out attributes of a code object. This method is best suited for quick debugging or exploration sessions where you want to check the code object’s properties swiftly without much setup.

Here’s an example:

inspect_code = lambda f: (f.__code__.co_name, f.__code__.co_varnames)
print(inspect_code(lambda x: x + 1))


(<lambda>, ('x',))

This one-liner defines a lambda function that takes another function as an argument, accesses its code object, and returns the function’s name and variable names. The output displays these details for a simple anonymous function that increments its argument.


  • Method 1: Using compile(). Strengths: Allows dynamic execution of code and introspection. Weaknesses: Security risk if the source isn’t trusted.
  • Method 2: Accessing __code__. Strengths: Quick introspection of functions. Weaknesses: It’s read-only; you can look, but you can’t modify.
  • Method 3: dis Module. Strengths: Provides a detailed view of bytecode. Weaknesses: Requires understanding of bytecode for useful insights.
  • Method 4: Modifying Code Objects. Strengths: Allows dynamic alteration at runtime, can optimize code. Weaknesses: Complex and can make code behave unpredictably if not used carefully.
  • Bonus Method 5: Lambda for Inspection. Strengths: Quick and concise. Weaknesses: Limited information, mainly suitable for simple introspection.