Usage of slots

Question

What is the purpose of   slots   in Python     especially with respect to when I would want to use it  and when not

User · Answer

Quoting Jacob Hallen      The proper use of   slots   is to save space in objects  Instead of having   a dynamic dict that allows adding attributes to objects at anytime    there is a static structure which does not allow additions after creation     This use of   slots   eliminates the overhead of one dict for every object   While this is sometimes a useful optimization  it would be completely   unnecessary if the Python interpreter was dynamic enough so that it would   only require the dict when there actually were additions to the object       Unfortunately there is a side effect to slots  They change the behavior of   the objects that have slots in a way that can be abused by control freaks   and static typing weenies  This is bad  because the control freaks should   be abusing the metaclasses and the static typing weenies should be abusing   decorators  since in Python  there should be only one obvious way of doing something       Making CPython smart enough to handle saving space without   slots   is a major   undertaking  which is probably why it is not on the list of changes for P3k  yet

User · Answer

In Python  what is the purpose of   slots   and what are the cases one should avoid this   TLDR  The special attribute   slots   allows you to explicitly state which instance attributes you expect your object instances to have  with the expected results   faster attribute access  space savings in memory   The space savings is from  Storing value references in slots instead of   dict    Denying   dict   and   weakref   creation if parent classes deny them and you declare   slots     Quick Caveats Small caveat  you should only declare a particular slot one time in an inheritance tree  For example  class Base        slots      foo    bar   class Right Base         slots      baz     class Wrong Base         slots      foo    bar    baz           redundant foo and bar  Python doesn t object when you get this wrong  it probably should   problems might not otherwise manifest  but your objects will take up more space than they otherwise should  Python 3 8   gt  gt  gt  from sys import getsizeof  gt  gt  gt  getsizeof Right     getsizeof Wrong     56  72   This is because the Base s slot descriptor has a slot separate from the Wrong s  This shouldn t usually come up  but it could   gt  gt  gt  w   Wrong    gt  gt  gt  w foo    foo   gt  gt  gt  Base foo   get   w  Traceback  most recent call last     File  quot  lt stdin gt  quot   line 1  in  lt module gt  AttributeError  foo  gt  gt  gt  Wrong foo   get   w   foo   The biggest caveat is for multiple inheritance - multiple  quot parent classes with nonempty slots quot  cannot be combined  To accommodate this restriction  follow best practices  Factor out all but one or all parents  abstraction which their concrete class respectively and your new concrete class collectively will inherit from - giving the abstraction s  empty slots  just like abstract base classes in the standard library   See section on multiple inheritance below for an example  Requirements   To have attributes named in   slots   to actually be stored in slots instead of a   dict    a class must inherit from object   To prevent the creation of a   dict    you must inherit from object and all classes in the inheritance must declare   slots   and none of them can have a    dict    entry    There are a lot of details if you wish to keep reading  Why use   slots    Faster attribute access  The creator of Python  Guido van Rossum  states that he actually created   slots   for faster attribute access  It is trivial to demonstrate measurably significant faster access  import timeit  class Foo object     slots      foo    class Bar object   pass  slotted   Foo   not slotted   Bar    def get set delete fn obj       def get set delete            obj foo    foo          obj foo         del obj foo     return get set delete  and  gt  gt  gt  min timeit repeat get set delete fn slotted    0 2846834529991611  gt  gt  gt  min timeit repeat get set delete fn not slotted    0 3664822799983085  The slotted access is almost 30  faster in Python 3 5 on Ubuntu   gt  gt  gt  0 3664822799983085   0 2846834529991611 1 2873325658284342  In Python 2 on Windows I have measured it about 15  faster  Why use   slots     Memory Savings Another purpose of   slots   is to reduce the space in memory that each object instance takes up  My own contribution to the documentation clearly states the reasons behind this   The space saved over using   dict   can be significant   SQLAlchemy attributes a lot of memory savings to   slots    To verify this  using the Anaconda distribution of Python 2 7 on Ubuntu Linux  with guppy hpy  aka heapy  and sys getsizeof  the size of a class instance without   slots   declared  and nothing else  is 64 bytes  That does not include the   dict    Thank you Python for lazy evaluation again  the   dict   is apparently not called into existence until it is referenced  but classes without data are usually useless  When called into existence  the   dict   attribute is a minimum of 280 bytes additionally  In contrast  a class instance with   slots   declared to be     no data  is only 16 bytes  and 56 total bytes with one item in slots  64 with two  For 64 bit Python  I illustrate the memory consumption in bytes in Python 2 7 and 3 6  for   slots   and   dict    no slots defined  for each point where the dict grows in 3 6  except for 0  1  and 2 attributes          Python 2 7             Python 3 6 attrs    slots      dict        slots      dict        no slots defined  none   16         56   272      16         56   112         if   dict   referenced one    48         56   272    48         56   112 two    56         56   272    56         56   112 six    88         56   1040   88         56   152 11     128        56   1040   128        56   240 22     216        56   3344   216        56   408      43     384        56   3344   384        56   752  So  in spite of smaller dicts in Python 3  we see how nicely   slots   scale for instances to save us memory  and that is a major reason you would want to use   slots    Just for completeness of my notes  note that there is a one-time cost per slot in the class s namespace of 64 bytes in Python 2  and 72 bytes in Python 3  because slots use data descriptors like properties  called  quot members quot    gt  gt  gt  Foo foo  lt member  foo  of  Foo  objects gt   gt  gt  gt  type Foo foo   lt class  member descriptor  gt   gt  gt  gt  getsizeof Foo foo  72  Demonstration of   slots    To deny the creation of a   dict    you must subclass object  class Base object          slots         now   gt  gt  gt  b   Base    gt  gt  gt  b a    a  Traceback  most recent call last     File  quot  lt pyshell 38 gt  quot   line 1  in  lt module gt      b a    a  AttributeError   Base  object has no attribute  a   Or subclass another class that defines   slots   class Child Base         slots       a     and now  c   Child   c a    a   but   gt  gt  gt  c b    b  Traceback  most recent call last     File  quot  lt pyshell 42 gt  quot   line 1  in  lt module gt      c b    b  AttributeError   Child  object has no attribute  b   To allow   dict   creation while subclassing slotted objects  just add    dict    to the   slots    note that slots are ordered  and you shouldn t repeat slots that are already in parent classes   class SlottedWithDict Child          slots         dict      b    swd   SlottedWithDict   swd a    a  swd b    b  swd c    c   and  gt  gt  gt  swd   dict     c    c    Or you don t even need to declare   slots   in your subclass  and you will still use slots from the parents  but not restrict the creation of a   dict    class NoSlots Child   pass ns   NoSlots   ns a    a  ns b    b   And   gt  gt  gt  ns   dict     b    b    However    slots   may cause problems for multiple inheritance  class BaseA object          slots       a     class BaseB object          slots       b     Because creating a child class from parents with both non-empty slots fails   gt  gt  gt  class Child BaseA  BaseB     slots        Traceback  most recent call last     File  quot  lt pyshell 68 gt  quot   line 1  in  lt module gt      class Child BaseA  BaseB     slots        TypeError  Error when calling the metaclass bases     multiple bases have instance lay-out conflict  If you run into this problem  You could just remove   slots   from the parents  or if you have control of the parents  give them empty slots  or refactor to abstractions  from abc import ABC  class AbstractA ABC         slots         class BaseA AbstractA          slots       a     class AbstractB ABC         slots         class BaseB AbstractB          slots       b     class Child AbstractA  AbstractB          slots       a    b    c   Child     no problem   Add    dict    to   slots   to get dynamic assignment  class Foo object         slots      bar    baz      dict     and now   gt  gt  gt  foo   Foo    gt  gt  gt  foo boink    boink   So with    dict    in slots we lose some of the size benefits with the upside of having dynamic assignment and still having slots for the names we do expect  When you inherit from an object that isn t slotted  you get the same sort of semantics when you use   slots   - names that are in   slots   point to  slotted values  while any other values are put in the instance s   dict    Avoiding   slots   because you want to be able to add attributes on the fly is actually not a good reason - just add  quot   dict   quot  to your   slots   if this is required  You can similarly add   weakref   to   slots   explicitly if you need that feature  Set to empty tuple when subclassing a namedtuple  The namedtuple builtin make immutable instances that are very lightweight  essentially  the size of tuples  but to get the benefits  you need to do it yourself if you subclass them  from collections import namedtuple class MyNT namedtuple  MyNT    bar baz          quot  quot  quot MyNT is an immutable and lightweight object quot  quot  quot        slots         usage   gt  gt  gt  nt   MyNT  bar    baz    gt  gt  gt  nt bar  bar   gt  gt  gt  nt baz  baz   And trying to assign an unexpected attribute raises an AttributeError because we have prevented the creation of   dict     gt  gt  gt  nt quux    quux  Traceback  most recent call last     File  quot  lt stdin gt  quot   line 1  in  lt module gt  AttributeError   MyNT  object has no attribute  quux   You can allow   dict   creation by leaving off   slots         but you can t use non-empty   slots   with subtypes of tuple  Biggest Caveat  Multiple inheritance Even when non-empty slots are the same for multiple parents  they cannot be used together  class Foo object          slots      foo    bar  class Bar object         slots      foo    bar    alas  would work if empty  i e       gt  gt  gt  class Baz Foo  Bar   pass Traceback  most recent call last     File  quot  lt stdin gt  quot   line 1  in  lt module gt  TypeError  Error when calling the metaclass bases     multiple bases have instance lay-out conflict  Using an empty   slots   in the parent seems to provide the most flexibility  allowing the child to choose to prevent or allow  by adding    dict    to get dynamic assignment  see section above  the creation of a   dict    class Foo object     slots        class Bar object     slots        class Baz Foo  Bar     slots       foo    bar   b   Baz   b foo  b bar    foo    bar   You don t have to have slots - so if you add them  and remove them later  it shouldn t cause any problems  Going out on a limb here  If you re composing mixins or using abstract base classes  which aren t intended to be instantiated  an empty   slots   in those parents seems to be the best way to go in terms of flexibility for subclassers  To demonstrate  first  let s create a class with code we d like to use under multiple inheritance class AbstractBase        slots            def   init   self  a  b           self a   a         self b   b     def   repr   self           return f  type self    name     repr self a     repr self b      We could use the above directly by inheriting and declaring the expected slots  class Foo AbstractBase         slots      a    b   But we don t care about that  that s trivial single inheritance  we need another class we might also inherit from  maybe with a noisy attribute  class AbstractBaseC        slots             property     def c self           print  getting c            return self  c      c setter     def c self  arg           print  setting c            self  c   arg  Now if both bases had nonempty slots  we couldn t do the below   In fact  if we wanted  we could have given AbstractBase nonempty slots a and b  and left them out of the below declaration - leaving them in would be wrong   class Concretion AbstractBase  AbstractBaseC         slots      a b  c  split    And now we have functionality from both via multiple inheritance  and can still deny   dict   and   weakref   instantiation   gt  gt  gt  c   Concretion  a    b    gt  gt  gt  c c   c setting c   gt  gt  gt  c c getting c  Concretion  a    b    gt  gt  gt  c d    d  Traceback  most recent call last     File  quot  lt stdin gt  quot   line 1  in  lt module gt  AttributeError   Concretion  object has no attribute  d   Other cases to avoid slots   Avoid them when you want to perform   class   assignment with another class that doesn t have them  and you can t add them  unless the slot layouts are identical   I am very interested in learning who is doing this and why   Avoid them if you want to subclass variable length builtins like long  tuple  or str  and you want to add attributes to them  Avoid them if you insist on providing default values via class attributes for instance variables   You may be able to tease out further caveats from the rest of the   slots   documentation  the 3 7 dev docs are the most current   which I have made significant recent contributions to  Critiques of other answers The current top answers cite outdated information and are quite hand-wavy and miss the mark in some important ways  Do not  quot only use   slots   when instantiating lots of objects quot  I quote    quot You would want to use   slots   if you are going to instantiate a lot  hundreds  thousands  of objects of the same class  quot   Abstract Base Classes  for example  from the collections module  are not instantiated  yet   slots   are declared for them  Why  If a user wishes to deny   dict   or   weakref   creation  those things must not be available in the parent classes    slots   contributes to reusability when creating interfaces or mixins  It is true that many Python users aren t writing for reusability  but when you are  having the option to deny unnecessary space usage is valuable    slots   doesn t break pickling When pickling a slotted object  you may find it complains with a misleading TypeError   gt  gt  gt  pickle loads pickle dumps f   TypeError  a class that defines   slots   without defining   getstate   cannot be pickled  This is actually incorrect  This message comes from the oldest protocol  which is the default  You can select the latest protocol with the -1 argument  In Python 2 7 this would be 2  which was introduced in 2 3   and in 3 6 it is 4   gt  gt  gt  pickle loads pickle dumps f  -1    lt   main   Foo object at 0x1129C770 gt   in Python 2 7   gt  gt  gt  pickle loads pickle dumps f  2    lt   main   Foo object at 0x1129C770 gt   in Python 3 6  gt  gt  gt  pickle loads pickle dumps f  4    lt   main   Foo object at 0x1129C770 gt   So I would keep this in mind  as it is a solved problem  Critique of the  until Oct 2  2016  accepted answer The first paragraph is half short explanation  half predictive  Here s the only part that actually answers the question  The proper use of   slots   is to save space in objects  Instead of having a dynamic dict that allows adding attributes to objects at anytime  there is a static structure which does not allow additions after creation  This saves the overhead of one dict for every object that uses slots  The second half is wishful thinking  and off the mark   While this is sometimes a useful optimization  it would be completely unnecessary if the Python interpreter was dynamic enough so that it would only require the dict when there actually were additions to the object   Python actually does something similar to this  only creating the   dict   when it is accessed  but creating lots of objects with no data is fairly ridiculous  The second paragraph oversimplifies and misses actual reasons to avoid   slots    The below is not a real reason to avoid slots  for actual reasons  see the rest of my answer above     They change the behavior of the objects that have slots in a way that can be abused by control freaks and static typing weenies   It then goes on to discuss other ways of accomplishing that perverse goal with Python  not discussing anything to do with   slots    The third paragraph is more wishful thinking  Together it is mostly off-the-mark content that the answerer didn t even author and contributes to ammunition for critics of the site  Memory usage evidence Create some normal objects and slotted objects   gt  gt  gt  class Foo object   pass  gt  gt  gt  class Bar object     slots         Instantiate a million of them   gt  gt  gt  foos    Foo   for f in xrange 1000000    gt  gt  gt  bars    Bar   for b in xrange 1000000    Inspect with guppy hpy   heap     gt  gt  gt  guppy hpy   heap   Partition of a set of 2028259 objects  Total size   99763360 bytes   Index  Count         Size     Cumulative    Kind  class   dict of class       0 1000000  49 64000000  64  64000000  64   main   Foo      1     169   0 16281480  16  80281480  80 list      2 1000000  49 16000000  16  96281480  97   main   Bar      3   12284   1   987472   1  97268952  97 str      Access the regular objects and their   dict   and inspect again   gt  gt  gt  for f in foos          f   dict    gt  gt  gt  guppy hpy   heap   Partition of a set of 3028258 objects  Total size   379763480 bytes   Index  Count          Size      Cumulative    Kind  class   dict of class       0 1000000  33 280000000  74 280000000  74 dict of   main   Foo      1 1000000  33  64000000  17 344000000  91   main   Foo      2     169   0  16281480   4 360281480  95 list      3 1000000  33  16000000   4 376281480  99   main   Bar      4   12284   0    987472   0 377268952  99 str      This is consistent with the history of Python  from Unifying types and classes in Python 2 2  If you subclass a built-in type  extra space is automatically added to the instances to accomodate   dict   and   weakrefs     The   dict   is not initialized until you use it though  so you shouldn t worry about the space occupied by an empty dictionary for each instance you create   If you don t need this extra space  you can add the phrase  quot   slots        quot  to your class

