Python read-only property

Question

I don t know when attribute should be private and if I should use property   I read recently that setters and getters are not pythonic and I should use property decorator  It s ok    But what if I have attribute  that mustn t be set from outside of class but can be read  read-only attribute   Should this attribute be private  and by private I mean with underscore  like that self  x  If yes then how can I read it without using getter  Only method I know right now is to write   property def x self       return self  x   That way I can read attribute by obj x but I can t set it obj x   1 so it s fine   But should I really care about setting object that mustn t be set  Maybe I should just leave it  But then again I can t use underscore because reading obj  x is odd for user  so I should use obj x and then again user doesn t know that he mustn t set this attribute   What s your opinion and practics

User · Answer

Here is a way to avoid the assumption that

all users are consenting adults, and thus are responsible for using things correctly themselves.

please see my update below

Using @property, is very verbose e.g.:

   class AClassWithManyAttributes:
        '''refactored to properties'''
        def __init__(a, b, c, d, e ...)
             self._a = a
             self._b = b
             self._c = c
             self.d = d
             self.e = e

        @property
        def a(self):
            return self._a
        @property
        def b(self):
            return self._b
        @property
        def c(self):
            return self._c
        # you get this ... it's long

Using

No underscore: it's a public variable.
One underscore: it's a protected variable.
Two underscores: it's a private variable.

Except the last one, it's a convention. You can still, if you really try hard, access variables with double underscore.

So what do we do? Do we give up on having read only properties in Python?

Behold! read_only_properties decorator to the rescue!

@read_only_properties('readonly', 'forbidden')
class MyClass(object):
    def __init__(self, a, b, c):
        self.readonly = a
        self.forbidden = b
        self.ok = c

m = MyClass(1, 2, 3)
m.ok = 4
# we can re-assign a value to m.ok
# read only access to m.readonly is OK 
print(m.ok, m.readonly) 
print("This worked...")
# this will explode, and raise AttributeError
m.forbidden = 4

You ask:

Where is read_only_properties coming from?

Glad you asked, here is the source for read_only_properties:

def read_only_properties(*attrs):

    def class_rebuilder(cls):
        "The class decorator"

        class NewClass(cls):
            "This is the overwritten class"
            def __setattr__(self, name, value):
                if name not in attrs:
                    pass
                elif name not in self.__dict__:
                    pass
                else:
                    raise AttributeError("Can't modify {}".format(name))

                super().__setattr__(name, value)
        return NewClass
    return class_rebuilder

update

I never expected this answer will get so much attention. Surprisingly it does. This encouraged me to create a package you can use.

$ pip install read-only-properties

in your python shell:

In [1]: from rop import read_only_properties

In [2]: @read_only_properties('a')
   ...: class Foo:
   ...:     def __init__(self, a, b):
   ...:         self.a = a
   ...:         self.b = b
   ...:         

In [3]: f=Foo('explodes', 'ok-to-overwrite')

In [4]: f.b = 5

In [5]: f.a = 'boom'
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-5-a5226072b3b4> in <module>()
----> 1 f.a = 'boom'

/home/oznt/.virtualenvs/tracker/lib/python3.5/site-packages/rop.py in __setattr__(self, name, value)
    116                     pass
    117                 else:
--> 118                     raise AttributeError("Can't touch {}".format(name))
    119 
    120                 super().__setattr__(name, value)

AttributeError: Can't touch a

User · Answer

That s my workaround    property def language self       return self  language  language setter def language self  value         WORKAROUND to get a  getter-only  behavior       set the value only if the attribute does not exist     try          if self language    value              pass         print  WARNING  Cannot set attribute   language          except AttributeError          self  language   value

User · Answer

Notice that instance methods are also attributes  of the class  and that you could set them at the class or instance level if you really wanted to be a badass  Or that you may set a class variable  which is also an attribute of the class   where handy readonly properties won t work neatly out of the box  What I m trying to say is that the  readonly attribute  problem is in fact more general than it s usually perceived to be  Fortunately there are conventional expectations at work that are so strong as to blind us wrt these other cases  after all  almost everything is an attribute of some sort in python    Building upon these expectations I think the most general and lightweight approach is to adopt the convention that  public   no leading underscore  attributes are readonly except when explicitly documented as writeable  This subsumes the usual expectation that methods won t be patched and class variables indicating instance defaults are better let alone  If you feel really paranoid about some special attribute  use a readonly descriptor as a last resource measure

User · Answer

