5 Ways to Control Attributes in Python. An Example Led Guide (2023)

What happens at the dot.

See Also

Python Properties Vs Attributes

Introduction

Data integrity can be secured by controlling attribute values and their access. When a class is created, we may want to ensure all future objects have attributes of the correct data type, and/or of sensible/appropriate values. We may also want to ensure once attributes are set their values cannot be changed or deleted. To achieve this, read-only and deletion proof attributes must be created.

An Employee class, that accepts name, age and length of service as arguments, may want to ensure that the name is a string, and the age and length of service are integers before they are set as attributes in the objects created. This class may also want to ensure attributes like names cannot be altered or deleted.

Attribute validation can help ensure valid data entry, even in cases where the user of a class may input less than ideal user-information, for example, a name in lower case. This tutorial article will explore 5 different ways to ensure attribute validation, namely via magic/dunder methods and decorators. Attribute integrity is important when the attributes themselves are used in methods defined in the class. This is why, before an attribute gets set in an object, its value should be checked.

Example 1: dunder __setattr_, __delattr__

The magic or dunder __setattr_ and__delattr__ methods in Python represent one way the programmer can exert control over attributes. To illustrate, let's initialise a class called Employees. This class will take 3 arguments and set them as attributes in the objects.

To showcase how we can exert control over attributes, let's establish the behaviour we would like to implement for our Employees object.

1. The _name attributevalue, should be capitalised, regardless of whether the user chooses to input the name attribute in capitalised format or not.
2. The _name attribute should only be allowed to be set once. The name attribute will become read-only once it is set.
3. The _age and _service_length attributes should be integers. If they are not a TypeError exception will be raised.
4. The _name attribute cannot be deleted

dunder __setattr__

The dunder setattr method takes the object and the key and the value we would like to set in the object as arguments. We first check to see if the object with the attribute ‘_name’ already has the attribute, name. If it does, we will raise an AttributeError because we do not want the name attribute to be re-set. In the following elif statement, if the object does not have a name attribute we will set it, and capitalise it using the string title method.

The logic in the first if and elif blocks of the setattr method solves points 1 and 2 above. Now, let's check the data type of the age and service length attributes for point number 3.

For both the ‘_age’ and the ‘_service_length’ attributes, we check they are of type int, using the built-in Python isinstance function. If they are of any type besides int, a TypeError exception will be raised.

Finally, let's address point 4, and implement code to prevent the deletion of the name attribute. For the sake of argument, let's assume, that once a name has been set, it cannot be deletion and exists permanently.

As such, when we attempt to del the name attribute from our object, an AttributeError exception will be raised, informing the user, that the attribute cannot be deleted. Under the hood, the del keyword calls the __delattr__ method. Since we have defined it in our class, it will call our custom version of __delattr__. We will however, still permit behaviour which enables the deletion of any other attribute.

To note, in the code snippets shown, we set and delete the attributes as shown below to avoid recursive errors.

The code for our Employee class is shown below via the GitHub gist and available via this link.

To test the custom behaviour we have implemented, let's create an instance of the Employees class and check to see if the name attribute can be set, cannot be re-set, and cannot be deleted. In addition, we can check the type of the age and service length attributes.

Re-setting the name attribute failed and informs the user of why the program terminated.

When we loop through the dictionary of attributes, and print their type, we can see the age and length of service are of type int.

Finally, when we try to delete the attribute name, an AttributeError exception is raised, with the string message informing the user that the attribute cannot be deleted.

(Video) Neural Network In 5 Minutes | What Is A Neural Network? | How Neural Networks Work | Simplilearn

We have now succeeded in enacting the custom behaviour we desired. While these examples are contrived, they do illustrate how we can control attributes using the setattr and delattr methods in Python. If you would like to try the examples shown, the entire code is available via this link.

Alternative ways to control attributes in an object

The following examples represent alternative ways to control attributes in Python. As a proviso, I do not attest to them being the best way to control attributes, rather alternatives means that can add to your arsenal of tools to use in Python.

The section to follow will introduce an example-led guide to using decorators to manage attributes.

Using Decorators

Example 2: Using @staticmethod Decorator

For continuity, the same Employees class will be initialised in the proceeding examples. Here, the staticmethod decorator can be used to check the attribute value in an object. Specifically, here, we want both the age and service_length attribute values to be of type int.

To do this, we can define a data_type_check method in our class, and decorate it with the staticmethod decorator. When the attributes are being set in the init constructor, we call the method data_type_check on our object, and pass in either age or service_length as arguments. If age, and service length are of type int, they will be returned and set as attributes in our object. If they are not of type int, a type error exception will be raised.

One thing that is really nice about using the staticmethod decorator, is its re-usability. If, for example, we added an annual bonus argument to our init method, we could simply call the staticmethod decorator again and pass bonus as an argument.

Example 3: Using a Custom Decorator

Another way to control the value of attributes is via a custom decorator. In keeping with our theme, let's create the same class, but this time decorate the init constructor method, with a function called attr_check.

When we create an instance of our Employee class, the init method will be called automatically. As the attr_check function decorates the init method, this function will be called. attr_check will take the init method as an argument, and return inner. When we then call inner with our object ref, age and service, we can perform type checking on both age and service. If age and service are of type int, we will return the original init method with the object, name, age and service and arguments.

This implementation is a nice way to control attribute values in Python because we can choose what goes into the body of inner. In this case, we did not perform any type checking on the name or any range allowance on the age, but we could simply add these checks in, by expanding the code defined within the inner function.

Example 4: Using the @property/setter/deleter decorators

Yet another way to control attribute values in Python is through the use of the property decorator and its corresponding setter and deleter methods.

Let's create our Employees class once more. When the user attempts to access the name attribute through the object.attribute syntax, the name method decorated with @property will be called, and the name will be returned capitalised.

This time if the user would like to change the name attribute, let's ensure whatever string they input will be capitalised. We can achieve this by defining a simple name method alongside corresponding setter and deleter methods.

We define the name method and decorate it with @name.setter. When the user wants to set a new name, using the object.attribute syntax, the new name set in the object will now be capitalised.

Note, the underlying name of the name attribute ‘_name’, is different to the name of the method to avoid recursive errors. We could not have self.name = new_name.title() in the body of our setter method.

Example 5: Conditional checking in the init Constructor

To finish this article on attribute control, the simplest way to implement attribute integrity, may in fact be to include conditional checking in the init constructor of our class itself. Here, we allow the age of the employee to be greater than or equal to 18, and less than or equal to 100. If the condition is satisfied, we can set the age supplied as an argument in the init method as an attribute value in our object. When an instance is created that fails to satisfy this condition, an AttributeError exception is raised, with a useful string message informing the user of the conditions required.

Summary

Thanks for reading, and I hoped you liked the different ways to control attribute access and their values. While I have mainly focused on data-type checking and range allowance, any conditional imaginable can be imposed on an attribute value. An email address may undergo validation using regex before being set, to comply with data integrity.

I have deliberately used basic examples here to help convey how the multiple ways to control attribute values and access work. Furthermore, Descriptors are another way to manage attributes in Python, and I will hopefully write a tutorial piece on how to use them. If you have any questions, or would like more articles themed around this topic, let me know via LinkedIn.