User · Answer

Each python object has a   dict   atttribute which is a dictionary containing all other attributes  e g  when you type self attr python is actually doing self   dict    attr    As you can imagine using a dictionary to store attribute takes some extra space  amp  time for accessing it   However  when you use   slots    any object created for that class won t have a   dict   attribute  Instead  all attribute access is done directly via pointers   So if want a C style structure rather than a full fledged class you can use   slots   for compacting size of the objects  amp  reducing attribute access time  A good example is a Point class containing attributes x  amp  y  If you are going to have a lot of points  you can try using   slots   in order to conserve some memory

User · Answer

Another somewhat obscure use of   slots   is to add attributes to an object proxy from the ProxyTypes package  formerly part of the PEAK project  Its ObjectWrapper allows you to proxy another object  but intercept all interactions with the proxied object  It is not very commonly used  and no Python 3 support   but we have used it to implement a thread-safe blocking wrapper around an async implementation based on tornado that bounces all access to the proxied object through the ioloop  using thread-safe concurrent Future objects to synchronise and return results   By default any attribute access to the proxy object will give you the result from the proxied object  If you need to add an attribute on the proxy object    slots   can be used   from peak util proxies import ObjectWrapper  class Original object       def   init   self           self name    The Original   class ProxyOriginal ObjectWrapper          slots       proxy name        def   init   self  subject  proxy name             proxy info attributed added directly to the           Original instance  not the ProxyOriginal instance         self proxy info    You are proxied by     format proxy name             proxy name added to ProxyOriginal instance  since it is           defined in   slots           self proxy name   proxy name          super ProxyOriginal  self    init   subject   if   name         main         original   Original       proxy   ProxyOriginal original   Proxy Overlord          Both statements print  The Original      print  original name     original name     print  proxy name     proxy name        Both statements below print         You are proxied by Proxy Overlord   since the ProxyOriginal         init   sets it to the original object      print  original proxy info     original proxy info     print  proxy proxy info     proxy proxy info        prints  Proxy Overlord      print  proxy proxy name     proxy proxy name       Raises AttributeError since proxy name is only set on        the proxy object     print  original proxy name     proxy proxy name

