Home/ Questions/Q 8555445
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-06-11T15:07:28+00:00

In python, I can alter the state of an instance by directly assigning to

  • 0

In python, I can alter the state of an instance by directly assigning to attributes, or by making method calls which alter the state of the attributes:

foo.thing = 'baz'

or:

foo.thing('baz')

Is there a nice way to create a class which would accept both of the above forms which scales to large numbers of attributes that behave this way? (Shortly, I’ll show an example of an implementation that I don’t particularly like.) If you’re thinking that this is a stupid API, let me know, but perhaps a more concrete example is in order. Say I have a Document class. Document could have an attribute title. However, title may want to have some state as well (font,fontsize,justification,…), but the average user might be happy enough just setting the title to a string and being done with it …

One way to accomplish this would be to:

class Title(object):
     def __init__(self,text,font='times',size=12):
         self.text = text
         self.font = font
         self.size = size
     def __call__(self,*text,**kwargs):
         if(text):
             self.text = text[0]
         for k,v in kwargs.items():
             setattr(self,k,v)
     def __str__(self):
         return '<title font={font}, size={size}>{text}</title>'.format(text=self.text,size=self.size,font=self.font)

class Document(object):
     _special_attr = set(['title'])
     def __setattr__(self,k,v):
         if k in self._special_attr and hasattr(self,k):
             getattr(self,k)(v)
         else:
             object.__setattr__(self,k,v)

     def __init__(self,text="",title=""):
         self.title = Title(title)
         self.text = text

     def __str__(self):
         return str(self.title)+'<body>'+self.text+'</body>'

Now I can use this as follows:

doc = Document()
doc.title = "Hello World"
print (str(doc))
doc.title("Goodbye World",font="Helvetica")
print (str(doc))

This implementation seems a little messy though (with __special_attr). Maybe that’s because this is a messed up API. I’m not sure. Is there a better way to do this? Or did I leave the beaten path a little too far on this one?

I realize I could use @property for this as well, but that wouldn’t scale well at all if I had more than just one attribute which is to behave this way — I’d need to write a getter and setter for each, yuck.

Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. Editorial Team

    It is a bit harder than the previous answers assume.

    Any value stored in the descriptor will be shared between all instances, so it is not the right place to store per-instance data.
    Also, obj.attrib(...) is performed in two steps:

    tmp = obj.attrib
tmp(...)

    Python doesn’t know in advance that the second step will follow, so you always have to return something that is callable and has a reference to its parent object.

    In the following example that reference is implied in the set argument:

    class CallableString(str):
    def __new__(class_, set, value):
        inst = str.__new__(class_, value)
        inst._set = set
        return inst
    def __call__(self, value):
        self._set(value)

class A(object):
    def __init__(self):
        self._attrib = "foo"
    def get_attrib(self):
        return CallableString(self.set_attrib, self._attrib)
    def set_attrib(self, value):
        try:
            value = value._value
        except AttributeError:
            pass
        self._attrib = value
    attrib = property(get_attrib, set_attrib)

a = A()
print a.attrib
a.attrib = "bar"
print a.attrib
a.attrib("baz")
print a.attrib

    In short: what you want cannot be done transparently. You’ll write better Python code if you don’t insist hacking around this limitation

    • 0