The Python property() function is a built-in feature that returns an object of the property class and is used to create class properties. This function provides a way to define properties in Python, allowing for controlled access to an object’s attributes. In this article, we will explore how the property() function works in Python.

Syntax of Python property() Function
The property() function is used to create properties within a class.

Syntax:
property(fget, fset, fdel, doc)
Parameters:

fget(): Retrieves the attribute’s value.
fset(): Sets the attribute’s value.
fdel(): Deletes the attribute.
doc(): A string that holds the documentation for the attribute.
Return: The function returns a property object created from the specified getter, setter, and deleter functions.

Notes:

If no arguments are provided, the property() function returns a base property object without a getter, setter, or deleter.
If the doc parameter isn’t provided, the property() function will use the docstring of the getter function.
Understanding the property() Function in Python
The property() function in Python is a built-in tool that allows the creation of special attributes known as properties within a class. Properties enable you to encapsulate access to an attribute and introduce additional logic, such as validation or computation, when the attribute is accessed or modified.
Methods to Create Properties in Python
There are two primary ways to create properties in Python:

Using the property() function:
This method allows you to manually create properties by defining getter, setter, and deleter methods.
Using the @property decorator:
This approach simplifies the process by using decorators to define properties.
Example: Creating a Property with the property() Function
In this example, we use the property() function to define a property within a class. We create a class named Alphabet and define a property called value.

This property controls how the internal attribute _value is accessed and modified by defining custom getter and setter methods.

`# Python program to explain property() function

Alphabet class

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

# getting the values

def getValue(self):

    print('Getting value')

    return self._value

  
  
  setting the values


def setValue(self, value):

    print('Setting value to ' + value)

    self._value = value

  
  
  deleting the values


def delValue(self):

    print('Deleting value')

    del self._value

value = property(getValue, setValue, 

                 delValue, )

passing the value

x = Alphabet('Codemagnet')
print(x.value)

x.value = 'CM'

del x.value
`

Output:
Getting value
Codemagnet
Setting value to CM
Deleting value

Using the @property Decorator
Decorators in Python are like add-ons that give extra features to your existing code. The @property decorator is a tool that makes your methods behave like regular attributes of a class.

This technique is part of something called metaprogramming, where one part of the program changes another part during the compile time.

Here’s how it works: when you define a method in your class and use the @property decorator, you’re turning that method into an attribute. This means you can access it like a regular variable, but behind the scenes, Python will call the method to get its value.

If you then define the same method again with a @value.setter or @value.deleter, you’re telling Python how to set or delete that attribute.

In simple terms, using @property lets you control what happens when you get, set, or delete a value in your class, all while making your code look clean and simple.

When you access x.value, Python will automatically know whether you’re trying to get, set, or delete the value and will call the right method for you.

Read More Below