将用户选择的方法添加到python中的元基类中

Question

I have base class that cannot be instanciated ( BaseFruit in my simplified example) and a few derived classes (for instance Apple in my example) that should all share a same method ( printfuture ). However, they are many possible variants, and I would like to let the user choose what variant should be used (for instance sadfuture and saddestfuture ).

As my printfuture method is common to all my derived class, I thought that it would be appropriated to catch the user argument for the variant with the __new__ method of my base class and assign the method to the base class itself. As written in the example below:

# my custom methods

def sadfuture(self):
    """A sad future"""
    print 'It looks {}!'.format(self.aspect)
    print 'Mmm yummy !'

def saddestfuture(self):
    """A saddest future"""
    print 'It looks {}'.format(self.aspect)
    print 'Garbage !'

# my base class

class BaseFruit(object):
    """Fruit base class"""
    def __new__(cls, *args, **kwargs):
        setattr(cls, 'printfuture', kwargs['usermethod'])
        return object.__new__(cls)

# My class

class Apple(BaseFruit):
   """An apple class"""
   def __init__(self, aspect, usermethod=sadfuture):
        self.aspect = aspect


if __name__ == '__main__':
    goodapple = Apple(aspect='delicious', usermethod=sadfuture)
    goodapple.printfuture() # ==> ok
    badapple = Apple(aspect='rotten', usermethod=saddestfuture)
    goodapple.printfuture() # ==> not ok anymore
    badapple.printfuture() # ==> ok

Which prints:

It looks delicious!
Mmm yummy !
It looks delicious
Garbage !
It looks rotten
Garbage !

instead of the expected behavior:

It looks delicious!
Mmm yummy !
It looks delicious!
Mmm yummy !
It looks rotten
Garbage !

I do understand that I have overwritten my base class and my first object has changed its behavior. So, my main question is: how can I achieve the expected behavior while keeping my custom methods out of the base class?

Comments on best practices and on proper designs for such problems are also welcome.

Answer 1

The "expected" behavior is truly what is actually printed. So, the behavior is not what "you were expecting", which is a different thing. Let's se why:

What you are doing is creating a new method on the instantiated class (in this case, Apple ) each time you mak ea new instance of Apple. The line setattr(cls, 'printfuture', kwargs['usermethod']) does exactly that, each time you create a new instance of BaseFruit or any subclass of it. (By the way, this line could be simply cls.printfuture = kwargs['usermethod'] , there is no need for setattr if the attribute name is hardcoded).

So, when you create your second instance of Apple , the call badapple = Apple(aspect='rotten', usermethod=saddestfuture) just make saddestfuture the printfuture for the Apple class to be saddestfuture , not just the method for badapple , but for any instance of Apple.

Fixing that has no need for a metaclass - you can use the code in __new__ itself to create a "pseudomethod", attached to the instance instead - as you intend. But you have to do that on the instance, after it is created, when you have a reference to the instance, not before instantiation, whenyou just have a reference to the class itself.

Since there is no actual code you need to run on before instatianting the class, you may as well bind the method-like function in __init__ , and leave customizing __new__ just for when it is really needed. And while at that, it won't hurt to use super instead of hardcoding the superclass's call:

...
# my base class

class BaseFruit(object):
    """Fruit base class"""
    def __init__(self, *args, **kwargs):
        printfuture = kwargs.pop('usermethod')
        super(BaseFruit, self).__init__(*args, **kwargs)
        # Wrap the call to the passed method in a function
        # that captures "self" from here, since Python do not 
        # insert "self" in calls to functions 
        # attributed to instances.
        self.printfuture = lambda: printfuture(self)


# My class

class Apple(BaseFruit):
   """An apple class"""
   def __init__(self, aspect, usermethod=sadfuture):
        super(Apple, self).__init__(usermethod)
        self.aspect = aspect

And as for metaclasses, this has no need for them - to the contrary, you have to customize each instance as it is created. We usually make use of metaclasses when we have to customize the class itself. Your original code is doing that (customizing the class itself), but the code for that is run when each instance is created, which made for the behavior you were not expecting. If the code to create the printfuture method where on the metaclass __new__ method instead, what is not the same as being in a superclass, that would happen just once, when each subclass is declared (and all instances of that subclass would share the same printifuture method).

Now, once you grasp how this works, please, just move to Python 3 to continue learning this stuff. Python 2 will be at complete end of line in 2 years from now, and will be useless in any prokect. One thing is having to keep legacy code in Python 2, another is learning or starting new projects - you should only use Python 3 for that.

Answer 2

I think that the problem is coming from the base class.

When you used the BaseFruit and used it as base class for the Apple-Class, python will assign any value that exist in the Apple-Class and the BaseFruit-Class directly to the BaseFruit Class. Since both 'apples' are based on the same Base Class, they share the values that come from this class.

When you set the saddestfuture as function to be executed you set it kind of 'globally' for all objects based on the BaseFruit-Class.

You need a line

self.userm = usermethod

in the __init__ of the apple . Then you pass this self.userm to the BaseClass as an kwarg and not the string "usermethod" .

I don't know excatly the syntax for this operation as I have not worked with python inheritance rules for a long time and I admit I have forgotten the syntax. Maybe somebody else can propose code in a comment or you find that out yourself :-) .