Python property() function

property() function in Python is a built-in function that returns an object of the property class. It allows developers to create properties within a class, providing a way to control access to an attribute by defining getter, setter and deleter methods. This enhances encapsulation and ensures better control over class attributes. Example:

class Student:
    def __init__(self, name):
        self._name = name

    name = property(lambda self: self._name)

s = Student("shakshi")
print(s.name) 

shakshi

Explanation: Student class initializes _name in __init__. The property() function with a lambda defines a read-only name property, restricting modifications. print(s.name) accesses and prints _name.

Syntax of property()

property(fget=None, fset=None, fdel=None, doc=None)

Here none is the default value if a getter, setter or deleter is not provided.

Parameters:

• fget() used to get the value of attribute.
• fset() used to set the value of attribute.
• fdel() used to delete the attribute value.
• doc() string that contains the documentation (docstring) for the attribute.

Return: Returns a property object from the given getter, setter and deleter.

Note:

• If no arguments are given, property() method returns a base property attribute that doesn’t contain any getter, setter or deleter.
• If doc isn’t provided, property() method takes the docstring of the getter function.

Creating properties in Python

We can create properties using two methods:

• Using the property() function
• Using the @property decorator

Using the property() function

class Alphabet:
    def __init__(self, value):
        self._value = value

    def getValue(self):
        print("Getting value")
        return self._value

    def setValue(self, value):
        print("Setting value to " + value)
        self._value = value

    def delValue(self):
        print("Deleting value")
        del self._value

    value = property(getValue, setValue, delValue)

# Usage
x = Alphabet("GeeksforGeeks")
print(x.value)

x.value = "GfG"
del x.value

Getting value
GeeksforGeeks
Setting value to GfG
Deleting value

Explanation: Alphabet class uses the property function to manage a private attribute _value with getter, setter and deleter methods. The __init__ method initializes _value. getValue retrieves and prints it, setValue updates and prints the change and delValue deletes it with a message. Accessing x.value calls getValue, assigning a new value calls setValue and deleting it calls delValue.

Using the @property Decorator

class Alphabet:
    def __init__(self, value):
        self._value = value

    @property
    def value(self):
        print("Getting value")
        return self._value

    @value.setter
    def value(self, value):
        print("Setting value to " + value)
        self._value = value

    @value.deleter
    def value(self):
        print("Deleting value")
        del self._value

# Usage
x = Alphabet("Peter")
print(x.value)

x.value = "Diesel"
del x.value

Getting value
Peter
Setting value to Diesel
Deleting value

Explanation: Alphabet class uses the @property decorator to manage _value with getter, setter and deleter methods. The getter prints “Getting value” and returns _value, the setter updates it with a message and the deleter removes it while printing “Deleting value.” Creating an instance with “Peter” triggers the getter on print(x.value), setting “Diesel” calls the setter and del x.value invokes the deleter.

Python Property vs Attribute

Understanding the difference between properties and attributes in Python is important for writing clean, maintainable code. Properties provide controlled access to instance attributes, while attributes are direct data members of a class or instance.

A property allows encapsulation by defining custom logic for getting, setting and deleting values. This helps in implementing validation and computed attributes dynamically. In contrast, class attributes are shared among all instances of a class and are typically used for static data that should not be changed on an instance level.

Example 1. class attributes vs Instances attribute

class Employee:
    count = 0  # Class attribute

    def increase(self):
        Employee.count += 1

# Usage
emp1 = Employee()
emp1.increase()
print(emp1.count)

emp2 = Employee()
emp2.increase()
print(emp2.count)
print(Employee.count)

1
2
2

Explanation: Employee class has a shared class attribute count, initialized to 0. The increase method increments count. Calling increase() on emp1 sets count to 1 and on emp2, it updates to 2. Printing emp1.count, emp2.count and Employee.count all return 2.

Example 2. Using property() for encapsulation

class GFG:
    def __init__(self, value):
        self._value = value

    def getter(self):
        print("Getting value")
        return self._value

    def setter(self, value):
        print("Setting value to " + value)
        self._value = value

    def deleter(self):
        print("Deleting value")
        del self._value

    value = property(getter, setter, deleter)

# Usage
x = GFG("Happy Coding!")
print(x.value)

x.value = "Hey Coder!"
del x.value

Getting value
Happy Coding!
Setting value to Hey Coder!
Deleting value

Explanation: GFG class uses property to manage _value with getter, setter and deleter methods. The getter retrieves _value, the setter updates it and the deleter removes it, each with a message. Creating an instance with “Happy Coding!”, print(x.value) calls the getter, assigning “Hey Coder!” updates _value and del x.value deletes it.

Difference Table: Class attribute vs property

Applications of property()

• Encapsulation: Controls attribute access by adding logic to getters and setters.
• Validation: Enables validation checks before assigning values.
• Backward Compatibility: Allows modifying class implementation without breaking existing client code.
• Computation on Access: Properties can compute values dynamically when accessed.