Distinguishing between functions and methods in a decorator.

[Diez B. Roggisch]

Berteun Damman schrieb:
> Hello,
> 
> I was wondering a bit about the differences between methods and
> functions. I have the following:
> 
> def wrap(arg):
>     print type(arg)
>     return arg
> 
> class C:
>     def f():
>         pass
> 
>     @wrap
>     def g():
>         pass
> 
> def h():
>     pass
> 
> print type(C.f)
> print type(h)
> 
> Which gives the following output:
> <type 'function'>
> <type 'instancemethod'>
> <type 'function'>
> 
> The first line is caused by the 'wrap' function of course. I had
> expected the first line to be 'instancemethod' too. So, I would guess,
> these methods of C are first created as functions, and only then become
> methods after they are 'attached' to some classobj. (You can do that
> yourself of course, by saying, for example, C.h = h, then the type of
> C.h is 'instancemethod' too.)
> 
> Why does the wrapping occur before the function is 'made' into an
> instancemethod?
> 
> The reason for asking is that I would like to differentiate between
> wrapping a function and an instancemethod, because in the latter case,
> the first parameter will be the implicit 'self', which I would like to
> ignore.  However, when the wrapping occurs, the method still looks like
> a function.

Can you provide an example of what you are actually after? The 
descriptor-protocol might come to use there.

Diez