What is a Data Class in Python?

In Python, a data class is a class specifically designed to store data and provide an easy and concise way to define classes that primarily store values (attributes) without the need for writing repetitive boilerplate code.

It simplifies the creation of classes that are meant to store data and automatically generates common methods like __init__, __repr__, __eq__, and more for you, based on the class attributes you define.

How to Define a Data Class

To define a data class, you use the @dataclass decorator, which is applied to the class. This decorator automatically adds special methods for you.

@dataclass
class Student:
  
  id:int,
  price:float,
  name:str
  
#creating instance
student = Stduent(id=1,price=90.90, name= 'John')
print(student.price)


  

Features and Methods Automatically Added by @dataclass:

1. __init__: This method is automatically generated. It allows you to instantiate objects by directly passing values for the attributes. product = Product(id=1, name="Laptop", price=999.99) # No need to manually define __init__
2. __repr__: A __repr__ method is automatically generated that returns a string representation of the instance, which is helpful for debugging and logging. print(product) # Output: Product(id=1, name='Laptop', price=999.99)
3. __eq__: This method is automatically generated so you can compare instances using == product1 = Product(id=1, name="Laptop", price=999.99) product2 = Product(id=1, name="Laptop", price=999.99) print(product1 == product2) # Output: True (since all attributes are the same)
4. __hash__: If your class is hashable, it will automatically have a __hash__ method, which is useful for using data class objects in sets and as dictionary keys.
5. __post_init__: If you need to do any custom initialization after the __init__ method, you can define a __post_init__ method, which is called after the instance is created.

Why are Data Classes Needed?

1. Boilerplate Reduction: Normally, when you define a class, you need to write methods like __init__, __repr__, and __eq__ manually, which can become repetitive and error-prone. Data classes automatically generate these methods for you, making your code more concise.
2. Cleaner Code: With data classes, you can define a class with just the attributes and let Python handle the other details like equality checks and string representations, reducing the amount of code you need to write.
3. Better Readability: Data classes make it clear that a class is intended to hold data, which improves readability and understanding of the code.
4. Immutable Data Classes (Optional): By using frozen=True, you can make a data class immutable, meaning its attributes cannot be changed after instantiation. This is useful for making data structures that should remain constant, such as configuration settings.

@dataclass(frozen=True)
class Product:
    id: int
    name: str
    price: float

product = Product(id=1, name="Laptop", price=999.99)
product.price = 899.99  # This will raise a dataclasses.FrozenInstanceError

Advantages of Data Classes Over Normal Classes

1. Less Boilerplate: You don’t need to write the __init__, __repr__, __eq__, __hash__, and other special methods manually. This reduces repetitive code and improves productivity.
2. Improved Readability: The data class is explicitly designed to store data, which improves the readability of your code and makes it clear that the class is for storing data only.
3. Comparison Support: Data classes automatically support comparison operations (like ==, !=, <, <=, etc.) based on their attributes. This means you don’t have to manually implement comparison logic for the attributes.
4. Default Values: You can specify default values for fields in a data class, just like in normal classes, but with less code.pythonCopy code@dataclass class Product: id: int name: str = "Unknown Product" # Default value price: float = 0.0
5. Mutability Control: Data classes can be made immutable by using frozen=True, which makes them safer and ensures data integrity.
6. Custom Initialization: If you need additional logic during object creation, you can define the __post_init__ method to add custom processing right after the object is initialized.

Example with Data Class in Python

Here’s an example of a data class used to store a simple product and perform some operations:

from dataclasses import dataclass

@dataclass
class Product:
    id: int
    name: str
    price: float
    quantity: int = 0

    def total_cost(self):
        return self.price * self.quantity

    @property
    def is_in_stock(self):
        return self.quantity > 0

# Creating an instance of Product
product = Product(id=1, name="Laptop", price=1000.00, quantity=5)

# Accessing properties and methods
print(product)  # Output: Product(id=1, name='Laptop', price=1000.0, quantity=5)
print(product.total_cost())  # Output: 5000.0
print(product.is_in_stock)  # Output: True