Adventures in Machine Learning

Mastering Python’s setattr() Function for Dynamic Attribute Updates

Understanding the setattr() Function for Setting Object Attribute Value

In the world of programming, object-oriented programming (OOP) is a widely used approach for designing complex applications. OOP is based on the concept of objects, which are essentially instances of classes containing data and methods.

In Python, classes are used to define the structure, attributes, and methods of objects. One of the key benefits of OOP is the ability to modify object attributes at runtime, which is where the setattr() function comes into play.

Explaining the setattr() Function

The setattr() function in Python is a built-in function that allows you to set an attribute on an object at runtime. Essentially, setattr() is used to set or alter an objects attribute value.

The syntax of the setattr() function is as follows:

setattr(object, name, value)

The object parameter specifies the target object whose attribute will be set. The name parameter specifies the attribute you wish to set, while the value parameter specifies the new value of the attribute.

Example of Using setattr() Function

To clarify how the setattr() function works, here’s an example:

class MyClass:

x = 1

# Before changing the attribute

print(MyClass.x) # Output: 1

setattr(MyClass, ‘x’, 2)

# After changing the attribute

print(MyClass.x) # Output: 2

In this example, the MyClass class has an attribute named “x” which is set to 1. The setattr() function is then used to change the value of the “x” attribute to 2.

As you can see from the output, the attribute value has been successfully modified.

Using setattr() Function with getattr()

Another useful feature of Python is that it allows you to set object attributes dynamically using getattr() and setattr() together. The getattr() function helps in getting the value of an attribute of an object.

The syntax of the getattr() function is:

getattr(object, attribute, default_value)

The object parameter specifies the name of the object whose attribute will be returned. The attribute parameter is the name of the attribute you’d like to get the value of.

The default_value parameter is an optional parameter that specifies the default value to return if the attribute doesn’t exist – if no default_value is specified, it’ll raise an AttributeError.

Example of Using setattr() with getattr()

Let us consider an example of a student record, which has names, subjects, and respective marks. Now, let’s say we wish to sort the students by their marks in each subject.

Here’s how you’d go about it:

class Student:

def __init__(self, name, math_marks, english_marks): = name

self.math_marks = math_marks

self.english_marks = english_marks

students = [Student(“Alice”, 80, 85), Student(“Bob”, 70, 90), Student(“Charlie”, 90, 75)]

# Sort the students based on math marks

for student in students:

setattr(student, ‘math_marks_sort’, -student.math_marks)

students.sort(key=lambda x: getattr(x, ‘math_marks_sort’))

# Print the sorted records

for student in students:

print(, student.math_marks, student.english_marks)


Charlie 90 75

Alice 80 85

Bob 70 90

In this example, we define a Student class with a constructor that takes three parameters: name, math_marks, and english_marks. Then, we create three Student objects with different names and marks in math and English subjects.

Finally, to sort the students based on their math_marks attribute, we use setattr() to create a new attribute called ‘math_marks_sort’ and assign it a negative value (-student.math_marks). The negative value is used because Python’s sort function sorts in ascending order by default, and we need to sort in descending order in this case.

Then, we sort the students based on the ‘math_marks_sort’ attribute using the lambda function, and print the sorted records.


In conclusion, the setattr() function is a useful built-in function in Python that allows you to set an object’s attribute value at runtime. By using the setattr() function, you can modify an object’s attributes, which can come in handy for a variety of use cases, especially in the domain of OOP.

Additionally, the setattr() function can be used with the getattr() function for sorting attributes dynamically, which adds greater flexibility to Python development. The setattr() function in Python plays a vital role in Object Oriented Programming (OOP) as it allows developers to set object attributes dynamically.

By utilizing setattr(), you can modify an object’s attributes at runtime, enabling great flexibility in the design of complex applications. The setattr() function is used for setting object attributes, which are the variables contained within an object that store data about the object.

Attributes can be used for a wide range of purposes, such as storing configuration data, state information, or settings that are based on user input. Attributes can be assigned any type of value, ranging from standard data types such as integers, floats and strings to custom objects defined by the developer.

To utilize setattr() effectively, you need to understand that objects in Python are instances of classes that contain data and methods. The setattr() method enables you to change the value of a Python class attribute dynamically at runtime, which is particularly useful when you don’t know the name of the attribute you need to modify ahead of time.

The syntax of the setattr() function is simple; it involves passing three parameters: the object, the attribute name, and the new value of that attribute. Using setattr() function, you can alter or create new object attributes as required.

Example of Object Attribute Modification with setattr()

Let’s say you have a Python class called “Person”, and it contains an attribute named “age”. Initially, you create an instance of the class and set an initial value of 25 to the attribute.

class Person():

def __init__(self):

self.age = 25

person = Person()

print(person.age) # Output: 25

Now, let’s say that you want to increase the value of the “age” attribute to 30. Utilizing setattr() function, you can achieve this dynamically at runtime:

setattr(person, ‘age’, 30)

print(person.age) # Output: 30

As the output shows, the setattr() function successfully changed the value of the “age” attribute from 25 to 30.

Using setattr() Function with getattr()

Another useful feature of Python is the ability to use the getattr() function in conjunction with setattr(). The getattr() function is used for retrieving an object’s attribute value dynamically, while setattr() function is used for setting an object’s attribute value dynamically.

Essentially, getattr() and setattr() provide a flexible API for Python developers, enabling them to design complex applications with dynamic attribute updates. The getattr() function returns the value of an object’s attribute, and setattr() updates the value of an object’s attribute.

However, the two functions work best when used together.

Example of Using setattr() with getattr()

Here is an example where we use getattr() and setattr() together to update the values of an object’s attributes:

class Book():

def __init__(self, title, author, year_published):

self.title = title = author

self.year_published = year_published

book = Book(“A Game of Thrones”, “George R.R. Martin”, 1996)

attribute_name = input(“Enter the attribute name (title/author/year_published): “)

if hasattr(book, attribute_name):

attribute_value = input(“Enter new attribute value: “)

setattr(book, attribute_name, attribute_value)

print(f”Updated book details: Title: {book.title} | Author: {} | Year Published: {book.year_published}”)

In this example, we ask the user which attribute they would like to update for the Book object they’ve created. Whenever a user makes a change to an attribute, we then use setattr() to apply that change to the Book object’s attribute.

The output displays the updated book details, which include the title, author, and year_published.


In conclusion, setattr() function plays a significant role in Python programming, especially when you need to dynamically set object attributes. By using setattr() function, you can modify the attributes of an object at runtime rather than using rigid variable declarations in your code.

Additionally, setattr() function is one of the must-have tools to empower Python developers to take advantage of the versatility offered by OOP. When used in conjunction with getattr(), developers can write more flexible and scalable code, creating more robust and dynamic applications that are easier to maintain.

In conclusion, the setattr() function is an essential built-in function in Python that enables you to set and modify object attributes dynamically. This feature is particularly useful in OOP, where objects have attributes that store data and states, and their values need to be updated at runtime.

By using setattr() and getattr() functions together, Python developers can create more flexible, scalable, and dynamic applications. This knowledge is vital for anyone looking to build robust and maintainable software systems in Python.

Ultimately, understanding and mastering setattr() and getattr() functions is key to building more robust, flexible, and scalable applications with Python.