Python class variables or @property

Question

I am writing a python class to store data and then another class will create an instance of that class to print different variables. Some class variables require a lot of formatting which may take multiple lines of code to get it in its "final state".

Is it bad practice to just access the variables from outside the class with this structure?

class Data():
    def __init__(self):
        self.data = "data"

Or is it better practice to use an @property method to access variables?

class Data:
    @property
    def data(self):
        return "data"

The whole point of language support for properties is so that you never have to make this decision. You start with normal attributes and use properties when they make sense. — Ignacio Vazquez-Abrams, Jul 01 '17 at 02:45
@IgnacioVazquez-Abrams you have a point there... But it is a little harder to see in python because all the properties can be accessed by default. — developer_hatch, Jul 01 '17 at 03:11
Start out with simple attribute access. Later, if you discover that you need to control access, make it a property, but only then. That is the whole *point*. — juanpa.arrivillaga, Jul 01 '17 at 04:09
Also, you are referring to *instance* variables, not *class variables*. — juanpa.arrivillaga, Jul 01 '17 at 04:16

developer_hatch · Accepted Answer · 2017-07-01T03:09:26.463

Be careful, if you do:

class Data:
    @property
    def data(self):
        return "data"

d = Data()
d.data = "try to modify data"

will give you error:

AttributeError: can't set attribute

And as I see in your question, you want to be able to transform the data until its final state, so, go for the other option

class Data2():
    def __init__(self):
        self.data = "data"

d2 = Data2()
d2.data = "now I can be modified"

or modify the previus:

class Data:
  def __init__(self):
    self._data = "data"

  @property
  def data(self):
      return self._data

  @data.setter
  def data(self, value):
    self._data = value

d = Data()
d.data = "now I can be modified"

Raymond Hettinger · Answer 2 · 2017-07-01T04:23:26.600

Common Practice

The normal practice in Python is to exposure the attributes directly. A property can be added later if additional actions are required when getting or setting.

Most of the modules in the standard library follow this practice. Public variables (not prefixed with an underscore) typically don't use property() unless there is a specific reason (such as making an attribute read-only).

Rationale

Normal attribute access (without property) is simple to implement, simple to understand, and runs very fast.

The possibility of use property() afterwards means that we don't have to practice defensive programming. We can avoid having to prematurely implement getters and setters which bloats the code and makes accesses slower.

Manoj Bisht · Answer 3 · 2017-07-01T04:13:28.990

1

Basically you could hide lot of complexity in the property and make it look like an attribute. This increases code readability.

Also, you need to understand the difference between property and attribute. Please refer What's the difference between a Python "property" and "attribute"?

edited Jul 01 '17 at 04:13

answered Jul 01 '17 at 02:56

Manoj Bisht

31
1
3

Python class variables or @property

3 Answers3

Common Practice

Rationale