How does __setattr__ work with class attributes?

__setattr__() is called whenever a value is assigned to any of the class’s property. Even if the property is initialized in the __init__(), it will make call to __setattr__(). Below is the example to illustrate that:

>>> class X(object):
...     def __init__(self, a, b):
...         self.a = a
...         self.b = b
...     def __setattr__(self, k, v):
...         print 'Set Attr: {} -> {}'.format(k, v)
...
>>> x = X(1, 3)       # <-- __setattr__() called by __init__() 
Set Attr: a -> 1
Set Attr: b -> 3
>>> x.a = 9           # <-- __setattr__() called during external assignment
Set Attr: a -> 9

The below can be found in the python documentation

Attribute assignments and deletions update the instance’s dictionary, never a class’s dictionary. If the class has a __setattr__() or __delattr__() method, this is called instead of updating the instance dictionary directly.

As you can clearly see the __setattr__() changes the instances dictionary when it is called. So whenever you try to assign a self.instance it raises your exception Exception(“Attribute is Read-Only”).
Whereas that’s not the case with setting a class’s attribute so no exception is raised.

__setattr__ is only invoked on instances of a class and not the actual class itself. However, the class is still an object, so when setting the attribute of the class the __setattr__ of the class of the class is invoked.

To change how attributes are set on classes you need to look into meta-classes. Metaclasses are overkill for almost any application, and can get confusing very easily. And trying to make a user-defined class/object read-only is normally a bad idea. That said, here is a simple example.

>>> class SampleMetaclass(type): # type as parent, not object
...     def __setattr__(self, name, value):
...         raise AttributeError("Class is read-only")
... 
>>> class SampleClass(metaclass=SampleMetaclass):
...     def __setattr__(self, name, value):
...         raise AttributeError("Instance is read-only")
... 
>>> SampleClass.attr = 1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in __setattr__
AttributeError: Class is read-only
>>> s = SampleClass()
>>> s.attr = 1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in __setattr__
AttributeError: Instance is read-only

The __setattr__ method defined in a class is only called for attribute assignments on instances of the class. It is not called for class variables, since they’re not being assigned on an instance of the class with the method.

Of course, classes are instances too. They’re instances of type (or a custom metaclass, usually a subclass of type). So if you want to prevent class variable creation, you need to create a metaclass with a __setattr__ method.

But that’s not really what you need to make your class do what you want. To just get a read-only attribute that can only be written once (in the __init__ method), you can probably get by with some simpler logic. One approach is to set another attribute at the end of the __init__ method, which tells __setattr__ to lock down assignments after it is set:

class Foo:
    def __init__(self, a, b):
        self.a = a
        self.b = b
        self._initialized = True

    def __setattr__(self, name, value):
        if self.__dict__.get('_initialized'):
            raise Exception("Attribute is Read-Only")
        super().__setattr__(name, value)

Another option would be to use property descriptors for the read-only attributes and store the real values in "private" variables that can be assigned to normally. You’d not use __setattr__ in this version:

class Foo:
    def __init__(self, a, b):
        self._a = a
        self._b = b

    @property
    def a(self):
        return self._a

    @property
    def b(self):
        return self._b

foo = Foo(3, 5)
foo.a = 7 # causes "AttributeError: can't set attribute"