How to Convert Objects to Strings in Python

In Python, converting objects to their string representations is a fundamental operation, essential for debugging, logging, data serialization, and user-friendly output. This guide explores different methods for converting objects (including class instances) to strings, covering str(), the special methods __str__() and __repr__(), and converting to JSON.

Converting Objects to Strings with str()

The built-in str() function is the primary way to get a string representation of a Python object. It works on basic data types like integers, floats, and many others:

my_int = 42
result = str(my_int)
print(result)        # Output: '42'
print(type(result))  # Output: <class 'str'>

my_float = 3.14
print(str(my_float)) # Output: '3.14'

The str() function attempts to create a user-friendly, readable string representation.

Controlling String Representation with __str__()

When you define a custom class, you control how instances of that class are represented as strings by implementing the special method __str__(). This is what str(), print(), and f-strings use by default.

class Employee():
    def __init__(self, name, salary):
        self.name = name
        self.salary = salary

    def __str__(self):
        return f'Name: {self.name}'

tom = Employee('tomnolan', 100)
print(tom)  # Output: Name: tomnolan

• The __str__() method should return a string. It's intended to provide a clear, human-readable description of the object.

Returning a String from __str__()

It's crucial that __str__() always returns a string. If you need to include non-string attributes, convert them to strings:

class Employee():

    def __str__(self):
        return str(self.salary) # Explicitly convert to string

Using __str__() with f-strings and str.format()

__str__() is automatically used when your object is embedded in an f-string or used with str.format():

class Employee():
    def __init__(self, name, salary):
        self.name = name
        self.salary = salary

    def __str__(self):
        return f'Name: {self.name}, Salary: {self.salary}' # Returns string

tom = Employee('tomnolan', 100)
result = f'Employee details: {tom}' # Uses __str__
print(result) # Output: Employee details: Name: tomnolan, Salary: 100

Converting Class Instances to JSON

For serialization to JSON, you typically don't need to define __str__(). Instead, access the instance's __dict__ attribute (which holds its attributes) and use json.dumps():

import json

class Employee():
    def __init__(self, name, salary):
        self.name = name
        self.salary = salary

tom = Employee('tomnolan', 100)
json_str = json.dumps(tom.__dict__)
print(json_str)  # Output: {"name": "tomnolan", "salary": 100}

This creates a JSON string directly from the object's attributes.

Understanding __repr__()

The __repr__() method is similar to __str__(), but it's intended to provide an unambiguous string representation of an object, primarily for developers (debugging, logging, etc.). Ideally, repr(object) should return a string that, when passed to eval(), could recreate the object.

    class Employee():
        def __init__(self, name, salary):
            self.name = name
            self.salary = salary

        def __repr__(self):
            return self.name

• The __repr__() should return a string representation that is valid and reproducible.

__str__() vs. __repr__()

• __str__(): User-friendly, for display to end-users. Focuses on readability.
• __repr__(): Unambiguous, for developers. Focuses on being able to recreate the object.

If __str__() is not defined, Python will fall back to using __repr__() for str(), print(), etc. It's good practice to define at least __repr__() for your classes.

A good example to demonstrate the difference is using the built-in datetime class:

import datetime

print(datetime.datetime.now())  # Output: 2023-10-27 14:10:37.929814

print(repr(datetime.datetime.now()))