Python3 operator

Function forms of every operator, itemgetter/attrgetter, and why they beat lambdas in hot paths.

Intermediate
Key Points`operator.itemgetter` is faster and picklable compared with an equivalent lambda — use it for sorting and grouping keys.

Operators as Functions

Python
import operator as op

op.add(2, 3)          # 5
op.mul(2, 3)          # 6
op.truediv(7, 2)      # 3.5
op.floordiv(7, 2)     # 3
op.mod(7, 2)          # 1
op.pow(2, 10)         # 1024
op.neg(5)             # -5
op.not_(True)         # False
op.contains([1, 2], 2)   # True
op.getitem({"a": 1}, "a")  # 1

itemgetter / attrgetter

These build key functions without a lambda. They are implemented in C, so they are faster, and they survive pickling — which matters for multiprocessing.

Python
from operator import itemgetter, attrgetter, methodcaller

rows = [{"name": "b", "age": 30}, {"name": "a", "age": 25}]

rows.sort(key=itemgetter("age"))
rows.sort(key=itemgetter("age", "name"))       # 多级排序

class P:
    def __init__(self, x, y):
        self.x, self.y = x, y

pts = [P(1, 2), P(0, 5)]
pts.sort(key=attrgetter("x"))

upper = methodcaller("upper")
upper("abc")                                    # 'ABC'

With reduce and map

Python
from functools import reduce
from operator import add, mul

reduce(add, [1, 2, 3, 4])      # 10
reduce(mul, [1, 2, 3, 4])      # 24

# 按字段求和
sum(map(itemgetter("amount"), orders))
Lambdaoperator
lambda r: r['age']itemgetter('age')
lambda p: p.xattrgetter('x')
lambda s: s.upper()methodcaller('upper')
lambda a, b: a + badd
For multiprocessing, a lambda as key= cannot be pickled and will fail. itemgetter can.

Friends & Partners