Using same function as instance and classmethod in python

Question

One can do something like this:

class master:
    @combomethod 
    def foo(param):
        param.bar() # Param could be type as well as object

class slaveClass( master ):
    @classmethod 
    def bar(cls):
        print("This is class method")

slaveType = slaveClass
slaveType.foo()

class slaveInstance( master ):
    def __init__(self, data):
        self.data = data
    def bar(self):
        print("This is "+self.data+" method")


slaveType = slaveInstance("instance")
slaveType.foo()

combomethod is defined in "Creating a method that is simultaneously an instance and class method".

My question is, why is it like this, that default first parameter can't be used as parameter of comboclass? Or at least, why can't I pass object to classmethod as the first parameter? I know the difference between classmethod and instancemethods, and I know decorators, but I might not understand how built-in @classmethod and self parameter passing is made. Is there a technical limitation? Or, why isn't combomethod allready built in?

Answer 1

use this:

class A(object):

    @classmethod
    def print(cls):
        print 'A'

    def __print(self):
        print 'B'

    def __init__(self):
        self.print = self.__print


a = A()
a.print()
A.print()

Answer 2

combomethod doesn't create a method object when accessed but a specially wrapped function. Like methods each access creates a new object, in this case a new function object.

class A:
    def __init__(self):
        self.data = 'instance'

    @combomethod 
    def foo(param):
        if isinstance(param, A):
            print("This is an " + param.data + " method.")
        elif param is A:
            print("This is a class method.")

>>> a = A()
>>> A.foo
<function foo at 0x00CFE810>
>>> a.foo
<function foo at 0x00CFE858>

>>> A.foo()
This is a class method.
>>> a.foo()
This is an instance method.

It's new for each access:

>>> A.foo is A.foo
False
>>> a.foo is a.foo
False

foo is really _wrapper in disguise:

>>> A.foo.__code__.co_name
'_wrapper'

When called from a class the closure has obj == None (note that 'self' here refers to the combomethod, which has a reference to the original function object in self.method):

>>> print(*zip(A.foo.__code__.co_freevars, A.foo.__closure__), sep='\n')
('obj', <cell at 0x011983F0: NoneType object at 0x1E1DF8F4>)
('self', <cell at 0x01198530: combomethod object at 0x00D29630>)
('objtype', <cell at 0x00D29D10: type object at 0x01196858>)

When called as the attribute of an instance, obj is the instance:

>>> print(*zip(a.foo.__code__.co_freevars, a.foo.__closure__), sep='\n')
('obj', <cell at 0x01198570: A object at 0x00D29FD0>)
('self', <cell at 0x01198530: combomethod object at 0x00D29630>)
('objtype', <cell at 0x00D29D10: type object at 0x01196858>)

Here is the original function stored in the combomethod:

>>> A.foo.__closure__[1].cell_contents.method
<function foo at 0x00D1CB70>
>>> A.foo.__closure__[1].cell_contents.method.__code__.co_name
'foo'

_wrapper executes self.method with either the class or instance as the first argument given the value of obj:

if obj is not None:
    return self.method(obj, *args, **kwargs)
else:
    return self.method(objtype, *args, **kwargs)