Python Property: quick and comprehensive overview

You can easily assign values ​​to attributes of a Python class using Python Property. Getter or setter methods are called automatically when using Python Property.

Python Property: what is it exactly and what is this solution for?¶

The Python Property solution is a technique that developers can use as part of the object oriented programming with Python. Programmers can thus define methods which they can then use as if they were attributes. This allows them tomore intuitive access to attributes of a class. Calling the dedicated setter and getter methods thus becomes superfluous. The Python Property solution allows class attributes to be transformed into properties called ” Managed Attributes “.

A Python Property also makes it possible to implement a form of access control: the use of properties makes it possible to ensure that no other method accesses the data of the attribute to make unwanted modifications to it. .

The Python property() function¶

Developers can use the Python property() function to work with properties. They can take advantage of this integrated function without having to import any additional modules. The Python property() function is implemented in the C programming language, for optimal performance.

The syntax of the Python property() function is as follows:

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

Python property() function parameters are optional. In the summary table below, you will find the meaning of each parameter:

The Python Property Decorator¶

It is not necessary to use the property() function to work with properties. A predefined Python Decorator can often be used; this one allows you to use a method of your class as a property. The programming language supports three different decorators with their well-known notation (“@”) allowing you to define a property:

• “@property”: identifies a method of your class as a Python Property;
• “@property-name.setter”: specifies a setter method, which sets the value of a property;
• “@property-name.deleter”: specifies the method for deleting a property.

Python Property: example¶

A detailed sample code can help you understand how the Python Property solution works and is useful. In the section of code below, we start by creating a class named “Dog”, with the attribute “_name”. If this example is particularly artificial and has no real use, it is nevertheless perfect to illustrate the operation of the Python Property solution.

class Chien:
	def __init__(self):
		self._nom = "Bello"

As you can see, the constructor does not receive any parameters specifying the name of our dog. Instead, the dog’s name is specified by default, using the value “Bello”. It is therefore possible to create an object of the class with, for example, the following line of code:

Getter and setter methods¶

You can enhance your class using specific getter and setter methods. This can be a good idea for several reasons, especially because they make the code more easy to maintain and because they allow theintegration of additional features. Since names are strings by default, we also want to make sure that a name as a string is actually passed into our class. To do this, we enter the corresponding functional logic in a dedicated setter method to improve the previous definition of our class:

class Chien:
	def __init__(self):
		self._nom = "Bello"

	
	def getNom(self):
		return self._nom

	def setNom(self, nom):
		if isinstance(nom, str):
			self._nom = nom
		else:
			return

The setter method with the name “setName” is responsible for checking, in an if…else declaration in Python, whether the parameter transmitted corresponds to a character string. This allows, if necessary, to define the name; otherwise, nothing happens.

We also chose to specify a getter method returning the dog’s name.

An object of our class called “Lassie” can be created by following the example below:

lassie = Chien()
lassie.setNom("Lassie")
print(lassie.getNom())

The result is the following (and corresponds to what we wanted):

Python property() function¶

To avoid having to resort to an explicit function call to change or find out your dog’s name in Python, you can now use a Python Property. For demonstration purposes, we have also chosen to embed a print statement in each of our getter and setter methods.

class Chien:
	def __init__(self):
		self._nom = "Bello"

	def getNom(self):
		print("Appel de la méthode getter")
		return self._nom

	def setNom(self, nom):
		if isinstance(nom, str):
			self._nom = nom
			print("Appel de la méthode setter")
		else:
			return
	
	nom = property(getNom, setNom)

As you can see, all we had to do was create a new attribute called “name” (without placing an underscore at the beginning, because the Python Property allowed us to address it from the outside without any problems) and assign the result of our function call to it to call the property() function. It then received the two getter and setter methods you already know as parameters.

By now creating another object of the class named “Snoopy”, the difference is already visible:

snoopy = Chien()
snoopy.nom = "Snoopy"
snoopy.nom

It is now possible to easily access the attributes of this class using the dot notation that you should already be familiar with. Here, the result returned by the program is particularly interesting:

Appel de la méthode setter
Appel de la méthode getter
'Snoopy'

The getter and setter methods have not been explicitly called, but they were still executed when the “Snoopy” object was assigned or retrieved using dot notation. The Python Property allowed us to achieve this result.

Python Property Decorator¶

It is possible to achieve the same result with function decorators, which we have already discussed. If so, the sample code looks like this (both “decorated” methods must have the same name):

class Chien:
	def __init__(self):
		self._nom = "Bello"

	@property
	def nom(self):
		print("Appel de la méthode setter")
		return self._nom


	@nom.setter
	def nom(self, nom):
		if isinstance(nom, str):
			self._nom = nom
			print("Appel de la méthode getter")
		else:
			return

It is possible to create a new object for this class and use dot notation to set and extract the “name” attribute:

struppi = Chien()
struppi.nom = "Struppi"
struppi.nom

The result is the same as that obtained using the Python-property() function:

Appel de la méthode setter
Appel de la méthode getter
'Struppi'