Data classes in Python

Data classes as data types

Data can be represented by several ways:

• For atomic elements, we can use basic types such as int, float or str.
• For more advanced pieces of data, we can use containers, such as list or dict. Containers can store basic types and also be nested, allowing complex data representations.

The container types are however very generic since a dict does not impose restrictions on the keys it stores. We therefore often use classes to store data. It enables a usefull autocomplete feature provided by IDEs. The class name is used to represent the type of the instance of the class.

Let's see a small example of a class in Python 3:

class User:
   def __init__(self, name, age):
      self.name = name
      self.age = age

bob = User("Bob", 20)

bob is an instance of the class User. The same information can be represented by a dict:

bob = {'name': "Bob",
       'age': 20}

However, using the former is handy since it enables IDE features:

In order to enhance the powers of the IDE, we can add type informations on the fields:

class User:
   def __init__(self, name: str, age: int):
      self.name = name
      self.age = age

Since for storing data, we often set all the arguments of the __init__ method as fields of the object, we may prefer a more concise syntax: data classes. Data classes are a new way to define classes in Python:

from dataclasses import dataclass

@dataclass
class User:
   name: str
   age: int

It defines automatically the __init__ method. Data classes are regular classes, the only difference being the way to define the class. We will see in the following section that data classes define other usefull methods automatically.

Data classes as object factories

The drawbacks when definining a class is that you need to define some methods for your objects to behave nicely:

• have a readable and usefull representation of an object,
• compare the equality of two objects in a natural way,
• use objects as keys of a dictionary.

Data classes automatically handle this for you as we will see in this section.

print(bob)

{'name': 'Bob', 'age': 20}

<__main__.User object at 0x105c56780>

class User:
   def __init__(self, name: str, age: int):
      self.name = name
      self.age = age

   def __str__(self):
      return f"User:\nname: {self.name}\nage: {self.age}"

User:
name: Bob
age: 20

def __repr__(self):
   return f"User(\"{self.name}\", {self.age})"

bob_copy = eval(repr(bob))

bob = {'name': "Bob", 'age': 20}
alice = {'name': "Alice", 'age': 21}
bob_copy = {'name': "Bob", 'age': 20}

print(bob == bob, bob == alice, bob == bob_copy)

bob = User("Bob", 20)
alice = User("Alice", 21)
bob_copy = User("Bob", 20)

print(bob == bob, bob == alice, bob == bob_copy)

from dataclasses import dataclass

@dataclass(frozen=True)
class User:
   name: str
   age: int

{User("Bob", 20): 1}

from dataclasses import dataclass

@dataclass
class User:
    name: str
    age: int

    def get_older(self):
        self.age += 1

    @property
    def is_an_adult(self):
        return self.age >= 18

bob = User("Bob", 17)
print(bob.is_an_adult)
bob.get_older()
print(bob.is_an_adult)

Conclusion

Data classes are a new way to define classes in Python.

• Since the resulting classes are regular Python classes, we can take advantage of their benefits: implement some methods and use the autocomplete features provided by IDEs for instance.
• Their syntax is more concise, and they generate automatically some methods such as __repr__, __str__ and __eq__.
• They can easily be declared as frozen, allowing for instance to use them as keys of a dictionary (the __hash__ method is generated automatically in this case).

This new feature is particularly interesting for data science applications because we always have to define data entities and manipulate them. It makes code more readable, less tedious to write and provides static type checking eases.