Python Academy · Lesson

Defining a Dataclass

Use @dataclass to remove boilerplate.

Defining a Dataclass is a free Python Academy lesson on CoddyKit — lesson 1 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Python Academy learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Why Dataclasses?

When you write a class that mostly holds data, you end up repeating the same boilerplate: an __init__, a __repr__, and an __eq__. The dataclasses module generates all of that for you from simple field declarations.

Less code to write and read.
Fewer chances for typos in __init__.
Built into the standard library since Python 3.7.

The Old Way

Here is a plain class that stores a point. Notice how much typing it takes just to store two numbers.

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

p = Point(1, 2)
print(p.x, p.y)

The @dataclass Decorator

Apply @dataclass above a class and declare fields with type annotations. Python generates __init__ automatically.

from dataclasses import dataclass

@dataclass
class Point:
    x: int
    y: int

p = Point(1, 2)
print(p.x, p.y)

Automatic repr

Dataclasses also build a readable __repr__, so printing the object shows its fields instead of a memory address.

from dataclasses import dataclass

@dataclass
class Point:
    x: int
    y: int

print(Point(3, 4))

Automatic eq

Two dataclass instances compare equal when all their fields are equal. No need to write __eq__ by hand.

from dataclasses import dataclass

@dataclass
class Point:
    x: int
    y: int

print(Point(1, 2) == Point(1, 2))
print(Point(1, 2) == Point(9, 9))

Type Annotations Are Required

Each field must have a type annotation. The annotation is what tells the dataclass machinery that the name is a field. A bare assignment without an annotation becomes a regular class attribute, not a field.

from dataclasses import dataclass

@dataclass
class User:
    name: str
    age: int

u = User('Alice', 30)
print(u)

Adding Methods

A dataclass is still a normal class. You can add ordinary methods that use the generated fields.

from dataclasses import dataclass

@dataclass
class Rectangle:
    width: int
    height: int

    def area(self):
        return self.width * self.height

r = Rectangle(3, 4)
print(r.area())

Mutating Fields

By default dataclass instances are mutable, so you can reassign fields after creation just like normal attributes.

from dataclasses import dataclass

@dataclass
class Counter:
    value: int

c = Counter(0)
c.value += 5
print(c.value)

asdict and astuple

The helpers asdict() and astuple() convert an instance into a dictionary or tuple, which is handy for serialization.

from dataclasses import dataclass, asdict, astuple

@dataclass
class Point:
    x: int
    y: int

p = Point(1, 2)
print(asdict(p))
print(astuple(p))

Nested Dataclasses

A dataclass field can itself be another dataclass. The generated __repr__ and asdict() recurse into nested structures.

from dataclasses import dataclass, asdict

@dataclass
class Address:
    city: str

@dataclass
class Person:
    name: str
    address: Address

p = Person('Bob', Address('Paris'))
print(asdict(p))

When to Use Dataclasses

Reach for a dataclass when a class mainly groups related values together.

Configuration objects.
Records returned from a function.
Simple value types like coordinates or money.

For classes dominated by behavior rather than data, a regular class may read more clearly.

Quick Check

What does the @dataclass decorator generate automatically?

Recap

You learned to use @dataclass to remove boilerplate.

Declare fields with type annotations.
__init__, __repr__, and __eq__ are generated.
Use asdict() and astuple() to convert instances.
You can still add methods and nest dataclasses.

Frequently asked questions

Is the “Defining a Dataclass” lesson free?

Yes — the full text of “Defining a Dataclass” is free to read here on the web, and the Python Academy course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Python Academy course, upgrade to CoddyKit PRO.

What will I learn in “Defining a Dataclass”?

Use @dataclass to remove boilerplate. You practise Python Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Python Academy?

No prior experience is required. Python Academy on CoddyKit is structured for beginners through advanced learners; this is — lesson 1 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Defining a Dataclass” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Python Academy lesson?

Yes. Every Python Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to Python Academy