User · Answer

A very simple example of   slot   attribute  Problem  Without   slots   If I don t have   slot   attribute  in my class  I can add new attributes to  my objects  class Test      pass  obj1 Test   obj2 Test    print obj1   dict      -- gt     obj1 x 12 print obj1   dict       -- gt    x   12  obj1 y 20 print obj1   dict       -- gt    x   12   y   20   obj2 x 99 print obj2   dict       -- gt    x   99   If you look at example above  you can see that obj1 and obj2 have their own x and y attributes and python has also created  a dict attribute for each object  obj1 and obj2   Suppose if my class Test has thousands of such objects  Creating an additional attribute dict for each object will cause lot of overhead  memory  computing power etc   in my code  Solution  With   slots   Now in the following example my class Test contains   slots   attribute  Now I can t add new attributes to my objects  except attribute x  and python doesn t create a dict attribute anymore  This eliminates overhead for each object  which can become significant if you have many objects  class Test        slots     quot x quot    obj1 Test   obj2 Test   obj1 x 12 print obj1 x     -- gt  12 obj2 x 99 print obj2 x     -- gt  99  obj1 y 28 print obj1 y     -- gt  AttributeError   Test  object has no attribute  y

User · Answer

Each python object has a   dict   atttribute which is a dictionary containing all other attributes  e g  when you type self attr python is actually doing self   dict    attr    As you can imagine using a dictionary to store attribute takes some extra space  amp  time for accessing it   However  when you use   slots    any object created for that class won t have a   dict   attribute  Instead  all attribute access is done directly via pointers   So if want a C style structure rather than a full fledged class you can use   slots   for compacting size of the objects  amp  reducing attribute access time  A good example is a Point class containing attributes x  amp  y  If you are going to have a lot of points  you can try using   slots   in order to conserve some memory

User · Answer

A very simple example of   slot   attribute  Problem  Without   slots   If I don t have   slot   attribute  in my class  I can add new attributes to  my objects  class Test      pass  obj1 Test   obj2 Test    print obj1   dict      -- gt     obj1 x 12 print obj1   dict       -- gt    x   12  obj1 y 20 print obj1   dict       -- gt    x   12   y   20   obj2 x 99 print obj2   dict       -- gt    x   99   If you look at example above  you can see that obj1 and obj2 have their own x and y attributes and python has also created  a dict attribute for each object  obj1 and obj2   Suppose if my class Test has thousands of such objects  Creating an additional attribute dict for each object will cause lot of overhead  memory  computing power etc   in my code  Solution  With   slots   Now in the following example my class Test contains   slots   attribute  Now I can t add new attributes to my objects  except attribute x  and python doesn t create a dict attribute anymore  This eliminates overhead for each object  which can become significant if you have many objects  class Test        slots     quot x quot    obj1 Test   obj2 Test   obj1 x 12 print obj1 x     -- gt  12 obj2 x 99 print obj2 x     -- gt  99  obj1 y 28 print obj1 y     -- gt  AttributeError   Test  object has no attribute  y

