Python is a beautifully flexible beast. Class properties are variable, which means we can change them from anything to anything at any time.

classFlexible:piece="hello world"instance=Flexible()print(instance.piece)# prints “hello world”instance.piece=42print(instance.piece)# prints “42”

Sometimes, we might want to trade some flexibility for safety. Humans are fallible, forgetful, and fickle beasts. Programmers are also humans. We make mistakes more often than we would like to admit.

Fortunately, Python gives us the tools protect ourselves against ourselves. Where we want to, we can trade flexibility for safety. You might wish to protect yourself by creatingimmutable objects : Instances of a class that can’t be modified once they are created.

In this article, we will seek immutability of properties. That is, we will stop ourselves from being able to change the.piece property of aFlexible class.

By making our class properties immutable, we eliminate the need to reason about object state. This reduces our cognitive load, and thus the potential for error.

Note that the immutability in this context is different to the immutability discussed byhimank in hisearlier Dev.to post. There, himank talks about immutability from the perspective of memory, an equally valuable but different angle on the broad topic of immutability in general.

Our objective is to achieve immutability from the perspective of the programmer - To explicitly catch cases were we accidentally attempt to mutate a property that we should not. From the perspective of the machine, the property is still perfectly mutable. We aren’t trying to change the way the property behaves in memory, we are trying to protect ourselves from our own stupidity.

To create an immutable property, we will utilise the inbuilt Pythonproperty class.property allows us to define get and set behaviour for a property.

classFlexible:piece=property(lambdas:"hello world"w)instance=Flexible()print(instance.piece)# prints “hello world”Instance.piece=‘mutated’# throws AttributeError

Theproperty class takes four parameters. The two we will focus on here arefget andfset. In the above example,lambda s: “hello world” was ourfget, allowing us toprint(instance.piece). The absence offset caused the AttributeError when we attempted to set the value ofinstance.piece to’mutated’.

An AttributeError might be a solid enough reminder to yourself that you’ve accidentally done something dumb. However, you might be working on a project with multiple programmers. Perhaps an AttributeError is not a clear enough warning to others that a property should not change.

For example, a colleague might interpret that AttributeError as a sign that you simply forgot to implementfset. They might merrily edit your class, addingfset, unknowingly opening a Pandora’s Box of state-related bugs.

To give our colleagues as much information as possible, let’s make the immutability explicit. We can do so by subclassingproperty.

classImmutable(property):_MESSAGE="Object state must not be mutated"def__init__(self,get)->None:super(fget,self._set_error)defself._set_error(self,_1,_2)->None:raiseRuntimeError(self._MESSAGE)

Now, when we attempt to change a property, we get a clear and unambiguous error.

classFlexible:piece=Immutable(lambdas:"Can't touch this")instance=Flexible()instance.piece="try me"# Raises RuntimeError with clear description

Of course, alambda serving a constant is not going to satisfy many requirements. You can supply thefget parameter something more useful. For example, suppose a class maintains some internal state, readable by the whole program. It is crucial to the safe operation of the program that nothing outside the class modifies that state.

classFlexible:_internal_state=42some_state=Immutable(lambdas:s._internal_state)

In this case, the rest of the program can safely access the value of_internal_state via thesome_state property. We provide a strong hint to our colleagues that_internal_state is off limits by using the leading underscore: A convention for hinting that a variable be treated as "private". The value returned bysome_state can be changed internally by the class, but it is very hard for a programmer to accidentally modify the state externally.

Other languages might achieve this behaviour in other ways, especially through the use of theprivate keyword. For example, in Swift:

classFlexible{publicprivate(set)varsome_state=42}

Unlike Swift and others, Python will not explicitly stop someone from modifying theFlexible state. For example, a colleague could easily execute

instance._internal_state="where is your god now?"

That flexibility is a great strength of Python. The point is not to stop anyone doing anything. The point is to provide helpful hints, checks, and clues to stop ourselves from making silly mistakes.

Originally published athughjeremy.com