@property speed overhead in Python

Question

I'm trying to understand the utility of the @property decorator in Python. Specifically, I set up a class using properties like so:

class A(object):
    def __init__(self, x):
        self._x = x

    @property
    def x(self):
        return self._x

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

And I also set up a class without properties providing the same functionality:

class B(object):
    def __init__(self, x):
        self._x = x

I create an instance of each:

a = A(10)
b = B(10)

Running %timeit in iPython yields the following results

%timeit a.x
%timeit b._x

1000000 loops, best of 3: 213 ns per loop

10000000 loops, best of 3: 67.9 ns per loop

%timeit a.x = 15
%timeit b._x = 15

1000000 loops, best of 3: 257 ns per loop

10000000 loops, best of 3: 89.7 ns per loop

Clearly, the @property and @setter decorators are inferior if you're going to be talking to the object with significant frequency. My question is, simply, why use it? I would be interested to hear any use-cases for these decorators that people may have. Thanks.

All the advantages of using properties are discussed in [this old question](http://stackoverflow.com/q/6618002/2647279). This comes at a price of some small loss in speed, as you discovered. — Bas Swinckels, Jan 16 '14 at 22:57
Measuring "inferior" by the fact that something costs an extra few dozen nanoseconds, without considering usability or flexibility or anything else, is silly. It's very rare that you need to micro-optimize attribute access. On the rare occasions when accessing an unchanging attribute _is_ a bottleneck, you usually want copy it to a local variable, and access _that_ inside the loop, so it still doesn't matter how fast the attribute access is. If you're writing code where this really matters, you probably shouldn't be writing it in Python. — abarnert, Jan 16 '14 at 23:20

score 6 · Answer 1 · answered Jan 16 '14 at 22:59

The simple answer is you don't use propertys for basic attributes. They are useful for attributes that require additional logic when stored or retrieved. For example, attributes with values derived from other attributes or attributes that need error checking or other specialized filtering. Using propertys lets you use the common setter/getter pattern common in other languages in an ala carte, drop in fashion instead of forcing verbose boilerplate.

score 2 · Answer 2 · answered Jan 16 '14 at 23:01

If the attribute is so simple, don't use property. You don't need it. property is there for cases when getting and setting an attribute needs to do more, for example, if there's a computation involved:

@property
def area(self):
    return math.pi * self.radius**2

They're particularly useful for when something that used to be a simple __dict__ lookup suddenly needs to perform extra work. You can switch to a property without needing to add method call parentheses at every call site.

@property speed overhead in Python

2 Answers2