Leveraging __slots__ for Better Performance in Python Classes

Each time when we create a new class python stores every attribute in adictattribute 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 useslots. 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

slotsmay be useful tool, but comes with limitations:

• No dynamic attributes: while definingslotsin 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 addingdictto theslot.

• No multiple inheritance: every base class must containslotsdefined, 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 howslotsare 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 definingslots, 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 withslots, you can't add new attributes dynamically, so it's best used when your class attributes are fixed and well-defined.

The above is the detailed content of Leveraging __slots__ for Better Performance in Python Classes. For more information, please follow other related articles on the PHP Chinese website!