Controlling String Representations of Objects in Python

When you print an instance of a class in Python, the output isn’t always what you might expect. By default, Python provides a representation that shows the class name and memory address of the object. While this is useful for debugging, it’s often desirable to customize how objects are represented as strings, especially for user-facing output. This tutorial will guide you through how to control the string representation of your objects.

The Default Representation

If you haven’t explicitly defined how an object should be represented as a string, Python falls back to using the object’s __repr__ method. If __repr__ isn’t defined, you’ll see an output similar to <__main__.MyClass object at 0x...>, indicating the object’s type and memory location.

`repr` vs. `str`

Python provides two methods for controlling string representations: __repr__ and __str__. Understanding the difference between them is crucial:

__repr__(self): This method should return a string that unambiguously represents the object. Ideally, it should be possible to recreate the object from this string using eval(). It’s primarily intended for developers and debugging. If __str__ isn’t defined, __repr__ is also used when you call print() on an object or use the str() function.
__str__(self): This method should return a human-readable string representation of the object. It’s intended for end-users and should be more user-friendly than the output of __repr__. print() and str() functions will call this method if it’s defined.

Implementing `repr`

Let’s start by implementing __repr__. Here’s an example:

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

    def __repr__(self):
        return f"Point(x={self.x}, y={self.y})"

# Example usage
p = Point(2, 3)
print(p)        # Output: Point(x=2, y=3)
print(repr(p))  # Output: Point(x=2, y=3)

In this example, the __repr__ method returns a string that looks like the code you would use to create a Point object with the same x and y values. This is a common and useful convention.

Implementing `str`

Now, let’s implement __str__ to provide a more user-friendly representation:

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

    def __repr__(self):
        return f"Point(x={self.x}, y={self.y})"

    def __str__(self):
        return f"Point at ({self.x}, {self.y})"

# Example usage
p = Point(2, 3)
print(p)        # Output: Point at (2, 3)
print(str(p))  # Output: Point at (2, 3)
print(repr(p))  # Output: Point(x=2, y=3)

Notice how print(p) now outputs a more descriptive string, while repr(p) still provides the unambiguous representation.

When to Use Which

If you need an unambiguous representation for debugging or recreating the object, implement __repr__.
If you want a human-readable string for displaying to users, implement __str__.
It’s generally good practice to always implement __repr__, even if you don’t need a custom representation. If you don’t, you’ll get the default, unhelpful output. You can then add __str__ if you need a more user-friendly display.

Accessing Object Attributes Directly (For Debugging)

While it’s best to define __repr__ or __str__ for controlled output, you can access an object’s attributes directly for quick debugging. Using print(object.__dict__) will print a dictionary containing the object’s attributes and their values. However, this isn’t a recommended approach for production code, as it relies on internal implementation details and might change. It’s far better to have explicit, well-defined string representations using __repr__ and __str__.

In summary, controlling string representations using __repr__ and __str__ allows you to provide meaningful and informative output for both developers and users, making your code easier to understand and debug.