Python: Dynamically Calling Methods with getattr()

Python is known for its flexibility and versatility, and one way it showcases these traits is through its ability to dynamically call methods based on string values. This can be incredibly useful in scenarios where you want to choose and execute methods at runtime, often seen in situations involving configuration, plugins, or user-driven decisions.

In this blog post, we’ll explore how to dynamically call methods in Python using the getattr() function. We’ll create a simple example using a class to illustrate this concept.

Introduction to getattr()

The getattr() function is a built-in Python function that returns the value of a named attribute of an object. In the context of calling methods, this function allows us to retrieve a method from an object based on its name and then execute it. The basic syntax of getattr() is as follows:

getattr(object, name[, default])

- object: The object from which to retrieve the attribute (method).
- name: The name of the attribute (method) you want to retrieve.
- default (optional): The value to be returned if the named attribute does not exist. If default is not provided and the attribute is not found, an AttributeError is raised.

A Practical Example

Let’s dive into a practical example using a Python class, Vehicle, which contains multiple methods. We’ll create a method in this class called call_method_by_name that will allow us to call other methods dynamically.

class Vehicle:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year

    def motorcycle(self):
        print(f"{self.make} {self.model} ({self.year}) - Motorcycle specific method")

    def bicycle(self):
        print(f"{self.make} {self.model} ({self.year}) - Bicycle specific method")

    def call_method_by_name(self, name):
        method = getattr(self, name, None)
        if method:
            method()
        else:
            print(f"{self.make} {self.model} ({self.year}) - Method '{name}' not found")

#Example usage:

if __name__ == "__main__":
    vehicle = Vehicle("Generic", "Model", 2022)
    vehicle.call_method_by_name("motorcycle")
    vehicle.call_method_by_name("bicycle")
    vehicle.call_method_by_name("unknown_method")

In this example, we have a Vehicle with two methods: motorcycle and bicycle. We also have the call_method_by_name method that takes a method name as an argument and uses getattr() to dynamically retrieve and call the corresponding method.

When we execute the code, it will produce the following output:

Generic Model (2022) - Motorcycle specific method
Generic Model (2022) - Bicycle specific method
Generic Model (2022) - Method 'unknown_method' not found

As you can see, the methods are called dynamically based on the string values passed to call_method_by_name. If the method does not exist, no error is raised because we’ve provided a default value of None to getattr(), and we use a conditional statement to check if the method exists before calling it.

It’s a powerful tool for dynamic method invocation based on string values, helping to avoid extensive if-else logic and making your code more adaptable to changing requirements and user preferences.