@property | Rustam Zokirov

TL;DR
Using property decorator
Read-write and read-only
Property as function
@property is just the syntactic sugar
Example
References

TL;DR

Getters and setters are used to add validation for getting and setting values or to avoid direct access of a class field.
We can use property, and call it as an instance variable. So, by this we are telling that the property is too cheap to compute, and no need to make it a function.
Or we can use property, to create another attributes based on that. Ex: Celsius, Fahrenheit.
If attribute value not passed in initializer, then use _.

Using property decorator

When inheriting property, you should do as usual and redefine getters, setters, and deleter

class Person:
    def __init__(self, name):
        self.name = name # if you do self._x = x, when you create object, x.setter will not be called for the first time.

    @property
    def name(self): 
        return self._name
            
    @name.setter
    def name(self, value):
        if not isinstance(value, str):
            raise TypeError('Expected a string')
        self._name = value

    @name.deleter
    def name(self):
        raise AttributeError("Can't delete attribute")
    
class SubPerson(Person): 
    @property
    def name(self): 
        print('Getting name') 
        return super().name

    @name.setter
    def name(self, value):
        print('Setting name to', value)
        super(SubPerson, SubPerson).name.__set__(self, value)

    @name.deleter
    def name(self):
        print('Deleting name')
        super(SubPerson, SubPerson).name.__delete__(self)

If only either getter or setter use @ParentClass.attribute.setter

class SubPerson(Person): 
	@Person.name.getter 
	def name(self):
		print('Getting name') 
		return super().name

class SubPerson(Person): 
  @Person.name.setter 
  def name(self, value):
	  print('Setting name to', value)
	  super(SubPerson, SubPerson).name.__set__(self, value)

Read-write and read-only

# Readwrite as usual
class Point:
    def __init__(self, x):
        self.x = x

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

    @x.setter
    def x(self, value):
        try:
            self._x = float(value)
            print("Validated!")
        except ValueError:
            raise ValueError('"x" must be a number') from None

# Readonly

class WriteCoordinateError(Exception):
    pass

class Point:
    def __init__(self, x, y):
        self._x = x
        self._y = y

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

    @x.setter
    def x(self, value):
        raise WriteCoordinateError("x coordinate is read-only")

    @property
    def y(self):
        return self._y

    @y.setter
    def y(self, value):
        raise WriteCoordinateError("y coordinate is read-only")

But in this example, you can only set instance variables only once.

Not considering obj._x = 78 of course.

Property as function

The setter method converts the input value for the ATTRIBUTE (radius) and assigns it to the non-public ._radius, which is the variable you use to store the final data.

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    @property
    def area(self):
        return self.width * self.height

rec = Rectangle()
area = rec.area # Computed attribute, no need to use brackets ()


The read-only property .area computes and returns the area of the current rectangle every time you access it

Rectangle().area is the computed attribute. These are attributes that are not actually stored, but computed on demand.

@property is just the syntactic sugar

# property_function.py
class Foo():
    def getter(self) -> object:
        print("accessing the attribute to get the value")
        return 42

    def setter(self, value) -> None:
        print("accessing the attribute to set the value")
        raise AttributeError("Cannot change the value")

    attribute1 = property(getter, setter)

my_foo_object = Foo()
x = my_foo_object.attribute1
print(x)

Example

from jsonpath import jsonpath


class DataParser(object):
    def __init__(self, data=None):
        self.data = data
        self._selector = None # We can do _, because we don't initialize selector like, parser = DataParser(selector="...")
        self.result = None

    @property
    def selector(self):
        return self._selector

    @selector.setter
    def selector(self, selector):
        self._selector = selector
        if self.data:
            self.result = jsonpath(self.data, selector)
        else:
            self.result = None

# HOW TO USE?
class TestSaveArticleUnSaveArticle(SavingFixtures):

    parser = DataParser()

		@pytest.mark.usefixtures('clear_saved_articles')
    def test_saved_article(self):
        article_id = test_data.get_article()
        self.client.execute(Base.saveArticle, variable_values={'id': article_id})

        self.parser.data = self.client.execute(Base.isArticleSaved, variable_values={'isArticleSavedId': article_id})
        self.parser.selector = '$..[?(@.saved==True)].id'
        assert [article_id, ] == self.parser.result

References

https://t.me/c/1729245485/234 My own code
https://realpython.com/python-property/