User · Answer

You would want to use   slots   if you are going to instantiate a lot  hundreds  thousands  of objects of the same class    slots   only exists as a memory optimization tool   It s highly discouraged to use   slots   for constraining attribute creation   Pickling objects with   slots   won t work with the default  oldest  pickle protocol  it s necessary to specify a later version   Some other introspection features of python may also be adversely affected

User · Answer

You would want to use   slots   if you are going to instantiate a lot  hundreds  thousands  of objects of the same class    slots   only exists as a memory optimization tool   It s highly discouraged to use   slots   for constraining attribute creation   Pickling objects with   slots   won t work with the default  oldest  pickle protocol  it s necessary to specify a later version   Some other introspection features of python may also be adversely affected

User · Answer

You have     essentially     no use for   slots       For the time when you think you might need   slots    you actually want to use Lightweight or Flyweight design patterns  These are cases when you no longer want to use purely Python objects  Instead  you want a Python object-like wrapper around an array  struct  or numpy array   class Flyweight object        def get self  theData  index           return theData index       def set self  theData  index  value           theData index   value   The class-like wrapper has no attributes     it just provides methods that act on the underlying data  The methods can be reduced to class methods  Indeed  it could be reduced to just functions operating on the underlying array of data

User · Answer

You would want to use   slots   if you are going to instantiate a lot  hundreds  thousands  of objects of the same class    slots   only exists as a memory optimization tool   It s highly discouraged to use   slots   for constraining attribute creation   Pickling objects with   slots   won t work with the default  oldest  pickle protocol  it s necessary to specify a later version   Some other introspection features of python may also be adversely affected

User · Answer

Slots are very useful for library calls to eliminate the "named method dispatch" when making function calls. This is mentioned in the SWIG documentation. For high performance libraries that want to reduce function overhead for commonly called functions using slots is much faster.

Now this may not be directly related to the OPs question. It is related more to building extensions than it does to using the slots syntax on an object. But it does help complete the picture for the usage of slots and some of the reasoning behind them.

User · Answer

The original question was about general use cases not only about memory. So it should be mentioned here that you also get better performance when instantiating large amounts of objects - interesting e.g. when parsing large documents into objects or from a database.

Here is a comparison of creating object trees with a million entries, using slots and without slots. As a reference also the performance when using plain dicts for the trees (Py2.7.10 on OSX):

********** RUN 1 **********
1.96036410332 <class 'css_tree_select.element.Element'>
3.02922606468 <class 'css_tree_select.element.ElementNoSlots'>
2.90828204155 dict
********** RUN 2 **********
1.77050495148 <class 'css_tree_select.element.Element'>
3.10655999184 <class 'css_tree_select.element.ElementNoSlots'>
2.84120798111 dict
********** RUN 3 **********
1.84069895744 <class 'css_tree_select.element.Element'>
3.21540498734 <class 'css_tree_select.element.ElementNoSlots'>
2.59615707397 dict
********** RUN 4 **********
1.75041103363 <class 'css_tree_select.element.Element'>
3.17366290092 <class 'css_tree_select.element.ElementNoSlots'>
2.70941114426 dict

Test classes (ident, appart from slots):

class Element(object):
    __slots__ = ['_typ', 'id', 'parent', 'childs']
    def __init__(self, typ, id, parent=None):
        self._typ = typ
        self.id = id
        self.childs = []
        if parent:
            self.parent = parent
            parent.childs.append(self)

class ElementNoSlots(object): (same, w/o slots)

testcode, verbose mode:

na, nb, nc = 100, 100, 100
for i in (1, 2, 3, 4):
    print '*' * 10, 'RUN', i, '*' * 10
    # tree with slot and no slot:
    for cls in Element, ElementNoSlots:
        t1 = time.time()
        root = cls('root', 'root')
        for i in xrange(na):
            ela = cls(typ='a', id=i, parent=root)
            for j in xrange(nb):
                elb = cls(typ='b', id=(i, j), parent=ela)
                for k in xrange(nc):
                    elc = cls(typ='c', id=(i, j, k), parent=elb)
        to =  time.time() - t1
        print to, cls
        del root

    # ref: tree with dicts only:
    t1 = time.time()
    droot = {'childs': []}
    for i in xrange(na):
        ela =  {'typ': 'a', id: i, 'childs': []}
        droot['childs'].append(ela)
        for j in xrange(nb):
            elb =  {'typ': 'b', id: (i, j), 'childs': []}
            ela['childs'].append(elb)
            for k in xrange(nc):
                elc =  {'typ': 'c', id: (i, j, k), 'childs': []}
                elb['childs'].append(elc)
    td = time.time() - t1
    print td, 'dict'
    del droot

User · Answer

You have     essentially     no use for   slots       For the time when you think you might need   slots    you actually want to use Lightweight or Flyweight design patterns  These are cases when you no longer want to use purely Python objects  Instead  you want a Python object-like wrapper around an array  struct  or numpy array   class Flyweight object        def get self  theData  index           return theData index       def set self  theData  index  value           theData index   value   The class-like wrapper has no attributes     it just provides methods that act on the underlying data  The methods can be reduced to class methods  Indeed  it could be reduced to just functions operating on the underlying array of data

User · Answer

The original question was about general use cases not only about memory. So it should be mentioned here that you also get better performance when instantiating large amounts of objects - interesting e.g. when parsing large documents into objects or from a database.

Here is a comparison of creating object trees with a million entries, using slots and without slots. As a reference also the performance when using plain dicts for the trees (Py2.7.10 on OSX):

********** RUN 1 **********
1.96036410332 <class 'css_tree_select.element.Element'>
3.02922606468 <class 'css_tree_select.element.ElementNoSlots'>
2.90828204155 dict
********** RUN 2 **********
1.77050495148 <class 'css_tree_select.element.Element'>
3.10655999184 <class 'css_tree_select.element.ElementNoSlots'>
2.84120798111 dict
********** RUN 3 **********
1.84069895744 <class 'css_tree_select.element.Element'>
3.21540498734 <class 'css_tree_select.element.ElementNoSlots'>
2.59615707397 dict
********** RUN 4 **********
1.75041103363 <class 'css_tree_select.element.Element'>
3.17366290092 <class 'css_tree_select.element.ElementNoSlots'>
2.70941114426 dict

Test classes (ident, appart from slots):

