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.
ActiveState has a recipe titled Cᴏɴsᴛᴀɴᴛs ɪɴ Pʏᴛʜᴏɴ by the venerable Alex 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 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 is considered to be a "good thing" by most folks. However, to make it a little more difficult, I suggest you don't bother adding the supposedly obvious __delattr__ method since people could then just delete names and then add them back rebound to different values.
This is what I'm taking about:
Put in const.py:
# from http://code.activestate.com/recipes/65207-constants-in-python
class _const:
class ConstError(TypeError): pass # Base exception class.
class ConstCaseError(ConstError): pass
def __setattr__(self, name, value):
if name in self.__dict__:
raise self.ConstError("Can't change const.%s" % name)
if not name.isupper():
raise self.ConstCaseError('const name %r is not all uppercase' % name)
self.__dict__[name] = value
# Replace module entry in sys.modules[__name__] with instance of _const
# (and create additional reference to it to prevent its deletion -- see
# https://mcmap.net/q/20824/-why-is-the-value-of-__name__-changing-after-assignment-to-sys-modules-__name__)
import sys
_ref, sys.modules[__name__] = sys.modules[__name__], _const()
if __name__ == '__main__':
import __main__ as const # Test this module...
try:
const.Answer = 42 # Not OK to create mixed-case attribute name.
except const.ConstCaseError as exc:
print(exc)
else: # Test failed - no ConstCaseError exception generated.
raise RuntimeError("Mixed-case const names should't be allowed!")
try:
const.ANSWER = 42 # Should be OK, all uppercase.
except Exception as exc:
raise RuntimeError("Defining a valid const attribute should be allowed!")
else: # Test succeeded - no exception generated.
print('const.ANSWER set to %d raised no exception' % const.ANSWER)
try:
const.ANSWER = 17 # Not OK, attempt to change defined constant.
except const.ConstError as exc:
print(exc)
else: # Test failed - no ConstError exception generated.
raise RuntimeError("Shouldn't be able to change const attribute!")
Output:
const name 'Answer' is not all uppercase
const.ANSWER set to 42 raised no exception
Can't change const.ANSWER
object.__setattr__(const,'this_is_not_a_costant',88).will work to set an invalid constant or redefine a constant. A similar trick is also available using __class__ modification, which can be implemented without using object.__setattr__ (class o(object):pass followed by object.__dict__['__class__'].__set__(const, o)), after which one can set attributes like an ordinary class. –
Robber 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 how 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"
getConstant = lambda: new_value. And since ALL_CAPS is the convention for should-be constants, you should just stick to that. –
Marlyn 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.
© 2022 - 2024 — McMap. All rights reserved.
UPPER_CASE =is an error because someone broke the rules. – Born