是否有像`lambda x，y：x.custom_method（y）`这样的标准功能代码？

Question

I know that I can call magic methods using functions from operator module, for example:

operator.add(a, b)

is equal to

a.__add__(b)

Is there a standard function for calling a custom method (like operator.methodcaller but also accepts method arguments when called)? Currently I have code like this:

def methodapply(name):
    """Apply a custom method.

    Usage:
        methodapply('some')(a, *args, **kwargs) => a.some(*args, **kwargs)

    """
    def func(instance, *args, **kwargs):
        return getattr(instance, name)(*args, **kwargs)
    func.__doc__ = """Call {!r} instance method""".format(name)
    return func

Answer 1

Yes, it is still called operator.methodcaller() :

Return a callable object that calls the method name on its operand. If additional arguments and/or keyword arguments are given, they will be given to the method as well. For example:

• After f = methodcaller('name') , the call f(b) returns b.name() .
• After f = methodcaller('name', 'foo', bar=1) , the call f(b) returns b.name('foo', bar=1) .

This inverts the chain a little from what you want; you need to tell methodcaller() up-front what arguments to pass in.

There is no standard-library callable that'll build a method caller that accepts both the instance and the arguments.

However, if your sequence of objects you are going to apply this to is homogenous, you can instead just use the unbound method; unbound methods take self as the first argument. So this works:

from itertools import 
map(str.split, list_of_strings, [','] * len(list_of_strings), range(len(list_of_strings)))

which will split strings on commas with a growing limit; each time map() calls str.split() (an unbound method), it'll pass in a str object from the list_of_strings list, a ',' string, and an integer argument ranging from 0 to len(list_of_strings) - 1 .