How to restrict setting an attribute outside of constructor?

Question

I want to forbid further assignments on some attributes of a class after it was initialized. For instance; no one can explicitly assign any value to 'ssn' (social security number) property after the Person instance 'p' has been initialized. _setattr_ is also being called while assigning the value inside _init_ method, thus it is not what I want. I'd like to restrict only further assignments. How can I achieve that?

class Person(object):
    def __init__(self, name, ssn):
        self.name = name
        self._ssn = ssn

    def __setattr__(self, name, value):
        if name == '_ssn':
            raise AttributeError('Denied.')
        else:
            object.__setattr__(self, name, value)

>> p = Person('Ozgur', '1234')
>> AttributeError: Denied.

Medici

Just because assignments in __init__ also calls __setattr__ – Aileen

I think you may have to try with a metaclass – Obsidian

FYI, this isn't really how Python's meant to work. Document your API to tell other developers not to change it. – Commissar

@detly: The usual philosophy in Python is to take measures to prevent an accidental breach of contract, but not to bother to prevent an intentional breach of contract. – Verditer

@SvenMarnach - true; it's up to the OP to apply the rule to his or her situation. – Commissar

Answer 1

The usual way is to use a "private" attribute starting with an underscore, and a read-only property for public access:

import operator

class Person(object):
    def __init__(self, name, ssn):
        self.name = name
        self._ssn = ssn
    ssn = property(operator.attrgetter("_ssn"))

Note that this does not really hinder anybody to change the attribute _ssn, but the leading _ documents that the attribute is private.

Verditer

+1. Python philosophy is that instead of having language-enforced "you can't touch this", you use attributes starting with _ to signal implementation details - which means clients can try to fiddle with it, but they are no longer covered by any guarantees you make about backward/forward compatibility or class invariants. So, they can fiddle, they can break things, but its their own damn fault. – Gunstock

Answer 2

Python does not support private or protected attributes. You need to implement the descriptor protocol instead. The standard library provides decorators to do that succinctly.

Just declare the attribute with two underscores in front of it in the init method. It is called name mangling and prevents the attribute from being accessible via __ssn, although it can still be accessed and modified by _Person__ssn in this case. However, if you do not explicitly define a setter for it will raise an AttributeError.

Of course if someone has an intention to misuse the API that person can if he is very intent. But it will not happen by accident.

import re

class Person:
    """Encapsulates the private data of a person."""

    _PATTERN = re.COMPILE(r'abcd-efgh-ssn')

    def __init__(self, name, ssn):
       """Initializes Person class with input name of person and
       his social security number (ssn).
       """
       # you can add some type and value checking here for defensive programming
       # or validation for the ssn using regex for example that raises an error
       if not self._PATTERN.match(ssn):
           raise ValueError('ssn is not valid')
       self.__name = name
       self.__ssn = snn

    @property
    def name(self):
        return self.__name

    @name.setter
    def name(self, value):
        self.__name = value

    @property
    def ssn(self):
        return self.__ssn

>>> p = Person('aname', 'abcd-efgh-ssn')
>>> p.ssn
'abcd-efgh-ssn'
>>> p.ssn = 'mistake'
AttributeError: 'can't set attribute'

Trismus

Answer 3

Just pointing out that we could still modify _ssn.

Objects have the special attribute, __dict__ that is a dictionary that maps all instance attributes of the object with their corresponding values. We can add/update/delete instance attributes directly by modifying the __dict__ attribute of an object.

We can still modify _snn like this:

p = Person('Ozgur', '1234')

p.__dict__.get('_ssn') # returns '1234'

p.__dict__['_ssn'] = '4321'

p.__dict__.get('_ssn') # returns '4321'

As we can see, we were still able to change the value of _ssn. By design, there isn't a straight forward way, if any, to circumvent attribute access in Python in all cases.

I'll show a more common way to restrict attribute access using property() as a decorator:

class Person(object):
    def __init__(self, name, ssn):
        self.name = name
        self._ssn = ssn

    @property
    def ssn(self):
        return self._ssn

    @ssn.setter
    def ssn(self, value):
        raise AttributeError('Denied')


>> p = Person('Ozgur', '1234')
>> p.ssn
>> '1234'
>> p.ssn = '4321'
>> AttributeError: Denied

Hope this helps!

Veats

Answer 4

You can bypass setattr by directly assigning to the instance dictionary in the constructor. Of course, this trick can always be used to spoof any other hoops you employ to make _ssn read-only (after an initial write)

 class Person(object): 
    def __init__(self, name, ssn):    
        self.name = name
        self.__dict__['_ssn'] = ssn 

    def __setattr__(self, name, value):
        if name == '_ssn':
            raise AttributeError('Denied.')
        else:
            object.__setattr__(self, name, value)

Leontina

Answer 5

I use a boolean flag switched on and then off in the constructor. This has the effect of only allowing the setter to work during instantiation. Obviously it can be easily circumvented by a malicious actor, but it will block accidental reassignment of ssn:

class Person():
    def __init__(self, name, ssn):
        self.constructing = True
        self.name = name
        self.ssn = ssn
        self.constructing = False

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, name):
        self._name = name

    @property
    def ssn(self):
        return self._ssn

    @ssn.setter
    def ssn(self, ssn):
        if not self.constructing:
            raise ValueError("Cannot change social security number")
        self._ssn = ssn

Reannareap

Answer 6

Problem 📖

In Python you can not create a true read-only attribute, but you can make modifying it harder.

You can make modifying an attribute a true headache even with Python. Here is the recipe. Even if you were willing to go to C-extension level, modifications to attributes could still be done but they would require using C pointers.

Solution 🍝

from types import MappingProxyType as Proxy
class Person:
    """A person with two read-only attributes.
    
    Setting __slots__ will prevent adding new attributes, but __slots__ itself
    can still be modified. Custom __setattr__ will prevent direct modification
    of __slots__ while custom __getattr__ will direct attribute lookup towards
    the real keys hiding behind the proxy attribute. Then, MappingProxyType is
    used to prevent easily modifying the proxy attribute even when accessed by
    using object.__getattribute__ and object.__setattr__ to bypass the methods
    defined in 'read-only' class. Normal 'self.proxy' can not be used here due
    to the __getattr__ and __setattr__ preventing it.
    """
    __slots__ = ("proxy")
    def __init__(self, name, ssn):
        object.__setattr__(self, "proxy", Proxy({"name": name, "ssn": ssn}))
    def __getattr__(self, name):
        proxy = object.__getattribute__(self, "proxy")
        if (name == "proxy") or (name not in proxy):
            return object.__getattribute__(self, name)
        return proxy[name]
    def __setattr__(self, _name, _val):
        raise AttributeError("Read-only object")

Example 🖥️

>>> person = Person("Joe", 123)
>>>
>>> person.name, person.ssn
('Joe', 123)
>>>
>>> person.name, person.ssn = "Niinistö", 1337
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 22, in __setattr__
AttributeError: Read-only object
>>>
>>> 
>>> person.fake_attribute = 1337
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 22, in __setattr__
AttributeError: Read-only object
>>>

Tobacco