Minor annoyances with properties

[eb303]

Hello all,

I've been using Python properties quite a lot lately and I've found a
few things that are a bit annoying about them in some cases. I
wondered if I missed something or if anybody else has this kind of
problems too, and if there are better solutions than the ones I'm
using ATM.

The first annoyance is when I want to specialize a property in a
subclass. This happens quite often actually, and it is even sometimes
the reason why a plain attribute is turned into a property: a subclass
needs to do more things than the superclass when the property is
updated for example. So, of course, my first try was:

class A(object):
def __init__(self):
self._p = None
def _get_p(self):
return self._p
def _set_p(self, p):
self._p = p
p = property(_get_p, _set_p)
class B(A):
def _set_p(self, p):
## Additional things here…
super(B, self)._set_p(p)

And of course, it doesn't work: the property has been bound to
A._set_p in A, so any new definition of _set_p in any subclass does
not replace the set method for the property. So I always have to add a
line:
p = property(A._get_p, _set_p)
in the subclass too. This is a bit awkward to me, since I have to
specify the superclass's name (super(…) can't be used, since it should
take B as an argument, and B isn't defined yet…). Do I miss something?
Is this the way to do it, or is there a better one?


The second annoyance is when I have a property that is a list of
something. I often have to do something when the contents of the list
is modified. So basically, I often end up doing the following:
def C(object):
def __init__(self):
self._l = []
def _get_l(self):
return list(self._l)
def _set_l(self, l):
self._l = list(l)
l = property(_get_l, _set_l)
But then, I have to do:
o = C()
l = o.l
l.append(42)
o.l = l
instead of just doing:
o.l.append(42)
which would seem much more natural IMHO.

Is there any not too complicated way to have o.l.append(…) call
something in C? And the same for o.l.remove(…), o.l = …, and
everything else updating the list contents?

Thanks!
- Eric -

 

[Neil Cerutti]

I've been using Python properties quite a lot lately and I've
found a few things that are a bit annoying about them in some
cases. I wondered if I missed something or if anybody else has
this kind of problems too, and if there are better solutions
than the ones I'm using ATM.

The first annoyance is when I want to specialize a property in a
subclass.

See:

URI:http://infinitesque.net/articles/2005/enhancing Python's property.xhtml

 

[John Posner]

See:

URI:http://infinitesque.net/articles/2005/enhancing Python's property.xhtml

Very nice idea, but I think this solution works too hard and not quite
correctly. In Python 2.6.5, checking the name of the OProperty object's
"fget" method:

if self.fget.__name__ == '<lambda>' or not self.fget.__name__:

.... doesn't distinguish between the original class's get-the-value
method and the derived class's. (Did something change between 2005-11-02
and now?)

Moreover, you don't *need* to perform this check -- just let *getattr*
do the work of finding the right method. These method defs work fine for me:

def __get__(self, obj, objtype):
if self.fget:
return getattr(obj, self.fget.__name__)()
else:
raise AttributeError, "unreadable attribute"

def __set__(self, obj, value):
if self.fset:
getattr(obj, self.fset.__name__)(value)
else:
raise AttributeError, "can't set attribute"

-John

 

[Francesco Bochicchio]

Hello all,

I've been using Python properties quite a lot lately and I've found a
few things that are a bit annoying about them in some cases. I
wondered if I missed something or if anybody else has this kind of
problems too, and if there are better solutions than the ones I'm
using ATM.

The first annoyance is when I want to specialize a property in a
subclass. This happens quite often actually, and it is even sometimes
the reason why a plain attribute is turned into a property: a subclass
needs to do more things than the superclass when the property is
updated for example. So, of course, my first try was:

class A(object):
  def __init__(self):
    self._p = None
  def _get_p(self):
    return self._p
  def _set_p(self, p):
    self._p = p
  p = property(_get_p, _set_p)
class B(A):
  def _set_p(self, p):
    ## Additional things here…
    super(B, self)._set_p(p)

And of course, it doesn't work: the property has been bound to
A._set_p in A, so any new definition of _set_p in any subclass does
not replace the set method for the property. So I always have to add a
line:
p = property(A._get_p, _set_p)
in the subclass too. This is a bit awkward to me, since I have to
specify the superclass's name (super(…) can't be used, since it should
take B as an argument, and B isn't defined yet…). Do I miss something?
Is this the way to do it, or is there a better one?

Don't know if is better, but you could add a level of indirection to
solve it

class A(object):
def __init__(self):
self._p = None
def _get_p(self):
return self._p
def _set_p(self, p):
self._p = p
def _virtual_get_p (self): _get_p(self)
def _virtual_set_p (self,v): _set_p(self, v)
p = property(_virtual_get_p, _virtual_set_p)

At this point, the subclasses of A can reimplement _get_p and _set_p
as they like (I think)

Ciao

 

[eb303]

A better way was introduced in Python 2.6. Seehttp://docs.python.org/library/functions.html?highlight=property#prop...
I have a Python only version around if you are still using Python 2.5.

Christian

Mmmm, I might still miss something. OK, I can replace my initial
property using @property and @p.setter, but it doesn't seem to work in
subclasses:

class A(object):
@property
def p(self):
return self._p
@p.setter
def _set_p(self, p):
self._p = p
class B(A):
@p.setter
def _set_p(self, p):
…

results in:

Traceback (most recent call last):
File "toto.py", line 8, in <module>
class B(A):
File "toto.py", line 9, in B
@p.setter
NameError: name 'p' is not defined

 

[eb303]

Don't know if is better, but you could add a level of indirection to
solve it

 class A(object):
   def __init__(self):
     self._p = None
   def _get_p(self):
     return self._p
   def _set_p(self, p):
     self._p = p
   def _virtual_get_p (self): _get_p(self)
   def _virtual_set_p (self,v): _set_p(self, v)
   p = property(_virtual_get_p, _virtual_set_p)

At this point, the subclasses of A can reimplement _get_p and _set_p
as they like (I think)

Ciao

Well, I've thought about that too and it should work, but that makes 2
function calls instead of one for every property access… I'd really
like to avoid that.

By the way, I think your 'virtual' methods should be written as:
def _virtual_get_p (self): return self._get_p()
def _virtual_set_p (self,v): self._set_p(v)

Thanks anyway.
- Eric -

 

[eb303]

See:

URI:http://infinitesque.net/articles/2005/enhancing Python's proper....

Thanks for the suggestion, but it looks a bit heavy… Performing the
name lookup on the specialized object each time the property is
accessed seems a bit overkill. I'd really just like a simple way to
tell in the subclass: now, the setter methof for property p is this
one, only that…

Thanks again anyway.
- Eric -

 

[eb303]

Am 28.05.2010 11:31, schrieb eb303:








It doesn't work because "p" is not in the scope of B's body while B is
created. You have to write

class B(A):
    # access the "p" property from class A
    @A.p.setter
    def p(self, p):
        pass

    # once p is in the class body scope, you must not use A.p again
    @p.deleter
    def p(self):
        pass

Christian

Well, I still have to explicitely specify the superclass's name then,
so IMHO it's not a big improvement over repeating:
p = property(A._get_p, _set_p)

Thanks anyway…
- Eric -