Understanding the `__repr__` method in Python: How to make your objects readable and debuggable

[Rajeev Bagra]

Source: Created with AI tool

The chunk of code def __repr__(self): return f"Vector({self.x}, {self.y})" is defining a dunder method (__repr__) within the Vector class. Its purpose is to return a string representation of the Vector object. This method allows for a more informative and readable output when the object is printed or viewed in the Python interpreter.

Here’s a breakdown of what this method does:

What Does __repr__ Do?

• Purpose: The __repr__ method is intended to provide a “formal” string representation of the object that is suitable for debugging and development purposes. It should ideally return a string that could be used to recreate the object when evaluated by Python.

• Functionality in This Case:

• The method returns a formatted string that includes the class name Vector and the values of self.x and self.y (the attributes of the object).
• For example, if the vector object has x=6 and y=8, the method will return the string "Vector(6, 8)".

When Is __repr__ Called?

• The __repr__ method is called when you attempt to output an object to the console using print() or when you inspect the object directly in the Python interpreter.
• For instance, when you write print(v3), Python internally calls v3.__repr__() to get the string "Vector(6, 8)" and then prints it to the console.

Example of __repr__ in Action:

Let’s walk through the provided code:

class Vector:
def __init__(self, x, y):
self.x = x
self.y = y

# Dunder method for addition
def __add__(self, other):
return Vector(self.x + other.x, self.y + other.y)

# Dunder method for string representation
def __repr__(self):
return f"Vector({self.x}, {self.y})"

# Creating two Vector objects
v1 = Vector(2, 3)
v2 = Vector(4, 5)

# Using the `+` operator which calls the `__add__` method
v3 = v1 + v2 # This results in a new Vector(6, 8)
print(v3) # Output: Vector(6, 8)

• Object Creation: v1 = Vector(2, 3) creates a Vector object where x=2 and y=3, and v2 = Vector(4, 5) creates another Vector object where x=4 and y=5.
• Addition with __add__: When you write v3 = v1 + v2, Python calls the __add__ method, which adds the x and y attributes of v1 and v2 together, returning a new Vector(6, 8).
• Calling __repr__: When you print v3 using print(v3), Python calls v3.__repr__(), which returns the string "Vector(6, 8)". This string is then printed to the console.

Why Use __repr__?

• For Debugging: __repr__ provides a useful representation of the object that shows its internal state, making it easier to debug.
• Clarity: It helps to present the object in a human-readable way, which is more informative than the default Python object representation (e.g., <Vector object at 0x...>).

Comparison with __str__:

There’s another related dunder method called __str__, which provides a more user-friendly or informal string representation of the object. If you only define __repr__, Python will use it as the fallback for both the formal (repr()) and informal (str()) string representations of the object.

However, the main difference is:
– __repr__: For developers and debugging, should ideally be a valid Python expression that can recreate the object.
– __str__: For end-users, focused on producing a readable string.

In this case, since __repr__ is defined, it makes sure that when v3 is printed or inspected, it clearly shows "Vector(6, 8)".

[Author]

Posts