What does operator.methodcaller('rjust', 8, '0') do when applied to a string?

`operator.methodcaller` completes the trio in the `operator` module. - `itemgetter` subscripts, - `attrgetter` reads attributes, - and `methodcaller` **calls a method by name and returns its result**. `methodcaller('rjust', 8, '0')` produces a callable that, applied to `'42'`, evaluates `'42'.rjust(8, '0')` and returns `'00000042'`. ## What is fixed and what is late The first argument is the method's name as a string; everything after it — positional and keyword alike — is stored and passed through on each call. All of that is captured once, at construction. What is deliberately *not* fixed is the receiver, and therefore the method itself: the operand you pass in supplies it. `methodcaller('rjust', 8, '0')` does not point at `str.rjust`; it points at *whatever* `rjust` the operand happens to expose. That makes it polymorphic in the ordinary Python way — the same caller applied to instances of two unrelated classes calls each class's own implementation, which is exactly what you want when mapping one operation over a heterogeneous collection, and exactly what makes it fail with `AttributeError` the moment an element lacks the method. ## Keyword arguments are supported - `methodcaller('sort', reverse=True)` applied to a list calls `lst.sort(reverse=True)` in place — and returns `None`, because that is what `list.sort` returns. - `methodcaller('get', 'id', -1)` applied to a dict calls `d.get('id', -1)`, giving you a defaulted lookup that `itemgetter` cannot express. That combination — a named method plus fixed arguments — is the whole value proposition. ## The captured arguments are shared Because the arguments are stored once on the object, a mutable one is the *same object* every call. A caller built as `methodcaller('extend', buf)` passes the identical `buf` list to every operand, and mutations to it are visible everywhere. This is the same class of surprise as any value captured once and reused, and it is the reason to keep the bound arguments immutable — numbers, strings, tuples — unless sharing is genuinely what you mean. ## Against attrgetter, and against functools.partial Two contrasts pin the concept down. - **Against `attrgetter`.** `attrgetter('strip')(s)` returns the **bound method object** `s.strip`, uncalled; you would still have to invoke it. `methodcaller('strip')(s)` returns the **stripped string**. Confusing the two produces the classic bug where a collection is sorted by a bunch of method objects — which are not comparable — instead of by their results. - **Against `functools.partial`:** `partial` binds arguments to a **specific function object** you already have in hand, so `partial(str.rjust, width=8)` is tied to `str.rjust` and to nothing else, whereas `methodcaller` binds a **name** that is resolved on each operand. `partial` fixes the callee and leaves the receiver free only if you pass the unbound function explicitly; `methodcaller` is the version that reads naturally when the receiver is the thing that varies. ## Where it shows up Anywhere a small one-argument callable is required and the operation is 'call this method on it': the `key=` argument of sorting helpers, a mapping over a sequence, a callback slot, a table of operations. It is genuinely the least-used of the three factories, because 'call a method with fixed arguments' is a mouthful in string form and an inline function often reads better — `methodcaller('rjust', 8, '0')` is not obviously clearer than writing the call out. Its edge appears when the callable must be **stored, compared or shipped**: a `methodcaller` is an instance of a real importable type that can be serialized, so it survives being sent to a worker process or held in a configuration table, which an anonymous inline function does not. ## Failure modes to name in an interview 1. A missing method raises `AttributeError` when the caller is applied, not when it is built — nothing is resolved at construction, so a typo in the method name lies dormant until the first call. 2. Wrong arguments raise the ordinary `TypeError` from the method itself. 3. And returning `None` from an in-place method such as `list.sort` or `list.append` catches people who expect a fluent, chainable result — the caller returns whatever the method returned, faithfully including `None`. ## The judgement call Reach for `methodcaller` when you need a reusable, serializable, declarative 'call this named method' object. Write the call out longhand when it is used once, in one place, and clarity matters more than the object's portability.