How User-defined method objects are created?

[Joaquin Abian]

I'm trying to understand the description of method object creation in
the python 2.6 language reference (3.2. The standard type hierarchy)
with little success. The points knocking me are:

"User-defined method objects may be created when getting an attribute
of a class (perhaps via an instance of that class), if that attribute
is a user-defined function object, an unbound user-defined method
object, or a class method object. When the attribute is a user-defined
method object, a new method object is only created if the class from
which it is being retrieved is the same as, or a derived class of, the
class stored in the original method object; otherwise, the original
method object is used as it is."

It is a bit of a tongue-twister for me. What the last sentence means?
Please, I beg for a simple example of the different objects (user
defined function, user defined method, class method) refered.
Are maybe the refered objects exemplified by :

#python 3.1
class Klass():

def met(self):
print('method')

def func():
print('function')

@classmethod
def kmet(klass):
print('classmethod')

or it is talking about another thing?
What is the difference with python 3 where there is no mention to the
unbound user-defined method object (same section in python 3 language
reference):

"User-defined method objects may be created when getting an attribute
of a class (perhaps via an instance of that class), if that attribute
is a user-defined function object or a class method object."

I'm trying to learn, however the task is revealing as an enormous
undertaking

JA

 

[Terry Reedy]

I'm trying to understand the description of method object creation in
the python 2.6 language reference (3.2. The standard type hierarchy)
with little success. The points knocking me are:

"User-defined method objects may be created when getting an attribute
of a class (perhaps via an instance of that class), if that attribute
is a user-defined function object, an unbound user-defined method
object, or a class method object. When the attribute is a user-defined
method object, a new method object is only created if the class from
which it is being retrieved is the same as, or a derived class of, the
class stored in the original method object; otherwise, the original
method object is used as it is."

It is a bit of a tongue-twister for me. What the last sentence means?
Please, I beg for a simple example of the different objects (user
defined function, user defined method, class method) refered.
Are maybe the refered objects exemplified by :

#python 3.1
class Klass():

def met(self):
print('method')

def func():
print('function')

@classmethod
def kmet(klass):
print('classmethod')

or it is talking about another thing?
What is the difference with python 3 where there is no mention to the
unbound user-defined method object (same section in python 3 language
reference):

Python3 does not have unbound method objects. Klass.met above is just a
function.l

"User-defined method objects may be created when getting an attribute
of a class (perhaps via an instance of that class), if that attribute
is a user-defined function object or a class method object."

I'm trying to learn, however the task is revealing as an enormous
undertaking

One can successfully use the language in the normal way without
understanding every detail of every oddball corner case. Recent 2.x is
complicated by duplication (two user object systems) and
back-compatibility constraints. Most new users do not need to bother
with obsolete complications.

Terry Jan Reedy

 

[Joaquin Abian]

Python3 does not have unbound method objects. Klass.met above is just a
function.l



One can successfully use the language in the normal way without
understanding every detail of every oddball corner case. Recent 2.x is
complicated by duplication (two user object systems) and
back-compatibility constraints. Most new users do not need to bother
with obsolete complications.

Terry Jan Reedy

Terry, Right, I was just reading about this difference in 2 vs 3 in
Lutz's book.
Well, in fact in my case I'm not a newcomer to python (neither a
professional). I have been programming for more than 4 years in python
mainly medium size scientific data management applications. Currently
I can write at a moderate speed and Im familiar with properties,
decorators, etc.

That's why it is so frustrating went I get lost in the language
reference manual in a matter I wrongly though was a simple stuff.

Thanks for your helpful comments.

JA

 

[Joaquin Abian]

"User-defined method objects may be created when getting an attribute
of a class (perhaps via an instance of that class), if that attribute
is a user-defined function object, an unbound user-defined method
object, or a class method object. When the attribute is a user-defined
method object, a new method object is only created if the class from
which it is being retrieved is the same as, or a derived class of, the
class stored in the original method object; otherwise, the original
method object is used as it is."

It is a bit of a tongue-twister for me. What the last sentence means?
Please, I beg for a simple example of the different objects (user
defined function, user defined method, class method) refered.

        def foo(self): pass

        def bar(self): pass

<unbound method A.foo>>>> B.bar

<unbound method B.bar>>>> B.baz

<unbound method B.bar>>>> instance.foo

<unbound method A.foo>>>> instance.bar

<bound method B.bar of <__main__.B object at 0x00000000036B7780>>>>> instance.baz

<bound method B.bar of <__main__.B object at 0x00000000036B7780>>>>> B.__dict__['bar']

<function bar at 0x00000000036C5048>>>> B.__dict__['baz']

<unbound method B.bar>>>> B.__dict__['foo']

<unbound method A.foo>

So, we have a function 'bar' stored in B's dict. When you access the
function as the attribute B.bar Python 2.x will create an unbound method
object. When you access the function through instance.bar Python creates a
bound method. Note that every time you access instance.bar it creates
another new method object:

False

B.baz is an unbound method stored directly in B's dict. When you access
instance.baz you get a new bound method object (it's at the same memory
location as the previous one but that's only because the lifetimes don't
overlap). Somewhat suprisingly the same also happens if you access B.baz:
it creates a new unbound method from the existing unbound method:

B.bar is B.__dict__['bar']

False

B.foo is an unbound method stored directly in B's dict, but it is a method
of an A and B doesn't subclass A, so when you try to access B.foo you just
get the stored unbound method it isn't converted into a new object.

Thanks Duncan, I think I got the idea. Your explanation together with
the comment from Terry about the absence of unbound method objects in
python 3 cleared some dust from my neuron(s)
Thanks!
JA