Difference Between Instance Attributes and Class Attributes

The fundamental difference is that class attributes are shared by all instances of that class, while instance attributes are particular to each object created with that class. Thus, instance variables are for data unique to each object and class variables are for attributes that must be shared by all instances of that class.

• Instance attributesinstance.attr are created using the or syntax self.attr( selfit's really a convention, it's just an identifier that refers to the instance itself). As has been said, they are local to that instance and therefore only accessible from one of them.

  As a general rule they are created within a method. Instance attributes can be created on any instance method, but it is generally good practice to do so in the class's initializer ( __init__) or constructor ( __new__) or at most in a method that is called directly from one of them. If this is not done (even just initializing them to a null value) the code loses readability and more importantly, the attribute does not exist until the method that creates it is called, which creates uncertainty as to whether an instance does or does not have a certain attribute at a given time.

  As for their utility, we can generically say that they allow defining a certain "state" for that particular object and that it differentiates it from other objects of its class. Such as the "license plate" attribute in a "Car" class.

  They are stored in a dictionary (instance or object dictionary) which you can access via NombreInstancia.__dict__.

• Class attributes are defined outside of any class methods, usually just below the documentation string. They can be referenced directly from the class and can also be referenced from any instance of the class. Common uses are to create an enumerated constant, as a control variable in a Singleton, to set default values ​​for instance variables, to define constants, etc.

  They are stored in a different dictionary (class dictionary) and independent from the one used for instance attributes, which you can query through NombreClase.__dict__or from an instance with NombreInstancia.__class__.__dict__. Properties and descriptors in general are also at the class level, not the instance level.

  Note: In Python 3 the class dictionary is of type mappingproxy, without going too far a direct consequence is to make the dictionary read-only and in principle you will only __setattr__be able to modify it in your case. This is done for efficiency and stability, among other things it ensures that the keys can only be strings.

It is important to know the order in which an attribute access is resolved, Python follows the following order when looking up an attribute from an object:

1. Special attributes ( __dict__, __slots__, __weakref__, etc.).
2. Data descriptors (implement __set__) in class dictionary and possible parent classes.
3. Instance attributes.
4. Non-data descriptors (implement __get__but do not __set__) in class dictionary and parents.
5. Finally try to delegate to the __getattr__.

if we ignore the data descriptors (and therefore properties with setter ) Python first looks for the attribute in the instance attributes, and if not found it looks in the class attributes. This implies that if you create an instance attribute with the same name as an already present class attribute, the class attribute is "hidden" if the path self.atributoor is attempted to be accessed instancia.atributo.

In the case of assignment, the order is:

1. Data descriptors in the class and parents.
2. Method__setattr__
3. Instance attributes, if the attribute does not exist and the above fails, the new attribute is automatically added as an instance attribute .

The above basically answers the question, the following is somewhat longer (mainly for the examples) and tries to explain a common error caused by the difference between assigning to a class attribute from its class or from an instance and directly related with the resolution order explained above.

If someone doesn't want to read more ツ, the moral is:

If a new value is going to be assigned to a class attribute (which is not a data descriptor), always do it referring from the class, not from the instance. That is, via NombreClase.atributoor using a class method ( @classmethod) not via self.atributoor nombre_instancia.atributo, since this does not modify the class attribute but creates a new instance attribute with the same name.

As discussed above we can access class attributes in both ways:

>>> class Foo:
        n = 7

>>> inst = Foo()
>>> inst.n             # Acceso mediante nombre de una instancia
7
>>> Foo.n              # Acceso mediante nombre de la clase
7
>>> inst.__class__.n   # Acceso mediante el atributo __class__ de la instancia
7

When instead of just accessing the value we want to perform an assignment, things change:

• If we assign through the class the behavior is as expected, the value changes for all instances of the class:

  >>> class Foo:
          cls_n = 13
  
          @classmethod
          def set_cls_n(cls, v):
              cls.cls_n = v
  
  >>> inst1 = Foo()
  >>> inst2 = Foo()
  >>> inst1.cls_n
  13
  >>> inst2.cls_n
  13
  >>> Foo.cls_n = 7
  >>> inst1.cls_n
  7
  >>> inst2.cls_n
  7
  >>> inst1.set_cls_n(23)
  >>> inst1.cls_n
  23
  >>> inst2.cls_n
  23
  

  You can see how modifying the value of neither using Foo.nor through a class method (where equals clsrefers to ) the change is reflected in all instances of the class.Foo__class__

• If we assign a new value to the class variable using an instance to refer to it we get a surprise:

  >>> class Foo:
          cls_n = 13
  
  >>> inst1 = Foo()
  >>> inst2 = Foo()
  >>> inst1.cls_n
  13
  >>> inst2.cls_n
  13
  >>> inst1.cls_n = 7
  >>> inst1.cls_n
  7
  >>> inst2.cls_n
  13               # ????????????????????
  

  Attempting to assign a new object to the class attribute using instancia.atributoor from a via instance method self.atributo(as long as we are not dealing with a data descriptor that as we saw has precedence and would behave as we expect) the class attribute is not modified, it is created an instance attribute with the same name and the new value is assigned .

  Let's remember that the attributes (again apart data descriptors) are first searched in __dict__and then in __class__.__dict__if they are not found, this causes the class attribute to be hidden behind the instance one, we can see it through the content of __dict__and __class__.__dict__:

  >>> inst1 = Foo()
  >>> inst1.__dict__
  {}
  >>> inst1.__class__.__dict__
  mappingproxy({'__module__': '__main__',
               'cls_n': 13,
               '__dict__': <attribute '__dict__' of 'Foo' objects>,
               '__weakref__': <attribute '__weakref__' of 'Foo' objects>,
                '__doc__': None
              })
  
  
  >>> inst1.cls_n = 7
  >>> inst1.__dict__
  {'cls_n': 7}         # <<<< Nuestro nuevo atributo de instancia
  >>> inst1.__class__.__dict__
  mappingproxy({'__module__': '__main__',
               'cls_n': 13,
               '__dict__': <attribute '__dict__' of 'Foo' objects>,
               '__weakref__': <attribute
               '__weakref__' of 'Foo' objects>,
               '__doc__': None
              })
  

