Python - multiple @property statements in class definition?

Question

Getting up to speed on learning classes. I have been reading that the constructor (def init in Python) should only set assigned variables, that calculated instance attributes should be set via a property. Also, that using @property is preferred to a Java-style getter/setter.

OK, but every example I have ever seen on this sets only one property. Let's say I have an object with three complicated attributes that need to be calculated, queried etc. How do you represent multiple @property getters, setters, deleters? Here is an example from another post:

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

So if I had three instance variables that were calculated values based on some other attributes, would it look like this

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

    @property
    def y(self):
        """I'm the 'y' property."""
        return self._y

    @y.setter
    def y(self, value):
        self._y = value

    @y.deleter
    def y(self):
        del self._y

    @property
    def z(self):
        """I'm the 'z' property."""
        return self._z

    @z.setter
    def z(self, value):
        self._z = value

    @z.deleter
    def z(self):
        del self._z

Or is that fact that I only ever see one @property statement mean that having a class with more than one @property is a bad idea?

Martijn Pieters · Accepted Answer · 2014-02-20T20:31:11.587

No, you can use multiple @property decorators to your heart's content. There is no limit here, other than that of example writers imaginations, apparently.

The Python standard library is full of @property use if you want examples:

numbers defines ABCs for the numbers classes in Python.
tempfile implements temporary file objects
threading provding higher-level thread support
urlparse for handling URLs and query strings.

etc.

You had it spot on; multiple properties would look exactly like what you posted.

Luis Masuelli · Answer 2 · 2014-02-21T13:49:11.537

3

it's not a bad idea. it's a regular property pattern.

another pattern is doing like:

class A(object):

    def _get_a(self):
        return self._a

    def _set_a(self, v)
        self._a = v

    def _del_a(self)
        del self._a

    a = property(_get_a, _set_a, _del_a)

the result is the same that in the first example, and you can use it as much as you wish. initializing self._a in the constructor is a good idea, since otherwise, accesing it BEFORE by calling self.a would raise AttributeError

edited Feb 21 '14 at 13:49

answered Feb 20 '14 at 20:19

Luis Masuelli

12,079
10
49
87

Consider using just `myObj.foo` or `myObj.foo()` over `myObj.set_foo()`. People differ on this but there's consensus that the get_ is not generally helpful and just makes stuff look like Java. – a p Feb 20 '14 at 20:35
Thanks I didn't think about initializing. So I would just say something like def __init__(self, a=None): self.a = a? – Alan S Feb 20 '14 at 20:39
yes, that would be the same, and more encapsulated. – Luis Masuelli Feb 21 '14 at 13:48
@ap i fixed my code (prepended underscore to deleter and setter). see that the methods are protected, and the only purpose for them is to be used as arguments to property() constructor, so they are not meant to be accesses publicly, and they are just an example to illustrate. I prefer the property-decorator pattern for getter, setter, and deleter. – Luis Masuelli Feb 21 '14 at 13:52
Upvoted for showing the more concise form of decorating a set of property accessors. Sometimes less vertical code improves readability, especially if you have one-line accessors like this that could be arranged as blocks of 4 lines plus a leading comment. – Rakurai Apr 25 '19 at 16:01

score 2 · Answer 3 · answered Oct 11 '19 at 15:31

To bounce on another answer,

there is no shortcut to the somewhat ugly looking pattern

Not in python stdlib indeed, but there is now a library named pyfields to do this in a more concise way, without sacrificing speed when you do not need validators not converters.

from pyfields import field, init_fields

class C(object):
    x = field(default=None, doc="the optional 'x' property")
    y = field(doc="the mandatory 'y' property")
    z = field(doc="the mandatory 'z' property")

    @init_fields
    def __init__(self):
        pass

c = C(y=1, z=2)
print(vars(c))

yields

{'z': 2, 'y': 1, 'x': None}

I'm the author of this lib, I wrote it because none of the existing alternatives were satisfying to me.

See documentation for details - Do not hesitate to provide feedback !

score 0 · Answer 4 · answered Feb 20 '14 at 20:20

It may be ugly, but that is the way it works. In general, the pythonic recommendation is not to create simple setter/getters that directly access the native variable (unless you know the interface is likely to change). Assuming that the reason for the properties is 'complex calculations' as you said, there is no shortcut to the somewhat ugly looking pattern. See this link http://tomayko.com/writings/getters-setters-fuxors

score 0 · Answer 5 · answered Jun 16 '18 at 09:05

yes it does but @property decorator make it more neat and tidy to define multiple property in a class. Property is Different with attribute. The reason property used in encapsulation because python don't have built-in access modifier. In fact, when we call @property decorator above a method we instantiate a property object. Property object is an object have get,set, and del method. Property can be defined in a class without the need to define it in init. init method invoked when an object instantiated. If the private attribute need to set when the object created define it in init but when we don't need initial value we have no need to define the attributes. Here's the example of property without attribute.

class C(object):
#X Property
@property
def x(self):
    """I'm the 'x' property."""
    print('Get The X Property')
    return self._x

@x.setter
def x(self, value):
    print('X Property Setted to {}'.format(value))
    self._x = value

@x.deleter
def x(self):
    print('X is Killed !')
    del self._x

#Y Property
@property
def y(self):
    """I'm the 'y' property."""
    print('Get The Y Property')
    return self._y

@y.setter
def y(self, value):
    print('Y Property Setted to {} '.format(value))
    self._y = value

@y.deleter
def y(self):
    print('Y is Killed !')
    del self._y

When we need to define x and y as an attribute to the class C. Just set the the attribute in init. so, x and y listed as class C attribute and have initial value setted when the object instantiated.

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

#X Property
@property
def x(self):
    """I'm the 'x' property."""
    print('Get The X Property')
    return self._x

@x.setter
def x(self, value):
    print('X Property Setted to {}'.format(value))
    self._x = value

@x.deleter
def x(self):
    print('X is Killed !')
    del self._x

#Y Property
@property
def y(self):
    """I'm the 'y' property."""
    print('Get The Y Property')
    return self._y

@y.setter
def y(self, value):
    print('Y Property Setted to {} '.format(value))
    self._y = value

@y.deleter
def y(self):
    print('Y is Killed !')
    del self._y

The Difference is simple. Without any initial value the class C have no x and y attributes. so, if we trying to get the attribute an exception will raised. With initial value the class C already have X and Y attribute from the beginning.

Python - multiple @property statements in class definition?

5 Answers5