Leveraging slots for Better Performance in Python Classes

Konrad — Sun, 25 Aug 2024 19:06:41 +0000

Each time when we create a new class python stores every attribute in a dict attribute which is called a dynamic dictionary. This default behaviour seems to be convenient, because it is flexible, but when you're working with a large number of instances or memory usage matters then this overhead can be significant.

How do 'slots' work?

Python basically uses a dictionary to store class attributes, but one of the alternatives is to use slots. By defining this name, we are telling Python to use a more static and compact structure which significantly reduces memory usage. Here's a basic example of how to use slots in a class.

import sys 

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

class WithSlots:
    __slots__ = ['x', 'y']

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

obj1 = WithoutSlots(1, 2)
obj2 = WithSlots(1, 2)

print(sys.getsizeof(obj1.__dict__)) # 296
print(sys.getsizeof(obj2)) # 48

As shown above 'WithoutSlots' uses much more memory compared to 'WithSlots'. Think about creating many instances of the class - Which approach would be the better choice?

Limitations

slots may be useful tool, but comes with limitations:

No dynamic attributes: while defining slots in the class body we disable its default attribute (dict), so we cannot dynamically add new attributes to the instance after it's creation.

obj = WithSlots(1, 2)
obj.z = 3  # This will raise an AttributeError

We can get around this by adding dict to the slot.

No multiple inheritance: every base class must contain slots defined, otherwise python will revert to using dictionary to store the instance attributes.
No default value: You need to explicitly initialise default values explicitly in the init method.

When to use it

I've written down some best scenario examples where we can use slots:

When we have a lot of instances to create and memory usage is a concern.
When we need to optimise performance.
When you have attributes that are known and fixed.
When you work with large datasets.

Final thoughts

This is how slots are used in Python: you can use them when you're certain you won't need any other attributes for your class and you’re working with a large number of instances. By defining slots, you tell Python to use a more efficient and compact structure for storing attributes, which helps save memory. This is especially handy when memory usage is a concern or when you need to optimize performance. Just remember that with slots, you can't add new attributes dynamically, so it's best used when your class attributes are fixed and well-defined.

Understanding the Differences Between Regular Classes and Dataclasses in Python

Konrad — Sun, 11 Aug 2024 19:20:10 +0000

Introduction

In Python defining data structures can be accomplished through various methods. Two commonly used approaches are regular classes and dataclass. Understanding the differences between these two methods can help in selecting the most suitable option for a given task. This article provides a comparative analysis of regular classes and dataclass, highlighting their respective characteristics and appropriate use cases.

Regular classes

A regular class in Python is a traditional way of creating objects. It necessitates explicit definitions for various methods and attributes. These include the initializer method (init) the string representation method (repr) and the equality comparison method (eq) among others.

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

    def __repr__(self):
        return f"Person(name='{self.name}', age={self.age})"

    def __eq__(self, other):
        if isinstance(other, Person):
            return self.name == other.name and self.age == other.age
        return False

Advantages

When you opt for regular classes you unlock several key benefits that cater to complex and customized needs:

Complete Control: Offers comprehensive control over method definitions and class behaviour allowing for detailed customisation.
Flexibility: Suitable for scenarios requiring complex initialization logic or additional functionality beyond simple data storage.

Disadvantages

However this level of control and flexibility comes with its own set of challenges:

Boilerplate Code: Requires significant amounts of manual code for defining standard methods, which can lead to increased development time and potential for errors.
Complexity: Can be more cumbersome when dealing with straightforward data storage tasks due to the additional code required.

Dataclasses

The dataclass decorator introduced in Python 3.7 simplifies the creation of classes used primarily for data storage. It automatically generates common methods such as init, repr, and eq, thereby reducing the amount of boilerplate code.

from dataclasses import dataclass

@dataclass
class Person:
    name: str
    age: int

Advantages

Choosing dataclass brings several notable benefits, particularly when dealing with straightforward data management tasks:

Reduced Boilerplate: Minimizes the amount of code required to define a class, enhancing code clarity and maintainability.
Automatic Method Generation: Automatically creates several useful methods facilitating easier class creation and improving code readability.
Default Values and Immutability: Supports default values for fields and the option to make instances immutable with the frozen=True parameter.

Disadvantages

While dataclass offers many advantages, it also comes with certain limitations:

Limited Customization: Provides less control over the specific implementations of the generated methods compared to manually defining them.
Simplicity: Most effective for straightforward data structures; more complex behaviors may still require regular classes.

Choosing the Appropriate Approach

When to use Regular Classes:

Complex Initialization: Opt for regular classes when detailed and customized initialization logic is required. For instance, a class managing various configuration settings might need specialized initialization routines.
Custom Behavior: If the class requires methods with complex or unique behaviors that cannot be easily handled by automatic method generation, regular classes are a better choice.
Legacy Code: In scenarios involving existing codebases or libraries that use traditional class definitions, it may be more consistent to continue using regular classes.

When to use Dataclasses:

Data Storage: Use dataclass when the primary goal is to store and manage simple data with minimal boilerplate. It is ideal for classes where automatic method generation provides significant benefits.
Code Simplicity: When aiming for cleaner and more readable code, especially for straightforward data structures, dataclass can enhance development efficiency.
Default Values and Immutability: If you need to leverage default field values or enforce immutability, dataclass offers built-in support for these features.

Final thoughts

Both regular classes and dataclass serve important roles in programming using Python. Regular classes provide extensive control and flexibility while dataclass offers an efficient and streamlined approach for handling simple data structures. By understanding the distinct advantages and limitations of each developers can make informed decisions to optimize their coding practices and improve code maintainability.

DEV Community: Konrad

Leveraging __slots__ for Better Performance in Python Classes

How do 'slots' work?

Limitations

When to use it

Final thoughts

Understanding the Differences Between Regular Classes and Dataclasses in Python

Introduction

Regular classes

Advantages

Disadvantages

Dataclasses

Advantages

Disadvantages

Choosing the Appropriate Approach

Final thoughts

Leveraging slots for Better Performance in Python Classes