After this lesson, you will be able to:

• Customize an object's human-readable text with __str__.
• Understand the difference between __str__ and the developer-oriented __repr__.
• Declare simple data-carrying classes using @dataclass with typed fields.
• Rely on dataclass-generated initialization and value-based equality.

Python calls methods with names like __str__ and __repr__ dunder methods (short for double underscore). str(obj) and print(obj) use __str__ when present. repr(obj) is intended to help developers inspect an object; by default, Python may show a generic class-and-address representation.

For data-focused classes, @dataclass from dataclasses automatically creates common methods based on declared, type-annotated fields. This includes an initializer, a useful representation, and value-based equality (==). Type annotations describe fields; they do not automatically validate types at runtime.

You can still define your own __str__ on a dataclass to control display while keeping its generated initializer and equality. Prefer dataclasses for simple structured records; keep complex behavior inside ordinary classes when it adds clarity.

1. Provide a readable __str__

class Server:
    def __init__(self, name, region):
        self.name = name
        self.region = region

    def __str__(self):
        return f"{self.name}@{self.region}"

print(Server("worker", "eu"))

Output:

worker@eu

__str__ must return a string, not print it.

2. Compare readable and developer representations

This class defines both representations for different audiences.

class Build:
    def __init__(self, number):
        self.number = number

    def __str__(self):
        return f"Build #{self.number}"

    def __repr__(self):
        return f"Build(number={self.number})"

build = Build(9)
print(str(build))
print(repr(build))

Output:

Build #9
Build(number=9)

3. Let @dataclass create the initializer

from dataclasses import dataclass

@dataclass
class Job:
    name: str
    retries: int

job = Job("backup", 2)
print(job.name)
print(repr(job))

Output:

backup
Job(name='backup', retries=2)

The fields automatically become constructor parameters.

4. Compare dataclass values

Two different instances can still represent equal data.

from dataclasses import dataclass

@dataclass
class Version:
    component: str
    major: int

first = Version("api", 2)
second = Version("api", 2)
print(first == second)
print(first is second)

Output:

True
False

1. Returning a number or None from __str__; Python requires a string.
2. Using is to compare independent data records by value.
3. Thinking dataclass type annotations enforce runtime types automatically.
4. Assuming @dataclass prevents writing custom methods; you can still customize behavior.