¿Puedo evitar la modificación de un objeto en Python?

Question

Quiero controlar las variables globales (o las variables de ámbito global) de forma que se establezcan solo una vez en el código de inicialización del programa, y ​​bloquearlas después de eso.

Uso UPPER_CASE_VARIABLES para variables globales, pero quiero tener una manera segura de no cambiar la variable de todos modos.

• ¿Python proporciona esa característica (o similar)?
• ¿Cómo se controlan las variables con ámbito global?

Answer 1

Activestate tiene una receta titulado Constants in Python por el venerable Alex Martelli para la creación de un módulo de const con atributos que no pueden recuperarse después de la creación. Eso suena como lo que estás buscando, excepto por el upsideing —, pero eso podría agregarse haciendo que verifique si el nombre del atributo estaba en mayúsculas o no.

Por supuesto, esto se puede eludir por el determinado, pero esa es la forma en que Python es — y es considerado como un "bien" por la mayoría de la gente. Sin embargo, para hacerlo un poco más difícil, le sugiero que no se moleste en agregar el método supuestamente obvio __delattr__, ya que las personas podrían simplemente eliminar nombres y luego volver a agregarlos a diferentes valores.

Esto es lo que estoy tomando sobre: ​​

# 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 module so it's not deleted -- 
# see Stack Overflow question: http://bit.ly/ff94g6) 
import sys 
_ref, sys.modules[__name__] = sys.modules[__name__], _const() 

if __name__ == '__main__': 
    import const # test this module... 

    try: 
     const.Answer = 42 # not OK, 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 have been allowed!") 

    const.ANSWER = 42 # should be OK, all uppercase 

    try: 
     const.ANSWER = 17 # not OK, attempts to change defined constant 
    except const.ConstError as exc: 
     print(exc) 
    else: # test failed - no ConstError exception generated 
     raise RuntimeError("Shouldn't have been able to change const attribute!") 

Salida:

const name 'Answer' is not all uppercase 
Can't change const.ANSWER 

Answer 2

Puede envolver sus variables globales en un objeto y anular el objeto .__ método setattr__. Luego puede evitar la configuración de atributos que ya están configurados. Sin embargo, esto no se trata de objetos complejos que se pasan por referencia. Tendría que hacer copias superficiales/profundas de esos objetos para estar absolutamente seguro de que no se pueden modificar. Si está utilizando nuevas clases de estilo, puede anular el objeto .__ getattribute __ (self, name) para hacer las copias.

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

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

** Normalmente no me preocupo tanto si alguien va a intentar realmente romper mi código. Considero que anular __setattr__ es suficiente (especialmente si arrojas una excepción) para advertir a quien esté jugando con el código que el objetivo para el Estado es solo leer. Si alguien todavía siente la necesidad de modificar el estado, cualquier comportamiento indefinido que encuentre no es mi culpa.

Answer 3

Python es un lenguaje muy abierto y no contiene una palabra clave final. Python te da más libertad para hacer cosas y supone que sabes cómo deberían funcionar las cosas. Por lo tanto, se supone que las personas que usan su código sabrán que al SOME_CONSTANT no se le debe asignar un valor en algún punto al azar en el código.

Si realmente desea, puede encerrar la constante dentro de una función getter.

def getConstant() 
    return "SOME_VALUE"