How Can I Bind Unbound Methods in Python Without Triggering Invocation?

Binding Unbound Methods Without Invocation

In Python, defining a class-level list of tuples where each tuple represents a button and its corresponding event handler can enhance data organization. However, binding unbound methods to an instance without triggering their execution can pose a challenge.

The issue arises when the event handler values are unbound methods, leading to runtime errors. While functools.partial offers a workaround, a more Pythonic approach is to exploit the descriptor behavior of functions.

Descriptors, including functions, have an __get__ method that, when called, binds the function to an instance. Utilizing this method, we can bind unbound methods as follows:

<code class="python">bound_handler = handler.__get__(self, MyWidget)</code>

This technique effectively binds the unbound method handler to the MyWidget instance without calling it.

Alternatively, a reusable function can encapsulate this binding logic:

<code class="python">def bind(instance, func, as_name=None):
    """
    Bind the function *func* to *instance*, with either provided name *as_name*
    or the existing name of *func*. The provided *func* should accept the 
    instance as the first argument, i.e. "self".
    """
    if as_name is None:
        as_name = func.__name__
    bound_method = func.__get__(instance, instance.__class__)
    setattr(instance, as_name, bound_method)
    return bound_method</code>

This function allows flexible binding with custom names:

<code class="python">something = Thing(21)

def double(self):
    return 2 * self.val

bind(something, double)
something.double()  # returns 42</code>

The above is the detailed content of How Can I Bind Unbound Methods in Python Without Triggering Invocation?. For more information, please follow other related articles on the PHP Chinese website!