How to print instances of a class using print()?

Mastering Python's print(): Customizing Class Instance Output

Learn how to effectively control the string representation of your custom Python objects when using the built-in print() function, enhancing debugging and user experience.

When working with custom classes in Python, you've likely encountered a less-than-informative output when trying to print() an instance of your class directly. By default, Python provides a generic memory address representation, which isn't very helpful for debugging or understanding the object's state. This article will guide you through the magic methods __str__ and __repr__ that allow you to define how your objects are represented as strings, making your code more readable and your debugging sessions more productive.

The Default print() Behavior

Let's start by observing the default behavior. When you create a simple class and instantiate it, then try to print that instance, Python uses the default implementation inherited from the object class. This typically results in a string that includes the class name and the object's memory address, which is rarely what you want to see.

class MyClass:
    def __init__(self, name, value):
        self.name = name
        self.value = value

my_instance = MyClass("Example", 123)
print(my_instance)

Default output of a class instance when using print().

Introducing __str__ for User-Friendly Output

The __str__ magic method is designed to return a "nice" or "readable" string representation of an object, primarily for end-users. It's what print() and str() use by default. When you implement __str__, you're defining what a human user should see when they try to convert your object to a string.

class Product:
    def __init__(self, name, price, quantity):
        self.name = name
        self.price = price
        self.quantity = quantity

    def __str__(self):
        return f"Product: {self.name}, Price: ${self.price:.2f}, In Stock: {self.quantity}"

apple = Product("Apple", 0.99, 150)
print(apple)
print(str(apple))

Implementing __str__ for a user-friendly string representation.

Introducing __repr__ for Developer-Friendly Output

While __str__ is for end-users, __repr__ (short for "representation") is for developers. Its goal is to return an "unambiguous" string representation of an object, ideally one that could be used to recreate the object. It's what repr() uses and what's displayed in interactive shells when an object is evaluated (but not printed). If __str__ is not defined, __repr__ will be used as a fallback for print() and str().

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

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

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

pixel = Coordinate(10, 20)
print(pixel)       # Uses __str__
print(repr(pixel)) # Uses __repr__

# In an interactive shell:
# >>> pixel
# Coordinate(x=10, y=20)

Distinguishing between __str__ and __repr__.

Python's String Representation Lookup Flow

Practical Steps: Implementing __str__ and __repr__

Follow these steps to customize the string representation of your classes for better readability and debugging.

1. Step 1

Identify your class's key attributes: Determine which attributes are most important for identifying or describing an instance of your class.

2. Step 2

Implement __repr__ first (for developers): Create a __repr__ method that returns a string that could ideally be used to reconstruct the object. For example, ClassName(arg1=value1, arg2=value2).

3. Step 3

Implement __str__ (for users) if different: If you need a more human-readable, less formal string for print() output, implement __str__. This can be a simpler, descriptive sentence.

4. Step 4

Test your implementations: Instantiate your class and use both print() and repr() to verify that the outputs are as expected.