class Element(object):
    __slots__ = ['_typ', 'id', 'parent', 'childs']
    def __init__(self, typ, id, parent=None):
        self._typ = typ
        self.id = id
        self.childs = []
        if parent:
            self.parent = parent
            parent.childs.append(self)

class ElementNoSlots(object): (same, w/o slots)

testcode, verbose mode:

na, nb, nc = 100, 100, 100
for i in (1, 2, 3, 4):
    print '*' * 10, 'RUN', i, '*' * 10
    # tree with slot and no slot:
    for cls in Element, ElementNoSlots:
        t1 = time.time()
        root = cls('root', 'root')
        for i in xrange(na):
            ela = cls(typ='a', id=i, parent=root)
            for j in xrange(nb):
                elb = cls(typ='b', id=(i, j), parent=ela)
                for k in xrange(nc):
                    elc = cls(typ='c', id=(i, j, k), parent=elb)
        to =  time.time() - t1
        print to, cls
        del root

    # ref: tree with dicts only:
    t1 = time.time()
    droot = {'childs': []}
    for i in xrange(na):
        ela =  {'typ': 'a', id: i, 'childs': []}
        droot['childs'].append(ela)
        for j in xrange(nb):
            elb =  {'typ': 'b', id: (i, j), 'childs': []}
            ela['childs'].append(elb)
            for k in xrange(nc):
                elc =  {'typ': 'c', id: (i, j, k), 'childs': []}
                elb['childs'].append(elc)
    td = time.time() - t1
    print td, 'dict'
    del droot

User · Answer

Each python object has a   dict   atttribute which is a dictionary containing all other attributes  e g  when you type self attr python is actually doing self   dict    attr    As you can imagine using a dictionary to store attribute takes some extra space  amp  time for accessing it   However  when you use   slots    any object created for that class won t have a   dict   attribute  Instead  all attribute access is done directly via pointers   So if want a C style structure rather than a full fledged class you can use   slots   for compacting size of the objects  amp  reducing attribute access time  A good example is a Point class containing attributes x  amp  y  If you are going to have a lot of points  you can try using   slots   in order to conserve some memory

User · Answer

Quoting Jacob Hallen      The proper use of   slots   is to save space in objects  Instead of having   a dynamic dict that allows adding attributes to objects at anytime    there is a static structure which does not allow additions after creation     This use of   slots   eliminates the overhead of one dict for every object   While this is sometimes a useful optimization  it would be completely   unnecessary if the Python interpreter was dynamic enough so that it would   only require the dict when there actually were additions to the object       Unfortunately there is a side effect to slots  They change the behavior of   the objects that have slots in a way that can be abused by control freaks   and static typing weenies  This is bad  because the control freaks should   be abusing the metaclasses and the static typing weenies should be abusing   decorators  since in Python  there should be only one obvious way of doing something       Making CPython smart enough to handle saving space without   slots   is a major   undertaking  which is probably why it is not on the list of changes for P3k  yet

User · Answer

You would want to use   slots   if you are going to instantiate a lot  hundreds  thousands  of objects of the same class    slots   only exists as a memory optimization tool   It s highly discouraged to use   slots   for constraining attribute creation   Pickling objects with   slots   won t work with the default  oldest  pickle protocol  it s necessary to specify a later version   Some other introspection features of python may also be adversely affected

User · Answer

Each python object has a   dict   atttribute which is a dictionary containing all other attributes  e g  when you type self attr python is actually doing self   dict    attr    As you can imagine using a dictionary to store attribute takes some extra space  amp  time for accessing it   However  when you use   slots    any object created for that class won t have a   dict   attribute  Instead  all attribute access is done directly via pointers   So if want a C style structure rather than a full fledged class you can use   slots   for compacting size of the objects  amp  reducing attribute access time  A good example is a Point class containing attributes x  amp  y  If you are going to have a lot of points  you can try using   slots   in order to conserve some memory

User · Answer

Quoting Jacob Hallen      The proper use of   slots   is to save space in objects  Instead of having   a dynamic dict that allows adding attributes to objects at anytime    there is a static structure which does not allow additions after creation     This use of   slots   eliminates the overhead of one dict for every object   While this is sometimes a useful optimization  it would be completely   unnecessary if the Python interpreter was dynamic enough so that it would   only require the dict when there actually were additions to the object       Unfortunately there is a side effect to slots  They change the behavior of   the objects that have slots in a way that can be abused by control freaks   and static typing weenies  This is bad  because the control freaks should   be abusing the metaclasses and the static typing weenies should be abusing   decorators  since in Python  there should be only one obvious way of doing something       Making CPython smart enough to handle saving space without   slots   is a major   undertaking  which is probably why it is not on the list of changes for P3k  yet

User · Answer

Slots are very useful for library calls to eliminate the "named method dispatch" when making function calls. This is mentioned in the SWIG documentation. For high performance libraries that want to reduce function overhead for commonly called functions using slots is much faster.

Now this may not be directly related to the OPs question. It is related more to building extensions than it does to using the slots syntax on an object. But it does help complete the picture for the usage of slots and some of the reasoning behind them.

User · Answer

An attribute of a class instance has 3 properties: the instance, the name of the attribute, and the value of the attribute.

In regular attribute access, the instance acts as a dictionary and the name of the attribute acts as the key in that dictionary looking up value.

instance(attribute) --> value

In __slots__ access, the name of the attribute acts as the dictionary and the instance acts as the key in the dictionary looking up value.

attribute(instance) --> value

In flyweight pattern, the name of the attribute acts as the dictionary and the value acts as the key in that dictionary looking up the instance.

attribute(value) --> instance

User · Answer

Another somewhat obscure use of   slots   is to add attributes to an object proxy from the ProxyTypes package  formerly part of the PEAK project  Its ObjectWrapper allows you to proxy another object  but intercept all interactions with the proxied object  It is not very commonly used  and no Python 3 support   but we have used it to implement a thread-safe blocking wrapper around an async implementation based on tornado that bounces all access to the proxied object through the ioloop  using thread-safe concurrent Future objects to synchronise and return results   By default any attribute access to the proxy object will give you the result from the proxied object  If you need to add an attribute on the proxy object    slots   can be used   from peak util proxies import ObjectWrapper  class Original object       def   init   self           self name    The Original   class ProxyOriginal ObjectWrapper          slots       proxy name        def   init   self  subject  proxy name             proxy info attributed added directly to the           Original instance  not the ProxyOriginal instance         self proxy info    You are proxied by     format proxy name             proxy name added to ProxyOriginal instance  since it is           defined in   slots           self proxy name   proxy name          super ProxyOriginal  self    init   subject   if   name         main         original   Original       proxy   ProxyOriginal original   Proxy Overlord          Both statements print  The Original      print  original name     original name     print  proxy name     proxy name        Both statements below print         You are proxied by Proxy Overlord   since the ProxyOriginal         init   sets it to the original object      print  original proxy info     original proxy info     print  proxy proxy info     proxy proxy info        prints  Proxy Overlord      print  proxy proxy name     proxy proxy name       Raises AttributeError since proxy name is only set on        the proxy object     print  original proxy name     proxy proxy name

