property() usage - is this as good as it gets?

[David Moss]

Hi,

I want to manage and control access to several important attributes in
a class and override the behaviour of some of them in various
subclasses.

Below is a stripped version of how I've implemented this in my current
bit of work.

It works well enough, but I can't help feeling there a cleaner more
readable way of doing this (with less duplication, etc).

Is this as good as it gets or can this be refined and improved
especially if I was to add in a couple more attributes some fairly
complex over-ride logic?

#!/usr/bin/env python

class A(object):
def __init__(self):
self._x = None
self._y = None

def _set_x(self, value):
self._x = value

def _get_x(self):
return self._x

x = property(_get_x , _set_x)

def _set_y(self, value):
self._y = value

def _get_y(self):
return self._y

y = property(_get_y , _set_y)

class B(A):
def __init__(self):
self._z = None
super(B, self).__init__( )

def _set_x(self, x):
# An example subclass 'set' override.
if x == 10:
raise Exception('%r is invalid!' % x)
self._x = x

x = property(A._get _x, _set_x)

def _set_z(self, value):
self._z = value

def _get_z(self):
return self._z

z = property(_get_z , _set_z)

del A._get_x, A._set_x, A._get_y, A._set_y
del B._set_x, B._get_z, B._set_z

[castironpi]

On Aug 22, 11:18*am, David Moss <drk...@gmail.c omwrote:

Hi,

I want to manage and control access to several important attributes in
a class and override the behaviour of some of them in various
subclasses.

Below is a stripped version of how I've implemented this in my current
bit of work.

It works well enough, but I can't help feeling there a cleaner more
readable way of doing this (with less duplication, etc).

Is this as good as it gets or can this be refined and improved
especially if I was to add in a couple more attributes some fairly
complex over-ride logic?

#!/usr/bin/env python

class A(object):
* * def __init__(self):
* * * * self._x = None
* * * * self._y = None

* * def _set_x(self, value):
* * * * self._x = value

* * def _get_x(self):
* * * * return self._x

* * x = property(_get_x , _set_x)

* * def _set_y(self, value):
* * * * self._y = value

* * def _get_y(self):
* * * * return self._y

* * y = property(_get_y , _set_y)

Within the bounds of Python, that's it.

In the cases where you're not executing code on 'get' or 'set', it
might be possible to have a default getter/setter, that just sets the
value of a variable name. This keeps your interface the same across
inheritance and changes. Possible to have it assign a default value
too.

def _set_z(self, value):
self._z = value

#def _get_z(self):
# return self._z

z = property( True, _set_z ) #still gets self._z

Unless, you are looking at something 'periodic' or regular. From
something I'm working on:

def _getbalance( self ):
return self._tree.geti (
self.where+ self.lookup[ 'balance' ] )

def _getparent( self ):
return self._tree.getI (
self.where+ self.lookup[ 'parent' ] )

Where 'balance' and 'parent' could both come from something generic:

balance= property( tree_lookup( 'balance' ) )
parent= property( tree_lookup( 'parent' ) )

They would have to take care to define 'self' properly and everything.

[Miles]

On Fri, Aug 22, 2008 at 12:18 PM, David Moss <dr****@gmail.c omwrote:

Hi,

I want to manage and control access to several important attributes in
a class and override the behaviour of some of them in various
subclasses.

Below is a stripped version of how I've implemented this in my current
bit of work.

It works well enough, but I can't help feeling there a cleaner more
readable way of doing this (with less duplication, etc).

It could certainly be made more concise, without changing the meaning:

###

from operator import attrgetter
class attrsetter(obje ct):
def __init__(self, attr):
self._attr = attr
def __call__(self, object, value):
setattr(object, self._attr, value)
def defaultproperty (attr):
return property(attrge tter(attr), attrsetter(attr ))

class A(object):
def __init__(self):
self._x = None
self._y = None

x = defaultproperty ('_x')
y = defaultproperty ('_y')

class B(A):
def __init__(self):
super(B, self).__init__( )
self._z = None

def _set_x(self, x):
# An example subclass 'set' override.
if x == 10:
raise Exception('%r is invalid!' % x)
self._x = x

x = property(A.x.fg et, _set_x)
z = defaultproperty ('_z')
# You really don't need to do this, but you can if you want
del _set_x

###

