Dictionary vs Object – which is more efficient and why?

by

Have you tried using __slots__?

From the documentation:

By default, instances of both old and new-style classes have a dictionary for attribute storage. This wastes space for objects having very few instance variables. The space consumption can become acute when creating large numbers of instances.

The default can be overridden by defining __slots__ in a new-style class definition. The __slots__ declaration takes a sequence of instance variables and reserves just enough space in each instance to hold a value for each variable. Space is saved because __dict__ is not created for each instance.

So does this save time as well as memory?

Comparing the three approaches on my computer:

test_slots.py:

class Obj(object):
  __slots__ = ('i', 'l')
  def __init__(self, i):
    self.i = i
    self.l = []
all = {}
for i in range(1000000):
  all[i] = Obj(i)

test_obj.py:

class Obj(object):
  def __init__(self, i):
    self.i = i
    self.l = []
all = {}
for i in range(1000000):
  all[i] = Obj(i)

test_dict.py:

all = {}
for i in range(1000000):
  o = {}
  o['i'] = i
  o['l'] = []
  all[i] = o

test_namedtuple.py (supported in 2.6):

import collections

Obj = collections.namedtuple('Obj', 'i l')

all = {}
for i in range(1000000):
  all[i] = Obj(i, [])

Run benchmark (using CPython 2.5):

$ lshw | grep product | head -n 1
          product: Intel(R) Pentium(R) M processor 1.60GHz
$ python --version
Python 2.5
$ time python test_obj.py && time python test_dict.py && time python test_slots.py 

real    0m27.398s (using 'normal' object)
real    0m16.747s (using __dict__)
real    0m11.777s (using __slots__)

Using CPython 2.6.2, including the named tuple test:

$ python --version
Python 2.6.2
$ time python test_obj.py && time python test_dict.py && time python test_slots.py && time python test_namedtuple.py 

real    0m27.197s (using 'normal' object)
real    0m17.657s (using __dict__)
real    0m12.249s (using __slots__)
real    0m12.262s (using namedtuple)

So yes (not really a surprise), using __slots__ is a performance optimization. Using a named tuple has similar performance to __slots__.

More Related Contents:

  1. Replace values in a pandas series via dictionary efficiently
  2. Convert nested Python dict to object?
  3. Python dictionary from an object’s fields
  4. How to convert a nested Python dict to object?
  5. [] and {} vs list() and dict(), which is better?
  6. Python: get a dict from a list based on something inside the dict
  7. How expensive are Python dictionaries to handle?
  8. Python: iterating over list vs over dict items efficiency
  9. Python: is “except KeyError” faster than “if key in dict”?
  10. Fast way to copy dictionary in Python
  11. Improving performance of very large dictionary in Python
  12. differences between “d = dict()” and “d = {}”
  13. Why is “1000000000000000 in range(1000000000000001)” so fast in Python 3?
  14. Determine the type of an object?
  15. Getting key with maximum value in dictionary?
  16. Is there any pythonic way to combine two dicts (adding values for keys that appear in both)?
  17. How do I call a parent class’s method from a child class in Python?
  18. I’m getting Key error in python
  19. Merge and sum of two dictionaries
  20. Link ATLAS/MKL to an installed Numpy
  21. Intersecting two dictionaries
  22. Python dictionary keys. “In” complexity
  23. How to convert list of key-value tuples into dictionary?
  24. Combining Dictionaries Of Lists In Python
  25. Set attributes from dictionary in python
  26. Python 3 dictionary with known keys typing
  27. Python built-in sum function vs. for loop performance
  28. sum each value in a list of tuples
  29. Why does dict(k=4, z=2).update(dict(l=1)) return None in Python? [duplicate]
  30. How do I send list of dictionary as Body parameter together with Files in FastAPI?

Leave a Comment