User · Answer

An attribute of a class instance has 3 properties: the instance, the name of the attribute, and the value of the attribute.

In regular attribute access, the instance acts as a dictionary and the name of the attribute acts as the key in that dictionary looking up value.

instance(attribute) --> value

In __slots__ access, the name of the attribute acts as the dictionary and the instance acts as the key in the dictionary looking up value.

attribute(instance) --> value

In flyweight pattern, the name of the attribute acts as the dictionary and the value acts as the key in that dictionary looking up the instance.

attribute(value) --> instance

User · Answer

In addition to the other answers  here is an example of using   slots      gt  gt  gt  class Test object      Must be new-style class         slots       x    y         gt  gt  gt  pt   Test    gt  gt  gt  dir pt      class        delattr        doc        getattribute        hash          init        module        new        reduce        reduce ex          repr        setattr        slots        str      x    y    gt  gt  gt  pt x Traceback  most recent call last     File   lt stdin gt    line 1  in  lt module gt  AttributeError  x  gt  gt  gt  pt x   1  gt  gt  gt  pt x 1  gt  gt  gt  pt z   2 Traceback  most recent call last     File   lt stdin gt    line 1  in  lt module gt  AttributeError   Test  object has no attribute  z   gt  gt  gt  pt   dict   Traceback  most recent call last     File   lt stdin gt    line 1  in  lt module gt  AttributeError   Test  object has no attribute    dict     gt  gt  gt  pt   slots     x    y     So  to implement   slots    it only takes an extra line  and making your class a new-style class if it isn t already   This way you can reduce the memory footprint of those classes 5-fold  at the expense of having to write custom pickle code  if and when that becomes necessary

User · Answer

You have     essentially     no use for   slots       For the time when you think you might need   slots    you actually want to use Lightweight or Flyweight design patterns  These are cases when you no longer want to use purely Python objects  Instead  you want a Python object-like wrapper around an array  struct  or numpy array   class Flyweight object        def get self  theData  index           return theData index       def set self  theData  index  value           theData index   value   The class-like wrapper has no attributes     it just provides methods that act on the underlying data  The methods can be reduced to class methods  Indeed  it could be reduced to just functions operating on the underlying array of data

User · Answer