But, given the example you gave, you could also write things this way
(aside from no longer forbidding deleting the properties, which really
shouldn't be necessary):

###

class A(object):
def __init__(self):
self.x = None
self.y = None

class B(A):
def __init__(self):
super(B, self).__init__( )
self._x = self.x
self.z = None

def _set_x(self, x):
# An example subclass 'set' override.
if x == 10:
raise Exception('%r is invalid!' % x)
self._x = x

x = property(attrge tter('_x'), _set_x)

###

It's difficult to know exactly what would work best for you without a
better idea of how your properties override each other.

-Miles

[George Sakkis]

On Aug 22, 12:18 pm, David Moss <drk...@gmail.c omwrote:

Hi,

I want to manage and control access to several important attributes in
a class and override the behaviour of some of them in various
subclasses.

Below is a stripped version of how I've implemented this in my current
bit of work.

It works well enough, but I can't help feeling there a cleaner more
readable way of doing this (with less duplication, etc).

Is this as good as it gets or can this be refined and improved
especially if I was to add in a couple more attributes some fairly
complex over-ride logic?

A small improvement as far as overriding goes is the OProperty recipe:
http://infinitesque.ne t/articles/2005/enhancing%20Pyt hon's%20propert y.xhtml

George

[Christian Heimes]

David Moss wrote:

Hi,

I want to manage and control access to several important attributes in
a class and override the behaviour of some of them in various
subclasses.

Below is a stripped version of how I've implemented this in my current
bit of work.

It works well enough, but I can't help feeling there a cleaner more
readable way of doing this (with less duplication, etc).

Is this as good as it gets or can this be refined and improved
especially if I was to add in a couple more attributes some fairly
complex over-ride logic?

The extended property type in Python 2.6 makes it much easier to
overwrite the getter, sett or deleter of a property:

http://docs.python.org/dev/library/f...perty#property

class C(object):
def __init__(self): self._x = None

@property
def x(self):
"""I'm the 'x' property."""
return self._x

@x.setter
def x(self, value):
self._x = value

@x.deleter
def x(self):
del self._x

class D(C):
@C.x.getter
def x(self):
return 2 * self._x

@x.setter
def x(self, value):
self._x = value // 2

Christian

[Medardo Rodriguez]

On Fri, Aug 22, 2008 at 1:49 PM, Miles <se*********@gm ail.comwrote:

from operator import attrgetter
class attrsetter(obje ct):
def __init__(self, attr):
self._attr = attr
def __call__(self, object, value):
setattr(object, self._attr, value)

This solution is very nice, but in programming is a good practice to be uniform:
The interface of "attrgetter " is "def attrgetter(*nam es): ..."
So, it will be nice the same for attrsetter: "def attrsetter(*nam es):"

I will send an example, but extending it a little bit and also using
some nice python structures of functional programming:

#<code>
from operator import attrgetter

def attrsetter(*nam es):
def closure(obj, *values):
for i in xrange(len(name s)):
setattr(obj, names[i], values[i])
return closure

attrmanager = lambda name: (attrgetter(nam e), attrsetter(name ))
class Test(object):
x = property(*attrm anager('_x'))
y = property(*attrm anager('_y'))

setvalues = attrsetter('x', 'y')
test = Test()

test.x = 1
print 'test.x:', test.x

test.y = 'Merchise'
print 'test.y:', test.y
# Just another test

test.setvalues( 3, 'med')

print 'test.x:', test.x
print 'test.y:', test.y
#</code>

Regards

[castironpi]

On Aug 22, 11:18 am, David Moss <drk...@gmail.c omwrote:

Hi,

I want to manage and control access to several important attributes in
a class and override the behaviour of some of them in various
subclasses.

Below is a stripped version of how I've implemented this in my current
bit of work.

It works well enough, but I can't help feeling there a cleaner more
readable way of doing this (with less duplication, etc).

Is this as good as it gets or can this be refined and improved
especially if I was to add in a couple more attributes some fairly
complex over-ride logic?

#!/usr/bin/env python

class A(object):
def __init__(self):
self._x = None
self._y = None

def _set_x(self, value):
self._x = value

def _get_x(self):
return self._x

x = property(_get_x , _set_x)

def _set_y(self, value):
self._y = value

def _get_y(self):
return self._y

y = property(_get_y , _set_y)

To the OP: you have a unique procedure executed for every attribute of
an instance, for each of set, get, and del. That's a lot of code. If
you don't want unique procedures, what patterns should they follow?
What is wrong with the way you overrode 'get_x' above? When
brainstorming, don't restrict yourself to Python syntax-- make
something up, and we'll write Python.

[alex23]

castironpi <castiro...@gma il.comwrote:

and we'll write Python.

I haven't seen anything you've contributed to this group that would so
far be considered well-written Python.

Confusing and border-line insane, yes. Pythonic? Not at all.

Here's a tip: try actually developing some real-world application in
Python for a while, rather than the god-knows-what-you're-doing
attempts that you keep hijacking various threads with. Your code isn't
anywhere near as clever as you seem to think.

[Raymond Hettinger]

On Aug 22, 1:18*pm, David Moss <drk...@gmail.c omwrote:

It works well enough, but I can't help feeling there a cleaner more
readable way of doing this (with less duplication, etc).

Is this as good as it gets or can this be refined and improved
especially if I was to add in a couple more attributes some fairly
complex over-ride logic?

#!/usr/bin/env python

class A(object):
* * def __init__(self):
* * * * self._x = None
* * * * self._y = None

* * def _set_x(self, value):
* * * * self._x = value

* * def _get_x(self):
* * * * return self._x

* * x = property(_get_x , _set_x)

* * def _set_y(self, value):
* * * * self._y = value

* * def _get_y(self):
* * * * return self._y

* * y = property(_get_y , _set_y)

FWIW, there is a variant of property() that allows you to re-use the
same getter/setter code for multiple attributes:

http://code.activestate.com/recipes/205126/
Raymond Hettinger

[castironpi]

On Aug 24, 5:00*am, alex23 <wuwe...@gmail. comwrote:

castironpi <castiro...@gma il.comwrote:

and we'll write Python.

I haven't seen anything you've contributed to this group that would so
far be considered well-written Python.

Confusing and border-line insane, yes. Pythonic? Not at all.

Here's a tip: try actually developing some real-world application in
Python for a while, rather than the god-knows-what-you're-doing
attempts that you keep hijacking various threads with. Your code isn't
anywhere near as clever as you seem to think.

Python isn't as clever as you think. It's a language. Do you want a
link to clever code? I like to encourage creativity.