Python Reflection Tutorial

📘 Premium Read: Access my best content on Medium member-only articles — deep dives into Java, Spring Boot, Microservices, backend architecture, interview preparation, career advice, and industry-standard best practices.

🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

▶️ Subscribe to My YouTube Channel (176K+ subscribers): Java Guides on YouTube

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube

Introduction

Reflection in Python refers to the ability of a program to inspect, modify, and manipulate its own structure and behavior at runtime. It allows you to dynamically examine and modify objects, classes, functions, and modules. Reflection is used for tasks like debugging, testing, and implementing dynamic behavior in your programs.

Table of Contents

1. What is Reflection?
2. Inspecting Objects
3. Getting and Setting Attributes
4. Working with Functions and Methods
5. Inspecting Classes
6. Using the inspect Module
7. Practical Examples
8. Conclusion

1. What is Reflection?

Reflection is the ability of a program to examine and modify its own structure and behavior at runtime. It enables dynamic access to information about classes, objects, methods, and modules, allowing for more flexible and adaptable code.

2. Inspecting Objects

You can inspect objects in Python using built-in functions like type(), id(), dir(), and getattr().

Example

class MyClass: def __init__(self, value): self.value = value obj = MyClass(10) # Inspecting the type of an object print(type(obj)) # Output: <class '__main__.MyClass'> # Inspecting the ID of an object print(id(obj)) # Output: An integer representing the object's memory address # Listing attributes and methods of an object print(dir(obj)) # Output: A list of attributes and methods 

3. Getting and Setting Attributes

You can dynamically get and set attributes of objects using getattr(), setattr(), hasattr(), and delattr().

Example

class MyClass: def __init__(self, value): self.value = value obj = MyClass(10) # Getting an attribute print(getattr(obj, 'value')) # Output: 10 # Setting an attribute setattr(obj, 'value', 20) print(obj.value) # Output: 20 # Checking if an attribute exists print(hasattr(obj, 'value')) # Output: True # Deleting an attribute delattr(obj, 'value') print(hasattr(obj, 'value')) # Output: False 

4. Working with Functions and Methods

You can inspect and call functions and methods dynamically using reflection.

Example

class MyClass: def __init__(self, value): self.value = value def display(self): print(f'Value: {self.value}') obj = MyClass(10) # Getting a method method = getattr(obj, 'display') # Calling the method method() # Output: Value: 10 

5. Inspecting Classes

You can inspect classes to get information about their attributes, methods, base classes, and more.

Example

class MyClass: def __init__(self, value): self.value = value def display(self): print(f'Value: {self.value}') # Inspecting class attributes and methods print(MyClass.__dict__) 

6. Using the inspect Module

The inspect module provides several useful functions for obtaining information about live objects, including modules, classes, methods, functions, tracebacks, and frame objects.

Example

import inspect class MyClass: def __init__(self, value): self.value = value def display(self): print(f'Value: {self.value}') obj = MyClass(10) # Getting the class of an object print(inspect.getmembers(obj, inspect.isclass)) # Getting the methods of an object print(inspect.getmembers(obj, inspect.ismethod)) # Getting the source code of a function print(inspect.getsource(MyClass.display)) 

7. Practical Examples

Example 1: Dynamic Function Invocation

def greet(name): return f'Hello, {name}!' def farewell(name): return f'Goodbye, {name}!' # Function mapping functions = { 'greet': greet, 'farewell': farewell } # Dynamically calling functions name = 'Alice' print(functions['greet'](name)) # Output: Hello, Alice! print(functions['farewell'](name)) # Output: Goodbye, Alice! 

Example 2: Dynamic Class Instantiation

class Dog: def speak(self): return "Woof!" class Cat: def speak(self): return "Meow!" # Class mapping classes = { 'dog': Dog, 'cat': Cat } # Dynamically creating instances animal_type = 'dog' animal = classes[animal_type]() print(animal.speak()) # Output: Woof! 

8. Conclusion

Reflection in Python provides powerful tools for inspecting and manipulating objects, classes, functions, and modules at runtime. By understanding and utilizing reflection, you can write more flexible, adaptable, and dynamic code. This tutorial covered the basics of reflection, including inspecting objects, getting and setting attributes, working with functions and methods, inspecting classes, using the inspect module, and practical examples.