In Python  what is the purpose of   slots   and what are the cases one should avoid this   TLDR  The special attribute   slots   allows you to explicitly state which instance attributes you expect your object instances to have  with the expected results   faster attribute access  space savings in memory   The space savings is from  Storing value references in slots instead of   dict    Denying   dict   and   weakref   creation if parent classes deny them and you declare   slots     Quick Caveats Small caveat  you should only declare a particular slot one time in an inheritance tree  For example  class Base        slots      foo    bar   class Right Base         slots      baz     class Wrong Base         slots      foo    bar    baz           redundant foo and bar  Python doesn t object when you get this wrong  it probably should   problems might not otherwise manifest  but your objects will take up more space than they otherwise should  Python 3 8   gt  gt  gt  from sys import getsizeof  gt  gt  gt  getsizeof Right     getsizeof Wrong     56  72   This is because the Base s slot descriptor has a slot separate from the Wrong s  This shouldn t usually come up  but it could   gt  gt  gt  w   Wrong    gt  gt  gt  w foo    foo   gt  gt  gt  Base foo   get   w  Traceback  most recent call last     File  quot  lt stdin gt  quot   line 1  in  lt module gt  AttributeError  foo  gt  gt  gt  Wrong foo   get   w   foo   The biggest caveat is for multiple inheritance - multiple  quot parent classes with nonempty slots quot  cannot be combined  To accommodate this restriction  follow best practices  Factor out all but one or all parents  abstraction which their concrete class respectively and your new concrete class collectively will inherit from - giving the abstraction s  empty slots  just like abstract base classes in the standard library   See section on multiple inheritance below for an example  Requirements   To have attributes named in   slots   to actually be stored in slots instead of a   dict    a class must inherit from object   To prevent the creation of a   dict    you must inherit from object and all classes in the inheritance must declare   slots   and none of them can have a    dict    entry    There are a lot of details if you wish to keep reading  Why use   slots    Faster attribute access  The creator of Python  Guido van Rossum  states that he actually created   slots   for faster attribute access  It is trivial to demonstrate measurably significant faster access  import timeit  class Foo object     slots      foo    class Bar object   pass  slotted   Foo   not slotted   Bar    def get set delete fn obj       def get set delete            obj foo    foo          obj foo         del obj foo     return get set delete  and  gt  gt  gt  min timeit repeat get set delete fn slotted    0 2846834529991611  gt  gt  gt  min timeit repeat get set delete fn not slotted    0 3664822799983085  The slotted access is almost 30  faster in Python 3 5 on Ubuntu   gt  gt  gt  0 3664822799983085   0 2846834529991611 1 2873325658284342  In Python 2 on Windows I have measured it about 15  faster  Why use   slots     Memory Savings Another purpose of   slots   is to reduce the space in memory that each object instance takes up  My own contribution to the documentation clearly states the reasons behind this   The space saved over using   dict   can be significant   SQLAlchemy attributes a lot of memory savings to   slots    To verify this  using the Anaconda distribution of Python 2 7 on Ubuntu Linux  with guppy hpy  aka heapy  and sys getsizeof  the size of a class instance without   slots   declared  and nothing else  is 64 bytes  That does not include the   dict    Thank you Python for lazy evaluation again  the   dict   is apparently not called into existence until it is referenced  but classes without data are usually useless  When called into existence  the   dict   attribute is a minimum of 280 bytes additionally  In contrast  a class instance with   slots   declared to be     no data  is only 16 bytes  and 56 total bytes with one item in slots  64 with two  For 64 bit Python  I illustrate the memory consumption in bytes in Python 2 7 and 3 6  for   slots   and   dict    no slots defined  for each point where the dict grows in 3 6  except for 0  1  and 2 attributes          Python 2 7             Python 3 6 attrs    slots      dict        slots      dict        no slots defined  none   16         56   272      16         56   112         if   dict   referenced one    48         56   272    48         56   112 two    56         56   272    56         56   112 six    88         56   1040   88         56   152 11     128        56   1040   128        56   240 22     216        56   3344   216        56   408      43     384        56   3344   384        56   752  So  in spite of smaller dicts in Python 3  we see how nicely   slots   scale for instances to save us memory  and that is a major reason you would want to use   slots    Just for completeness of my notes  note that there is a one-time cost per slot in the class s namespace of 64 bytes in Python 2  and 72 bytes in Python 3  because slots use data descriptors like properties  called  quot members quot    gt  gt  gt  Foo foo  lt member  foo  of  Foo  objects gt   gt  gt  gt  type Foo foo   lt class  member descriptor  gt   gt  gt  gt  getsizeof Foo foo  72  Demonstration of   slots    To deny the creation of a   dict    you must subclass object  class Base object          slots         now   gt  gt  gt  b   Base    gt  gt  gt  b a    a  Traceback  most recent call last     File  quot  lt pyshell 38 gt  quot   line 1  in  lt module gt      b a    a  AttributeError   Base  object has no attribute  a   Or subclass another class that defines   slots   class Child Base         slots       a     and now  c   Child   c a    a   but   gt  gt  gt  c b    b  Traceback  most recent call last     File  quot  lt pyshell 42 gt  quot   line 1  in  lt module gt      c b    b  AttributeError   Child  object has no attribute  b   To allow   dict   creation while subclassing slotted objects  just add    dict    to the   slots    note that slots are ordered  and you shouldn t repeat slots that are already in parent classes   class SlottedWithDict Child          slots         dict      b    swd   SlottedWithDict   swd a    a  swd b    b  swd c    c   and  gt  gt  gt  swd   dict     c    c    Or you don t even need to declare   slots   in your subclass  and you will still use slots from the parents  but not restrict the creation of a   dict    class NoSlots Child   pass ns   NoSlots   ns a    a  ns b    b   And   gt  gt  gt  ns   dict     b    b    However    slots   may cause problems for multiple inheritance  class BaseA object          slots       a     class BaseB object          slots       b     Because creating a child class from parents with both non-empty slots fails   gt  gt  gt  class Child BaseA  BaseB     slots        Traceback  most recent call last     File  quot  lt pyshell 68 gt  quot   line 1  in  lt module gt      class Child BaseA  BaseB     slots        TypeError  Error when calling the metaclass bases     multiple bases have instance lay-out conflict  If you run into this problem  You could just remove   slots   from the parents  or if you have control of the parents  give them empty slots  or refactor to abstractions  from abc import ABC  class AbstractA ABC         slots         class BaseA AbstractA          slots       a     class AbstractB ABC         slots         class BaseB AbstractB          slots       b     class Child AbstractA  AbstractB          slots       a    b    c   Child     no problem   Add    dict    to   slots   to get dynamic assignment  class Foo object         slots      bar    baz      dict     and now   gt  gt  gt  foo   Foo    gt  gt  gt  foo boink    boink   So with    dict    in slots we lose some of the size benefits with the upside of having dynamic assignment and still having slots for the names we do expect  When you inherit from an object that isn t slotted  you get the same sort of semantics when you use   slots   - names that are in   slots   point to  slotted values  while any other values are put in the instance s   dict    Avoiding   slots   because you want to be able to add attributes on the fly is actually not a good reason - just add  quot   dict   quot  to your   slots   if this is required  You can similarly add   weakref   to   slots   explicitly if you need that feature  Set to empty tuple when subclassing a namedtuple  The namedtuple builtin make immutable instances that are very lightweight  essentially  the size of tuples  but to get the benefits  you need to do it yourself if you subclass them  from collections import namedtuple class MyNT namedtuple  MyNT    bar baz          quot  quot  quot MyNT is an immutable and lightweight object quot  quot  quot        slots         usage   gt  gt  gt  nt   MyNT  bar    baz    gt  gt  gt  nt bar  bar   gt  gt  gt  nt baz  baz   And trying to assign an unexpected attribute raises an AttributeError because we have prevented the creation of   dict     gt  gt  gt  nt quux    quux  Traceback  most recent call last     File  quot  lt stdin gt  quot   line 1  in  lt module gt  AttributeError   MyNT  object has no attribute  quux   You can allow   dict   creation by leaving off   slots         but you can t use non-empty   slots   with subtypes of tuple  Biggest Caveat  Multiple inheritance Even when non-empty slots are the same for multiple parents  they cannot be used together  class Foo object          slots      foo    bar  class Bar object         slots      foo    bar    alas  would work if empty  i e       gt  gt  gt  class Baz Foo  Bar   pass Traceback  most recent call last     File  quot  lt stdin gt  quot   line 1  in  lt module gt  TypeError  Error when calling the metaclass bases     multiple bases have instance lay-out conflict  Using an empty   slots   in the parent seems to provide the most flexibility  allowing the child to choose to prevent or allow  by adding    dict    to get dynamic assignment  see section above  the creation of a   dict    class Foo object     slots        class Bar object     slots        class Baz Foo  Bar     slots       foo    bar   b   Baz   b foo  b bar    foo    bar   You don t have to have slots - so if you add them  and remove them later  it shouldn t cause any problems  Going out on a limb here  If you re composing mixins or using abstract base classes  which aren t intended to be instantiated  an empty   slots   in those parents seems to be the best way to go in terms of flexibility for subclassers  To demonstrate  first  let s create a class with code we d like to use under multiple inheritance class AbstractBase        slots            def   init   self  a  b           self a   a         self b   b     def   repr   self           return f  type self    name     repr self a     repr self b      We could use the above directly by inheriting and declaring the expected slots  class Foo AbstractBase         slots      a    b   But we don t care about that  that s trivial single inheritance  we need another class we might also inherit from  maybe with a noisy attribute  class AbstractBaseC        slots             property     def c self           print  getting c            return self  c      c setter     def c self  arg           print  setting c            self  c   arg  Now if both bases had nonempty slots  we couldn t do the below   In fact  if we wanted  we could have given AbstractBase nonempty slots a and b  and left them out of the below declaration - leaving them in would be wrong   class Concretion AbstractBase  AbstractBaseC         slots      a b  c  split    And now we have functionality from both via multiple inheritance  and can still deny   dict   and   weakref   instantiation   gt  gt  gt  c   Concretion  a    b    gt  gt  gt  c c   c setting c   gt  gt  gt  c c getting c  Concretion  a    b    gt  gt  gt  c d    d  Traceback  most recent call last     File  quot  lt stdin gt  quot   line 1  in  lt module gt  AttributeError   Concretion  object has no attribute  d   Other cases to avoid slots   Avoid them when you want to perform   class   assignment with another class that doesn t have them  and you can t add them  unless the slot layouts are identical   I am very interested in learning who is doing this and why   Avoid them if you want to subclass variable length builtins like long  tuple  or str  and you want to add attributes to them  Avoid them if you insist on providing default values via class attributes for instance variables   You may be able to tease out further caveats from the rest of the   slots   documentation  the 3 7 dev docs are the most current   which I have made significant recent contributions to  Critiques of other answers The current top answers cite outdated information and are quite hand-wavy and miss the mark in some important ways  Do not  quot only use   slots   when instantiating lots of objects quot  I quote    quot You would want to use   slots   if you are going to instantiate a lot  hundreds  thousands  of objects of the same class  quot   Abstract Base Classes  for example  from the collections module  are not instantiated  yet   slots   are declared for them  Why  If a user wishes to deny   dict   or   weakref   creation  those things must not be available in the parent classes    slots   contributes to reusability when creating interfaces or mixins  It is true that many Python users aren t writing for reusability  but when you are  having the option to deny unnecessary space usage is valuable    slots   doesn t break pickling When pickling a slotted object  you may find it complains with a misleading TypeError   gt  gt  gt  pickle loads pickle dumps f   TypeError  a class that defines   slots   without defining   getstate   cannot be pickled  This is actually incorrect  This message comes from the oldest protocol  which is the default  You can select the latest protocol with the -1 argument  In Python 2 7 this would be 2  which was introduced in 2 3   and in 3 6 it is 4   gt  gt  gt  pickle loads pickle dumps f  -1    lt   main   Foo object at 0x1129C770 gt   in Python 2 7   gt  gt  gt  pickle loads pickle dumps f  2    lt   main   Foo object at 0x1129C770 gt   in Python 3 6  gt  gt  gt  pickle loads pickle dumps f  4    lt   main   Foo object at 0x1129C770 gt   So I would keep this in mind  as it is a solved problem  Critique of the  until Oct 2  2016  accepted answer The first paragraph is half short explanation  half predictive  Here s the only part that actually answers the question  The proper use of   slots   is to save space in objects  Instead of having a dynamic dict that allows adding attributes to objects at anytime  there is a static structure which does not allow additions after creation  This saves the overhead of one dict for every object that uses slots  The second half is wishful thinking  and off the mark   While this is sometimes a useful optimization  it would be completely unnecessary if the Python interpreter was dynamic enough so that it would only require the dict when there actually were additions to the object   Python actually does something similar to this  only creating the   dict   when it is accessed  but creating lots of objects with no data is fairly ridiculous  The second paragraph oversimplifies and misses actual reasons to avoid   slots    The below is not a real reason to avoid slots  for actual reasons  see the rest of my answer above     They change the behavior of the objects that have slots in a way that can be abused by control freaks and static typing weenies   It then goes on to discuss other ways of accomplishing that perverse goal with Python  not discussing anything to do with   slots    The third paragraph is more wishful thinking  Together it is mostly off-the-mark content that the answerer didn t even author and contributes to ammunition for critics of the site  Memory usage evidence Create some normal objects and slotted objects   gt  gt  gt  class Foo object   pass  gt  gt  gt  class Bar object     slots         Instantiate a million of them   gt  gt  gt  foos    Foo   for f in xrange 1000000    gt  gt  gt  bars    Bar   for b in xrange 1000000    Inspect with guppy hpy   heap     gt  gt  gt  guppy hpy   heap   Partition of a set of 2028259 objects  Total size   99763360 bytes   Index  Count         Size     Cumulative    Kind  class   dict of class       0 1000000  49 64000000  64  64000000  64   main   Foo      1     169   0 16281480  16  80281480  80 list      2 1000000  49 16000000  16  96281480  97   main   Bar      3   12284   1   987472   1  97268952  97 str      Access the regular objects and their   dict   and inspect again   gt  gt  gt  for f in foos          f   dict    gt  gt  gt  guppy hpy   heap   Partition of a set of 3028258 objects  Total size   379763480 bytes   Index  Count          Size      Cumulative    Kind  class   dict of class       0 1000000  33 280000000  74 280000000  74 dict of   main   Foo      1 1000000  33  64000000  17 344000000  91   main   Foo      2     169   0  16281480   4 360281480  95 list      3 1000000  33  16000000   4 376281480  99   main   Bar      4   12284   0    987472   0 377268952  99 str      This is consistent with the history of Python  from Unifying types and classes in Python 2 2  If you subclass a built-in type  extra space is automatically added to the instances to accomodate   dict   and   weakrefs     The   dict   is not initialized until you use it though  so you shouldn t worry about the space occupied by an empty dictionary for each instance you create   If you don t need this extra space  you can add the phrase  quot   slots        quot  to your class

