Can I prevent modifying an object in Python?

Question

I want to control global variables (or globally scoped variables) in a way that they are set only once in program initialization code, and lock them after that.

I use UPPER_CASE_VARIABLES for global variables, but I want to have a sure way not to change the variable anyway.

• Does python provide that (or similar) feature?
• How do you control the globally scoped variables?

Answer 1

You could wrap your global variables in an object and override the object.__setattr__ method. You can then prevent setting attributes that are already set. However, this doesn't deal with complex objects that are passed by reference. You would need to make shallow/deep copies of those objects to be absolutely sure they can't be modified. If you are using new style classes you could override object.__getattribute__(self, name) to make the copies.

class State(object):
    def __init__(self):
        pass

    def __setattr__(self, name, value):
        if name not in self.__dict__:
            self.__dict__[name] = value

** I usually don't worry so much if someone is going to try really hard to break my code. I find overriding __setattr__ is sufficient (especially if you throw an exception) to warn whoever is playing with the code that the goal for the State is to be read only. If someone still feels the need to modify the state then whatever undefined behavior they encounter isn't my fault.

Answer 2

Python is a very open language and does not contain a final keyword. Python gives you more freedom to do things and assumes you know who things should work. Therefore, it is assumed that people using your code will know that SOME_CONSTANT should not be assigned a value at some random point in the code.

If you really do want to, you can enclose the constant inside a getter function.

def getConstant()
  return "SOME_VALUE"

Answer 3

Activestate has a recipe titled Constants in Python by Martelli for creating a const module with attributes which cannot be rebound after creation. That sounds like what you're looking for except for the upcasing -- but I suspect that could be added by making it check to see whether the attribute name was all uppercase or not.

Of course, this can be circumvented by the determined, but that's the way Python is -- and it's considered to be a "good-thing" by most of us. To make it harder though, I suggest you do not add the so-called obvious __delattr__ method because people could then just delete names and then add them back rebound to different values.

So here's what I'm taking about:

# from http://code.activestate.com/recipes/65207-constants-in-python
class _const:
    class ConstError(TypeError): pass
    class ConstCaseError(ConstError): pass

    def __setattr__(self, name, value):
        if self.__dict__.has_key(name):
            raise self.ConstError, "Can't change const.%s" % name
        if not name.isupper():
            raise self.ConstCaseError, 'const name "%s" is not all uppercase' % name
        self.__dict__[name] = value

import sys
sys.modules[__name__] = _const()

if __name__ == '__main__':
    import const

    try:
        const.Answer = 42
    except const.ConstCaseError, exc:
        print exc
    else:
        raise Exception, "Non-uppercase only const name shouldn't be allowed!"

    const.ANSWER = 42 # OK, all uppercase
    try:
        const.ANSWER = 17
    except const.ConstError, exc:
        print exc
    else:
        raise Exception, "Shouldn't be able to change const!"