Posso impedire la modifica di un oggetto in Python?

Question

Voglio controllare le variabili globali (o le variabili globali) in modo che vengano impostate una sola volta nel codice di inizializzazione del programma e bloccarle successivamente.

Io uso UPPER_CASE_VARIABLES per le variabili globali, ma voglio avere un modo sicuro di non modificare la variabile comunque.

• Python fornisce questa funzionalità (o simile)?
• Come si controllano le variabili con ambito globale?

Answer 1

ActiveState ha una ricetta intitolata Constants in Python dal venerabile Alex Martelli per la creazione di un modulo const con gli attributi che non possono essere rimbalzo dopo la creazione. Sembra che quello che stai cercando eccetto per l'aggiornamento — ma che potrebbe essere aggiunto facendolo controllare per vedere se il nome dell'attributo era tutto in maiuscolo o meno.

Naturalmente, questo può essere aggirato dal determinato, ma questo è il modo in cui Python è — ed è considerato una "cosa buona" dalla maggior parte della gente. Tuttavia, per renderlo un po 'più difficile, ti suggerisco di non preoccuparti di aggiungere il metodo apparentemente ovvio __delattr__ poiché le persone potrebbero semplicemente cancellare i nomi e quindi aggiungerli nuovamente a valori diversi.

Questo è quello che sto prendendo circa:

# 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!") 

uscita:

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

Answer 2

È possibile racchiudere le variabili globali in un oggetto e sovrascrivere il metodo oggetto .__ setattr__. È quindi possibile impedire l'impostazione degli attributi già impostati. Tuttavia, questo non riguarda oggetti complessi che vengono passati per riferimento. Dovresti fare copie poco profonde/profonde di quegli oggetti per essere assolutamente sicuro che non possano essere modificati. Se si utilizzano nuove classi di stile, è possibile sovrascrivere l'oggetto .__ getattribute __ (self, name) per creare le copie.

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

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

** Io di solito non mi preoccupo tanto se qualcuno sta per provare davvero difficile da rompere il mio codice. Trovo che __setattr__ sia sufficiente (specialmente se si lancia un'eccezione) per avvisare chi sta giocando con il codice che l'obiettivo per lo stato deve essere letto solo. Se qualcuno sente ancora il bisogno di modificare lo stato, qualsiasi comportamento non definito che incontrano non è colpa mia.

Answer 3

Python è una lingua molto aperta e non contiene una parola chiave final. Python ti dà più libertà di fare cose e presuppone che tu sappia come dovrebbero funzionare le cose. Pertanto, si presume che chi usa il tuo codice saprà che a SOME_CONSTANT non dovrebbe essere assegnato un valore in un punto casuale del codice.

Se lo si desidera, è possibile racchiudere la costante all'interno di una funzione getter.

def getConstant() 
    return "SOME_VALUE"