Finally, remember that in Python there are mutable objects like ( list, dict, set) and immutable ( int, float, bool, tuple, frozenset, str). Immutable objects cannot be modified once created, when we concatenate a string a new object is created, which does not happen with a list:

    >>> a = "Hola"
    >>> b = "StackOverflow"
    >>> id(a)
    2105306070744
    >>> id(b)
    2105306118320
    >>> a += b
    >>> a
    'HolaStackOverflow'
    >>> id(a)       
    2105306110544    # a ahora hace referencia a otro objeto

    >>> a = ["Hola"]
    >>> b = ["StackOverflow"]
    >>> id(a)
    2105306091848
    >>> id(b)
    2105305993800
    >>> a += b
    >>> a 
    ['Hola', 'StackOverflow']
    >>> id(a)
    2105306091848    # a sigue haciendo referencia al mismo objeto

Python handles assignment by reference, a variable or attribute is nothing more than an identifier, a name, that refers to an object in memory. Class attributes are shared between all instances because they reference the same object in memory, so when we modify mutable class attributes via instancia.atributoor self.atributothe change if that is reflected in all instances:

class Foo:
    a = [100]                # Atributo de clase

    def __init__(self, n):
        self.b = [n]         # Atributo de instancia


>>> inst1 = Foo(1)
>>> inst2 = Foo(2)

>>> inst1.a
[100]
>>> inst2.a
[100]
>>> inst1.a += [5]
>>> inst1.a
[100, 5]
>>> inst2.a
[100, 5]

This does not happen with the instance attribute since it is specific to each object:

>>> inst1.b
[1]    
>>> inst2.b
[2] 
>>> inst1.b += [5]
>>> inst1.b
[1, 5]
>>> inst2.b
[2]

If the class attribute refers to an immutable object, although we try to "modify" it in one instance, this does not imply doing it in the rest, since "modifying" an immutable object always implies an assignment in between and, as seen before, an assignment from instance causes the creation of a new instance attribute, not the modification of the class attribute (unless it is a data descriptor):

>>> class Foo:
        s = "Hola"

>>> a = Foo()
>>> b = Foo()
>>> a.s += " StackOverflow"
>>> a.s
'Hola StackOverflow'
>>> b.s
'Hola'

Unlike what happened with the list, string concatenation (or operations with integers, floats, etc.) implies the creation of a new object and an attempt to assign it to the attribute, which implies the creation of an instance attribute like we saw before and not the alteration of the class attribute.

Although the descriptors are intimately linked to all this and are mentioned repeatedly, they are not entered because explaining the descriptor protocol would imply extending the response too much when it is already possibly too long, we can see in the documentation itself a general guide about this: Descriptor HowTo Guide

A class variable is inherited by all instances that derive from it. If you look at this example:

pi@rp1:~ $ python3
Python 3.4.2 (default, Oct 19 2014, 13:31:11)
[GCC 4.9.1] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> class Perro:
...     numero_patas = 4
...
>>> pancho = Perro()
>>> fido = Perro()
>>> pancho.numero_patas
4
>>> fido.numero_patas
4
>>> Perro.numero_patas
4

panchoand fidoare two instances Perrothat have inherited the value of the variable numero_patas. Now we change the value of the variable in the instancefido

>>> fido.numero_patas = 3
>>> fido.numero_patas
3
>>>

Now we add a new instance variable to fido:

>>> fido.cola = 'cortada'
>>> fido.cola
'cortada'

In Python, class and instance variables are stored in different dictionaries. If we look in the dictionary of each created instance:

>>> pancho.__dict__
{}
>>> fido.__dict__
{'cola': 'cortada', 'numero_patas': 3}
>>>

We see that panchoit has no instance variables. However, when we have asked for it , it numero_patashas returned us 4. This is because there is a second dictionary, the class dictionary, which is accessed when the instance variable is not found in its dictionary. If we access it:

>>> pancho.__class__.__dict__
mappingproxy({'__weakref__': <attribute '__weakref__' of 'Perro' objects>, '__dict__': <attribute '__dict__' of 'Perro' objects>, 'numero_patas': 4, '__module__': '__main__', '__doc__': None})
>>> fido.__class__.__dict__
mappingproxy({'__weakref__': <attribute '__weakref__' of 'Perro' objects>, '__dict__': <attribute '__dict__' of 'Perro' objects>, 'numero_patas': 4, '__module__': '__main__', '__doc__': None})
>>>

You will see that they are identical. If you're deriving a single instance of a class, you should use instance variables, since accessing the instance variable dictionary first will be a bit faster.

The difference between a class attribute and an instance attribute is in the way of accessing them , therefore for instance attributes it is only possible to access through an object, for class attributes it is accessed directly from the class and/or also by means of an object.