On 9/17/22, Chris Angelico <rosuav@gmail.com> wrote:
>
> A method IS a function. A bound method is a function with one argument
> locked in, but still a function.

We were talking past each other. A method object is not a function
object. You're talking about a function defined in a class that's
accessed as a method of an instance of the class. In the class, that's
just a function object; it's exactly a function, not merely
fundamentally the same thing as one. It's only when accessed as an
attribute of an instance of the type that the function's descriptor
__get__() method is called to bind it and the instance to a method
object that sets the instance as its __self__ and the function as its
__func__.

Eryk Sun <eryksun@gmail.com> writes:
>We were talking past each other. A method object is not a function
>object.

The following code investigates whether the results of
the various substitutions actually have the method type.

main.py

import types
import functools

class example_class():
def method_original( self ): pass
def method_methodtype( self ): pass
def method_partial( self ): pass
def method_get( self ): pass

instance = example_class()

def new_method( self, param ): pass

instance.method_methodtype =\
types.MethodType( new_method, instance )

instance.method_partial =\
functools.partial(new_method, instance )

instance.method_get =\
new_method.__get__( instance )

print\
( "method_original ",
isinstance( instance.method_original, types.MethodType ))

print\
( "method_methodtype ",
isinstance( instance.method_methodtype, types.MethodType ))

print\
( "method_partial ",
isinstance( instance.method_partial, types.MethodType ))

print\
( "method_get ",
isinstance( instance.method_get, types.MethodType ))

print()

print\
( "method_original ",
type( instance.method_original ))

print\
( "method_methodtype ",
type( instance.method_methodtype ))

print\
( "method_partial ",
type( instance.method_partial ))

print\
( "method_get ",
type( instance.method_get ))

output

method_original True
method_methodtype True
method_partial False
method_get True

method_original <class 'method'>
method_methodtype <class 'method'>
method_partial <class 'functools.partial'>
method_get <class 'method'>

ram@zedat.fu-berlin.de (Stefan Ram) writes (abbreviated):
>types.MethodType( function, instance )
>functools.partial( function, instance )
>new_method.__get__( instance )

I wonder which of these three possibilities expresses
the idea of creating a new method from a function and
an instance most clearly.

On 9/18/22, Stefan Ram <ram@zedat.fu-berlin.de> wrote:
> ram@zedat.fu-berlin.de (Stefan Ram) writes (abbreviated):
>>types.MethodType( function, instance )
>>functools.partial( function, instance )
>>new_method.__get__( instance )
>
> I wonder which of these three possibilities expresses
> the idea of creating a new method from a function and
> an instance most clearly.

Using types.MethodType(function, instance) is the most clear and
correct of the three. Using the function's descriptor __get__() method
is equivalent in terms of the result. That said, the descriptor
protocol is an intermediate-level concept, so manually calling
__get__() isn't friendly to novices or casual users of the language.

Using a functools.partial isn't the expected method type, with
__func__ and __self__ attributes, and, unlike a method, it doesn't
expose the wrapped function's __code__, __name__, __module__, __doc__,
__annotations__, __defaults__, __kwdefaults__, __closure__,
__globals__, or __builtins__. If dynamic inspection matters, using a
functools.partial won't work directly with dis.dis(),
inspect.getfile(), inspect.getsource(), inspect.getdoc(),
inspect.get_annotations(), inspect.getcallargs(), or
inspect.getclosurevars().

On 2022-09-18 at 09:11:28 +0000,
Stefan Ram <ram@zedat.fu-berlin.de> wrote:

> ram@zedat.fu-berlin.de (Stefan Ram) writes (abbreviated):
> >types.MethodType( function, instance )
> >functools.partial( function, instance )
> >new_method.__get__( instance )
>
> I wonder which of these three possibilities expresses
> the idea of creating a new method from a function and
> an instance most clearly.

The first one. And only the first one.

The second one requires too much inside knowledge of Python to make the
leap from currying to instance method.

The third one doesn't even mention the function. Also, in Python, if
I'm applying dunder methods directly (it's okay to write them), then I'm
doing something wrong.

On 9/19/22, 2QdxY4RzWzUUiLuE@potatochowder.com
<2QdxY4RzWzUUiLuE@potatochowder.com> wrote:
> On 2022-09-18 at 09:11:28 +0000,
> Stefan Ram <ram@zedat.fu-berlin.de> wrote:
>
>> ram@zedat.fu-berlin.de (Stefan Ram) writes (abbreviated):
>> >types.MethodType( function, instance )
>> >functools.partial( function, instance )
>> >new_method.__get__( instance )
>>
>> I wonder which of these three possibilities expresses
>> the idea of creating a new method from a function and
>> an instance most clearly.
>
> The first one. And only the first one.
>
> The second one requires too much inside knowledge of Python to make the
> leap from currying to instance method.
>
> The third one doesn't even mention the function.

The OP's example named the function "new_method". In general the third
case would be func.__get__(instance). It's how the interpreter binds a
new method when a function from the class hierarchy is accessed as an
instance attribute.

When a function from the class hierarchy is accessed as an attribute
of the class, it's equivalent to calling func.__get__(None, cls),
which just returns a reference to the function. To use the descriptor
protocol to bind a function as a method of the class requires wrapping
it with the classmethod descriptor type. For example,
classmethod(func).__get__(None, cls) returns a method object with
__self__ that references the cls type. Of course, calling
types.MethodType(func, cls) is easier to understand and the preferred
way.