At the first glance Python's operator module might not seem very interesting. It includes many operator functions for arithmetic and binary operations and a couple of convenience and helper functions. They might not seem so useful, but with help of just a few of these functions you can make your code faster, more concise, more readable and more functional. So, in this article we will explore this great Python module and make the most out of the every function included in it.
Use Cases
The biggest part of the module consists of functions that wrap/emulate basic Python operators, such as +, << or not. It might not be immediately obvious why you would need or want to use any of these when you can just use the operator itself, so let's first talk about some of the use cases for all these functions.
First reason why you might want to use some of these in your code is if you need to pass operator to a function:
def apply(op, x, y):
return op(x, y)
from operator import mul
apply(mul, 3, 7)
# 21
Reason why we need to do this is, is that Python's operators (+, -, ...) are not functions, so you cannot pass them directly to functions. Instead, you can pass in the version from operator module. You could easily implement wrapper function that does this for you, but no one wants to create function for each arithmetic operator, right? Also, as a bonus this allows for more functional style of programming.
You might also think, I don't need operator module for this, I can just use lambda expression!. Yes, but here comes the second reason why you should use this module. Functions in this module are faster than lambdas. You obviously won't notice that with single execution, but if you run it in loop enough times, then it's going to make a big difference:
python -m timeit "(lambda x,y: x + y)(12, 15)"
10000000 loops, best of 3: 0.072 usec per loop
python -m timeit -s "from operator import add" "add(12, 15)"
10000000 loops, best of 3: 0.0327 usec per loop
So if you're used to writing something like (lambda x,y: x + y)(12, 15), you might want to switch to operator.add(12, 15) for a little performance boost.
Third and for me the most important reason to use operator module is readability - this is more of a personal preference and if you use lambda expressions all the time, then it might be more natural for you to use those, but in my opinion, it's in general more readable to use functions in operator module rather than lambdas, for example consider the following:
(lambda x, y: x ^ y)(7, 10)
from operator import xor
xor(7, 10)
Clearly the second option is more readable.
Finally, unlike lambdas, operator module functions are picklable, meaning that they can be saved and later restored. This might not seem very useful, but it's necessary for distributed and parallel computing, which requires the ability to pass functions between processes.
All The Options
As I already mentioned this module has a function for every Python arithmetic, bitwise and truth operator as well as some extras. For the full list of mapping between functions and the actual operators, see table in docs.
Along with all the expected functions, this module also features their in-place versions that implement operations such as a += b or a *= b. If you want to use these you can just prefix the basic versions with i, for example iadd or imul.
Finally, in operator you will also find the dunder versions of all these functions, so for example __add__ or __mod__. These are present there for legacy reasons, and the versions without underscores should be preferred.
Apart from all the actual operators, this module has some more features that can come in handy. One of them is little know length_hint function, which can be used to get vague idea of length of an iterator:
from operator import length_hint
iterator = iter([2, 4, 12, 5, 18, 7])
length_hint(iterator)
# 6
iterator.__length_hint__()
# 6
I want to highlight the vague keyword here - don't rely on this value because it really is a hint and makes no guarantees of accuracy.
Another convenience function that we can grab from this module is countOf(a, b) which returns number occurrences of b in a, for example:
from operator import countOf
countOf([1, 4, 7, 15, 7, 5, 4, 7], 7)
# 3
And last of these simple helpers is indexOf(a, b), which returns index of first occurrence of b in a:
from operator import indexOf
indexOf([1, 4, 7, 15, 7, 5, 4, 7], 7)
# 2
Key Functions
Apart from operator functions and couple of the above mentioned utility functions, operator module also includes functions for working with higher-order functions. These are attrgetter and itemgetter which are most often used as key-function usually in conjunction with function such as sorted or itertools.groupby.
To see how they work and how you can use them in your code, let's look at a couple of examples.
Let's say we have a list of dictionaries, and we want to sort them by a common key. Here's how we can do it with itemgetter:
rows = [
{"name": "John", "surname": "Doe", "id": 2},
{"name": "Andy", "surname": "Smith", "id": 1},
{"name": "Joseph", "surname": "Jones", "id": 3},
{"name": "Oliver", "surname": "Smith", "id": 4},
]
from operator import itemgetter
sorted_by_name = sorted(rows, key=itemgetter("surname", "name"))
# [{"name": "John", "surname": "Doe", "id": 2},
# {"name": "Joseph", "surname": "Jones", "id": 3},
# {"name": "Andy", "surname": "Smith", "id": 1},
# {"name": "Oliver", "surname": "Smith", "id": 4}]
min(rows, key=itemgetter("id"))
# {"name": "Andy", "surname": "Smith", "id": 1}
In this snippet we use sorted function that accepts iterable and key function. This key function has to be a callable that takes single item from the iterable (rows) and extracts the value used for sorting. In this case we pass in itemgetter which creates the callable for us. We also give it dictionary keys from rows which are then fed to object's __getitem__ and the results of the lookup are then used for sorting. As you probably noticed, we used both surname and name, this way we can simultaneously sort on multiple fields.
The last lines of the snippet also show another usage for itemgetter, which is lookup of row with minimum value for ID field.
Next up is the attrgetter function, which can be used for sorting in similar way as itemgetter above. More specifically, we can use it to sort objects that don't have native comparison support:
class Order:
def __init__(self, order_id):
self.order_id = order_id
def __repr__(self):
return f"Order({self.order_id})"
orders = [Order(23), Order(6), Order(15) ,Order(11)]
from operator import attrgetter
sorted(orders, key=attrgetter("order_id"))
# [Order(6), Order(11), Order(15), Order(23)]
Here we use self.order_id attribute to sort orders by their IDs.
Both of the above shown functions are very useful when combined with some functions from itertools module, so let's see how we can use itemgetter to group elements by its field:
orders = [
{"date": "07/10/2021", "id": 10001},
{"date": "07/10/2021", "id": 10002},
{"date": "07/12/2021", "id": 10003},
{"date": "07/15/2021", "id": 10004},
{"date": "07/15/2021", "id": 10005},
]
from operator import itemgetter
from itertools import groupby
orders.sort(key=itemgetter("date"))
for date, rows in groupby(orders, key=itemgetter("date")):
print(f"On {date}:")
for order in rows:
print(order)
print()
# On 07/10/2021:
# {"date": "07/10/2021", "id": 10001}
# {"date": "07/10/2021", "id": 10002}
# On 07/12/2021:
# {"date": "07/12/2021", "id": 10003}
# On 07/15/2021:
# {"date": "07/15/2021", "id": 10004}
# {"date": "07/15/2021", "id": 10005}
Here we have a list of rows (orders) which we want to group by date field. To do that, we first sort the array and then call groupby to create groups of items with same date value. If you're wondering why we needed to sort the array first, it's because groupby function work by looking for consecutive records with same value, therefore all the records with same date need to be grouped together beforehand.
In the previous examples we worked with arrays of dictionaries, but these functions can be also applied to other iterables. We can for example use itemgetter to sort dictionary by values, find index of minimum/maximum value in array or sort list of tuples based on some of their fields:
# Sort dict by value
from operator import itemgetter
products = {"Headphones": 55.90, "USB drive": 12.20, "Ethernet Cable": 8.12, "Smartwatch": 125.80}
sort_by_price = sorted(products.items(), key=itemgetter(1))
# [('Ethernet Cable', 8.12), ('USB drive', 12.2), ('Headphones', 55.9), ('Smartwatch', 125.8)]
# Find index of maximum value in array
prices = [55.90, 12.20, 8.12, 99.80, 18.30]
index, price = max(enumerate(prices), key=itemgetter(1))
# 3, 99.8
# Sort list of tuples based on their indices
names = [
("John", "Doe"),
("Andy", "Jones"),
("Joseph", "Smith"),
("Oliver", "Smith"),
]
sorted(names, key=itemgetter(1, 0))
# [("John", "Doe"), ("Andy", "Jones"), ("Joseph", "Smith"), ("Oliver", "Smith")]
Methodcaller
Last function from operator module that needs to be mentioned is methodcaller. This function can be used to call a method on object using its name supplied as string:
from operator import methodcaller
methodcaller("rjust", 12, ".")("some text")
# "...some text"
column = ["data", "more data", "other value", "another row"]
[methodcaller("rjust", 12, ".")(value) for value in column]
# ["........data", "...more data", ".other value", ".another row"]
In the first example above we essentially use methodcaller to call "some text".rjust(12, ".") which right-justifies the string to length of 12 characters with . as fill character.
Using this function makes more sense for example in situations where you have a string name of the desired method and want supply the same arguments to it over and over again, as in the second example above.
Another more practical example for usage of methodcaller can be the following code. Here we feed lines of a text file to map function and we also pass it our desired method - in this case strip - which strips whitespaces from each of the lines. Additionally, we pass result of that to filter which removes all the empty lines (empty lines are empty string which are falsy, so they get removed by filter).
from operator import methodcaller
with open(path) as file:
items = list(filter(None, map(methodcaller("strip"), file.read().splitlines())))
print(items)
Closing Thoughts
In this article we took a quick tour of (in my opinion) an underrated operator module. This shows that even small module with just a couple of functions can be very useful in you daily Python programming tasks. There are many more useful modules in Python's standard library, so I recommend just checking module index and diving in. You can also checkout my previous articles which explore some of these modules such as itertools or functools.
Top comments (3)
Thanks for this post! I noticed that
itemgetter("x")(dict(x=10, y=20))would return a single element (10), whileitemgetter("x", "y")(dict(x=10, y=20))returns a tuple. Do you happen to know a way to streamline this and force it to always return the same type (i.e. a tuple)?Fantasic post, that just keeps giving more and more nuggets.
Great post, Martin! Saving it for future reference.