Just my two cents  Silas Ray is on the right track  however I felt like adding an example   -   Python is a type-unsafe language and thus you ll always have to trust the users of your code to use the code like a reasonable  sensible  person   Per PEP 8      Use one leading underscore only for non-public methods and instance variables    To have a  read-only  property in a class you can make use of the  property decoration  you ll need to inherit from object when you do so to make use of the new-style classes   Example    gt  gt  gt  class A object           def   init   self  a               self  a   a              property         def a self               return self  a       gt  gt  gt  a   A  test    gt  gt  gt  a a  test   gt  gt  gt  a a    pleh  Traceback  most recent call last     File   lt stdin gt    line 1  in  lt module gt  AttributeError  can t set attribute

User · Answer

I know i m bringing back from the dead this thread  but I was looking at how to make a property read only and after finding this topic  I wasn t satisfied with the solutions already shared   So  going back to the initial question  if you start with this code    property def x self       return self  x   And you want to make X readonly  you can just add    x setter def x self  value       raise Exception  Member readonly     Then  if you run the following   print  x    Will print whatever X value is x   3   Will raise exception  Member readonly

User · Answer

While I like the class decorator from Oz123  you could also do the following  which uses an explicit class wrapper and    new   with a class Factory method returning the class within a closure   class B object       def   new   cls  val           return cls factory val    classmethod def factory cls  val       private     var    test        class InnerB object           def   init   self               self variable   val             pass           property         def var self               return private  var        return InnerB

User · Answer

someone mentioned using a proxy object  I didn t see an example of that so I ended up trying it out   poorly       Please prefer class definitions and class constructors if possible this code is effectively re-writing class   new    class constructor  except worse in every way  Save yourself the pain and do not use this pattern if you can  def attr proxy obj        quot  quot  quot  Use dynamic class definition to bind obj and proxy attrs          If you can extend the target class constructor that is          cleaner  but its not always trivial to do so       quot  quot  quot      proxy attrs   dict        class MyObjAttrProxy            def   getattr   self  name               if name in proxy attrs                  return proxy attrs name     overloaded              return getattr obj  name     proxy          def   setattr   self  name  value                quot  quot  quot  note  self is not bound when overloading methods              quot  quot  quot              proxy attrs name    value      return MyObjAttrProxy     myobj   attr proxy Object    setattr myobj   foo str    foo    def func bind obj as self func  self       def  method  args    kwargs           return func self   args    kwargs      return  method  def mymethod self  foo ct        quot  quot  quot  self is not bound because we aren t using object   new           you can write the   setattr   method to bind a self          argument  or declare your functions dynamically to bind in          a static object reference       quot  quot  quot      return self foo str   foo ct  setattr myobj   foo   func bind obj as self mymethod  myobj

User · Answer