User · Answer

In addition to the other answers  here is an example of using   slots      gt  gt  gt  class Test object      Must be new-style class         slots       x    y         gt  gt  gt  pt   Test    gt  gt  gt  dir pt      class        delattr        doc        getattribute        hash          init        module        new        reduce        reduce ex          repr        setattr        slots        str      x    y    gt  gt  gt  pt x Traceback  most recent call last     File   lt stdin gt    line 1  in  lt module gt  AttributeError  x  gt  gt  gt  pt x   1  gt  gt  gt  pt x 1  gt  gt  gt  pt z   2 Traceback  most recent call last     File   lt stdin gt    line 1  in  lt module gt  AttributeError   Test  object has no attribute  z   gt  gt  gt  pt   dict   Traceback  most recent call last     File   lt stdin gt    line 1  in  lt module gt  AttributeError   Test  object has no attribute    dict     gt  gt  gt  pt   slots     x    y     So  to implement   slots    it only takes an extra line  and making your class a new-style class if it isn t already   This way you can reduce the memory footprint of those classes 5-fold  at the expense of having to write custom pickle code  if and when that becomes necessary

User · Answer

You have     essentially     no use for   slots       For the time when you think you might need   slots    you actually want to use Lightweight or Flyweight design patterns  These are cases when you no longer want to use purely Python objects  Instead  you want a Python object-like wrapper around an array  struct  or numpy array   class Flyweight object        def get self  theData  index           return theData index       def set self  theData  index  value           theData index   value   The class-like wrapper has no attributes     it just provides methods that act on the underlying data  The methods can be reduced to class methods  Indeed  it could be reduced to just functions operating on the underlying array of data

User · Answer

Quoting Jacob Hallen      The proper use of   slots   is to save space in objects  Instead of having   a dynamic dict that allows adding attributes to objects at anytime    there is a static structure which does not allow additions after creation     This use of   slots   eliminates the overhead of one dict for every object   While this is sometimes a useful optimization  it would be completely   unnecessary if the Python interpreter was dynamic enough so that it would   only require the dict when there actually were additions to the object       Unfortunately there is a side effect to slots  They change the behavior of   the objects that have slots in a way that can be abused by control freaks   and static typing weenies  This is bad  because the control freaks should   be abusing the metaclasses and the static typing weenies should be abusing   decorators  since in Python  there should be only one obvious way of doing something       Making CPython smart enough to handle saving space without   slots   is a major   undertaking  which is probably why it is not on the list of changes for P3k  yet

[python] Usage of slots?

The answer is

Problem: Without `slots`

Solution: With `slots`

Problem: Without `slots`

Solution: With `slots`

Examples related to python

Examples related to oop

Examples related to python-internals

Examples related to slots

Tags

[python] Usage of __slots__?

The answer is

Problem: Without __slots__

Solution: With __slots__

Problem: Without __slots__

Solution: With __slots__

Examples related to python

Examples related to oop

Examples related to python-internals

Examples related to slots

Tags

[python] Usage of slots?

Problem: Without `slots`

Solution: With `slots`

Problem: Without `slots`

Solution: With `slots`