Code Introspection in Python

Code introspection is a crucial technique that empowers programmers to scrutinize code, comprehend its structure and behavior, and debug it effectively. It proves particularly useful in large−scale software development. Python, a popular programming language, provides an extensive range of tools for code introspection that simplify the process of understanding and enhancing code quality.

In Python, code introspection allows programmers to examine the code while it is running. It provides the ability to scrutinize code attributes and functionalities during runtime. This technique proves to be invaluable when debugging code, as it enables programmers to understand precisely what the code is doing at a specific moment. Python comes equipped with several built−in functions and modules for code introspection, which simplifies the process of code examination and obtaining relevant information about its structure.

dir() function

Code introspection is essential for Python programmers as it allows them to examine an object's attributes and methods at runtime, aiding in debugging and comprehension. The widely used dir() function retrieves a list of all attributes and methods for any object, including modules, functions, and classes. Using dir() with a defined class like MyClass provides a complete list of its attributes and methods, as shown below:


class MyClass:
    def __init__(self):
        self.my_attribute = 42
    def my_method(self):
        return "Hello, world!"
obj = MyClass()

# Get a list of all the attributes and methods of the object


['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'my_attribute', 'my_method']

The generated output presents a comprehensive list of attributes and methods belonging to the obj object. The __init__ method, being a constructor, initializes the my_attribute attribute, while the my_method method returns the string "Hello, world!". The remaining attributes and methods correspond to built−in attributes and methods of the object class.

type() function

The type() function in Python is a built−in function that returns the type of the specified object. The syntax for using the type() function is as follows:


Here, the object parameter can be any Python object, such as a variable, function, or class.

Upon calling the type() function, it returns a string representing the type of the object provided as its argument. The type() function commonly returns the following types among others:

  • int − for integers

  • float − for floating−point numbers

  • str − for strings

  • bool − for Boolean values

  • list − for lists

  • tuple − for tuples

  • dict − for dictionaries

  • set − for sets

  • function − for functions

  • class − for classes

  • module − for modules


Here's an example that demonstrates how to use the type() function:

x = 5
y = "Hello, world!"
z = [1, 2, 3]
print(type(x))  # Output: <class 'int'>
print(type(y))  # Output: <class 'str'>
print(type(z))  # Output: <class 'list'>

We initialize three variables named x, y, and z, and assign them an integer, a string, and a list, respectively.


The output of this program will be:

<class 'int'>
<class 'str'>
<class 'list'>

The type() function returns the type of each variable as a string, which is surrounded by single quotes and has the class keyword at the beginning.

Inspect module

Python's built−in inspect module offers a range of functions for analyzing and introspecting live objects in a running Python program. It enables retrieving information about various objects such as modules, classes, and functions, as well as inspecting the source code of a module or function. With these capabilities, inspect is frequently utilized for analyzing, testing, and debugging Python code. For instance, suppose we have a module named that defines a function named my_function. In such a scenario, we can utilize the inspect module to retrieve information about my_function, as depicted below:


import inspect
from my_module import my_function

# Get the source code of the function
source_code = inspect.getsource(my_function)

# Get the function's arguments and their default values
argspec = inspect.getfullargspec(my_function)

# Get the function's return type
return_type = inspect.getreturnannotations(my_function)


def my_function(x, y=0):
    z = x + y
return z
FullArgSpec(args=['x', 'y'], varargs=None, varkw=None, defaults=(0,), kwonlyargs=[], kwonlydefaults=None, annotations={})
{'return': <class 'int'>}

The output shows the function's argument information returned by inspect.getfullargspec(). It indicates that my_function takes two arguments x and y, with y having a default value of 0. The second output is a dictionary showing the function's return type, which is an integer.

pdb module

Python's pdb module is a built−in debugging tool that offers a command−line interface for developers to step through their code, set breakpoints, and inspect variable values during execution. With pdb, programmers can easily track down bugs and issues in their code by pausing the execution at specified points and examining the state of their variables. It provides a powerful debugging environment that can help to identify and fix issues more efficiently.

Here is an example of how to use the pdb module to debug a simple Python program:

import pdb

def multiply(a, b):
    result = a * b
    pdb.set_trace() # Set a breakpoint
    return result

result = multiply(2, 3)

In this example, we define a function called multiply that takes two arguments a and b and returns their product. We insert a breakpoint using the pdb.set_trace() function call, which stops the execution of the program at that point and drops us into the debugger prompt.

When we run the program, it will output the result of the multiply function, but will then pause execution and enter the debugger:

> c:\path\to\
-> return result
(Pdb) _


In summary, Python provides built−in functions, third−party libraries, and language features that enable code introspection. These include dir(), inspect, type(), help(), pdb, ipdb, and decorators. Programmers can use these tools to gain a better understanding of their code, making it easier to debug and leading to more efficient and error−free code. Code introspection is a vital skill for Python programmers and helps them write more maintainable and high−quality code.

Updated on: 19-Jul-2023


Kickstart Your Career

Get certified by completing the course

Get Started