Introduction to Python's operator-Module

Accessing Items by Attribute Name¶

The idea behind attrgetter() is to create a callable, which fetches the predefined attribute from a given operand. To illustrate that, we create a class Student with three attributes:

• first_name (str): The student's first name

• last_name (str): The student's last name

• student_id (int): The student's personal identification number

Furthermore, a list of three students is created.

# student_class.py
import operator


class Student:
    def __init__(self, first_name: str, last_name: str, student_id: int) -> None:
        self.first_name: str = first_name
        self.last_name: str = last_name
        self.student_id: str = student_id

    def __repr__(self) -> str:
        return f"Student(first_name={self.first_name}, last_name={self.last_name}, student_id={self.student_id})"


students = [
    Student("Albert", "Einstein", 12345),
    Student("Richard", "Feynman", 73855),
    Student("Isaac", "Newton", 39352),
]

The task we are facing is to be able to sort the list of students by their last name and by their student id in combination with the last name. Python's built-in sorted() function accepts a key function (parameter key). In essence, each element of the iterable is passed to the key function and the returned value is used for sorting the elements. We want to have a callable returning the last_name attribute of a given element and a callable, which returns a tuple (student_id, last_name) for a given element, so sorted() can sort the elements based on these values. This can be achieved by utilising the attrgetter() function and assigning the returned callable to variables now acting as functions.

# previous code in student_class.py
get_last_name = operator.attrgetter("last_name")
get_id_last_name = operator.attrgetter("student_id", "last_name")

If we call the get_last_name() callable with an instance of the Student class, the last name will be returned. Simply put, get_last_name(student) is equivalent to student.last_name.

With that being said, we can supply both callables to the built-in sorted() function as key functions.

# previous code in student_class.py
sorted_by_last_name = sorted(students, key=get_last_name)
sorted_by_id_last_name = sorted(students, key=get_id_last_name)

print(sorted_by_last_name)
print(sorted_by_id_last_name)

Running the script via the command line gives us the desired outcome:

$ python student_class.py
[Student(first_name=Albert, last_name=Einstein, student_id=12345), Student(first_name=Richard, last_name=Feynman, student_id=73855), Student(first_name=Isaac, last_name=Newton, student_id=39352)]
[Student(first_name=Albert, last_name=Einstein, student_id=12345), Student(first_name=Isaac, last_name=Newton, student_id=39352), Student(first_name=Richard, last_name=Feynman, student_id=73855)]

Accessing Items by Index¶

The itemgetter() is somewhat similar to attrgetter(). The difference is that itemgetter() is an equivalent for the index-operator [] and not for accessing attributes. To demonstrate it, we use the previous example and use a tuple of tuples instead of a list of Student instances:

# student_dict.py
import operator

students = (
    ("Albert", "Einstein", 12345),
    ("Richard", "Feynman", 73855),
    ("Isaac", "Newton", 39352),
)

Now, we can create the two callables again, but this time we reference the "attributes" by using their indices:

# previous code in student_dict.py
get_last_name = operator.itemgetter(1)
get_id_last_name = operator.itemgetter(2, 1)

Calling get_last_name(student) is equivalent to student[1]. Again, we supply them as key functions to the built-in sorted() function ...

# previous code in student_dict.py
sorted_by_last_name = sorted(students, key=get_last_name)
sorted_by_id_last_name = sorted(students, key=get_id_last_name)

print(sorted_by_last_name)
print(sorted_by_id_last_name)

... and get the desired output:

$ python student_dict.py
[('Albert', 'Einstein', 12345), ('Richard', 'Feynman', 73855), ('Isaac', 'Newton', 39352)]
[('Albert', 'Einstein', 12345), ('Isaac', 'Newton', 39352), ('Richard', 'Feynman', 73855)]

Calling Methods by Name¶

Last but not least, let us have a look at the methodcaller() function. It is pretty similar to the previous two functions. This time, the idea is to create a callable, which calls a method on its operand. To show you a practical example, we create three classes first:

• Plugin: Abstract Base Class (ABC) representing a plugin with an abstract static method run().

• FirstPlugin: A class inheriting from Plugin and implementing the run() method.

• SecondPlugin: A class inheriting from Plugin and implementing the run() method, but printing a different value than FirstPlugin.

# plugin.py
import abc
import operator


class Plugin(abc.ABC):
    @abc.abstractstaticmethod
    def run(self):
        pass


class FirstPlugin(Plugin):
    def run(self):
        print("FirstPlugin here")


class SecondPlugin(Plugin):
    def run(self):
        print("SecondPlugin here")

The example at hand could be easily seen as an abstract plugin system. You as the maintainer of a project want to give your users the ability to implement and use custom plugins. Therefore, a plugin base class is provided. The only requirement is that the custom plugin has a run() method accepting no arguments.

If we now want to have a callable, which calls the run() method of a given plugin instance, we can utilise the methodcaller() function to create one:

# previous code in plugin.py
call_run = operator.methodcaller("run")
call_run(FirstPlugin())
call_run(SecondPlugin())

The result of calling it with an instance of FirstPlugin and SecondPlugin is shown below.

$ python plugin.py
FirstPlugin here
SecondPlugin here

The good thing about methodcaller() is that supplying arguments to the method, which is being invoked, is supported, too! So creating a callable ...

callable = operator.methodcaller("run", "foo", bar=1)

... and supplying an instance to it like ...

callable(plugin)

... is the same as:

plugin.run("foo", bar=1)