I am dissatisfied with the previous two answers to create read only properties because the first solution allows the readonly attribute to be deleted and then set and doesn t block the   dict    The second solution could be worked around with testing - finding the value that equals what you set it two and changing it eventually  Now  for the code  def final cls       clss   cls      classmethod     def   init subclass   cls    kwargs           raise TypeError  quot type      is not an acceptable base type quot  format clss   name         cls   init subclass       init subclass       return cls   def methoddefiner cls  method name       for clss in cls mro            try              getattr clss  method name              return clss         except AttributeError               pass     return None                           def readonlyattributes  attrs        quot  quot  quot Method to create readonly attributes in a class          Use as a decorator for a class  This function takes in unlimited      string arguments for names of readonly attributes and returns a     function to make the readonly attributes readonly            The original class s   getattribute      setattr    and   delattr   methods     are redefined so avoid defining those methods in the decorated class          You may create setters and deleters for readonly attributes  however     if they are overwritten by the subclass  they lose access to the readonly     attributes            Any method which sets or deletes a readonly attribute within     the class loses access if overwritten by the subclass besides the   new       or   init   constructors           This decorator doesn t support subclassing of these classes      quot  quot  quot      def classrebuilder cls           def   getattribute   self  name               if name       dict                         from types import MappingProxyType                     return MappingProxyType super cls  self    getattribute      dict                  return super cls  self    getattribute   name          def   setattr   self  name  value                    if name       dict    or name in attrs                      import inspect                     stack   inspect stack                       try                          the class   stack 1  0  f locals  self     class                       except KeyError                           the class   None                     the method   stack 1  0  f code co name                     if the class    cls                            if methoddefiner type self   the method     cls                              raise AttributeError  quot Cannot set readonly attribute      quot  format name                                           return super cls  self    setattr   name  value          def   delattr   self  name                                   if name       dict    or name in attrs                      import inspect                     stack   inspect stack                       try                          the class   stack 1  0  f locals  self     class                       except KeyError                           the class   None                     the method   stack 1  0  f code co name                     if the class    cls                          if methoddefiner type self   the method     cls                              raise AttributeError  quot Cannot delete readonly attribute      quot  format name                                           return super cls  self    delattr   name          clss   cls         cls   getattribute       getattribute           cls   setattr       setattr           cls   delattr       delattr            This line will be moved when this algorithm will be compatible with inheritance         cls   final cls          return cls     return classrebuilder  def setreadonlyattributes cls   readonlyattrs       return readonlyattributes  readonlyattrs  cls    if   name         main          test readonlyattributes only as an indpendent module      readonlyattributes  readonlyfield       class ReadonlyFieldClass object           def   init   self  a  b                Prevent initalization of the internal  unmodified PrivateFieldClass              External PrivateFieldClass can be initalized             self readonlyfield   a             self publicfield   b                   attr   None     def main            global attr         pfi   ReadonlyFieldClass  forbidden    changable              ---test publicfield  ensure its mutable---            try               get publicfield             print pfi publicfield              print    getattribute   works                set publicfield             pfi publicfield    mutable              print    setattr   seems to work                get previously set publicfield             print pfi publicfield              print    setattr   definitely works                delete publicfield             del pfi publicfield              print    delattr   seems to work                get publicfield which was supposed to be deleted therefore should raise AttributeError             print pfi publlicfield               publicfield wasn t deleted  raise RuntimeError             raise RuntimeError    delattr   doesn  t work           except AttributeError               print    delattr   works                             try                 ---test readonly  make sure its readonly---                 get readonlyfield             print pfi readonlyfield              print    getattribute   works                set readonlyfield  should raise AttributeError             pfi readonlyfield    readonly               apparently readonlyfield was set  notify user             raise RuntimeError    setattr   doesn  t work           except AttributeError               print    setattr   seems to work               try                   ensure readonlyfield wasn t set                 print pfi readonlyfield                  print    setattr   works                    delete readonlyfield                 del pfi readonlyfield                  readonlyfield was deleted  raise RuntimeError                 raise RuntimeError    delattr   doesn  t work               except AttributeError                   print    delattr   works           try              print  quot Dict testing quot               print pfi   dict    type pfi   dict                 attr   pfi readonlyfield             print attr              print  quot   getattribute   works quot               if pfi readonlyfield     forbidden                   print pfi readonlyfield                  raise RuntimeError  quot   getattr   doesn t work quot               try                  pfi   dict                        raise RuntimeError  quot   setattr   doesn t work quot               except AttributeError                   print  quot   setattr   works quot               del pfi   dict               raise RuntimeError  quot   delattr   doesn t work quot           except AttributeError               print pfi   dict                print  quot   delattr   works quot               print  quot Basic things work quot     main             There is no point to making read only attributes except when your writing  library code  code which is being distributed to others as code to use in order to enhance their programs  not code for any other purpose  like app development  The   dict   problem is solved  because the   dict   is now of the immutable types MappingProxyType  so attributes cannot be changed through the   dict    Setting or deleting   dict   is also blocked  The only way to change read only properties is through changing the methods of the class itself  Though I believe my solution is better than of the previous two  it could be improved  These are this code s weaknesses   Doesn t allow adding to a method in a subclass which sets or deletes a readonly attribute  A method defined in a subclass is automatically barred from accessing a readonly attribute  even by calling the superclass  version of the method   The class  readonly methods can be changed to defeat the read only restrictions    However  there is not way without editing the class to set or delete a read only attribute  This isn t dependent on naming conventions  which is good because Python isn t so consistent with naming conventions  This provides a way to make read only attributes that cannot be changed with hidden loopholes without editing the class itself  Simply list the attributes to be read only when calling the decorator as arguments and they will become read only  Credit to Brice s answer for getting the caller classes and methods

User · Answer

Generally  Python programs should be written with the assumption that all users are consenting adults  and thus are responsible for using things correctly themselves   However  in the rare instance where it just does not make sense for an attribute to be settable  such as a derived value  or a value read from some static datasource   the getter-only property is generally the preferred pattern

User · Answer

Here is a slightly different approach to read-only properties  which perhaps should be called write-once properties since they do have to get initialized  don t they  For the paranoid among us who worry about being able to modify properties by accessing the object s dictionary directly  I ve introduced  quot extreme quot  name mangling  from uuid import uuid4  class ReadOnlyProperty      def   init   self  name           self name   name         self dict name   uuid4   hex         self initialized   False      def   get   self  instance  cls           if instance is None              return self         else              return instance   dict   self dict name       def   set   self  instance  value           if self initialized              raise AttributeError  quot Attempt to modify read-only property   s   quot    self name          instance   dict   self dict name    value         self initialized   True  class Point      x   ReadOnlyProperty  x       y   ReadOnlyProperty  y       def   init   self  x  y           self x   x         self y   y  if   name         main         try          p   Point 2  3          print p x  p y          p x   9     except Exception as e          print e

[python] Python read-only property

please see my update below

So what do we do? Do we give up on having read only properties in Python?

update

Examples related to python

Examples related to properties

Examples related to python-2.7

Examples related to private

Examples related to readonly