Python-为什么当我检查返回的对象不是NoneType时，此方法为什么返回NoneType？

Question

I have code in which all objects descend from a base object, which I don't plan to instantiate directly. In the __init__() method of my base object I'm trying to perform some magic -- I am trying to decorate, or wrap, every method of the object being initialized. But I'm getting a result that puzzles me when I call the resulting methods. Here is example code that isolates the problem:

class ParentObject(object):
    def __init__(self):
        self._adjust_methods(self.__class__)

    def _adjust_methods(self, cls):
        for attr, val in cls.__dict__.iteritems():
            if callable(val) and not attr.startswith("_"):
                setattr(cls, attr, self._smile_warmly(val))
        bases = cls.__bases__
        for base in bases:
            if base.__name__ != 'object':
                self._adjust_methods(base)

    def _smile_warmly(self, the_method):
        def _wrapped(cls, *args, **kwargs):
            print "\n-smile_warmly - " +cls.__name__
            the_method(self, *args, **kwargs)
        cmethod_wrapped = classmethod(_wrapped)
        return cmethod_wrapped

class SonObject(ParentObject):
    def hello_son(self):
        print "hello son"

    def get_sister(self):
        sis = DaughterObject()
        print type(sis)
        return sis

class DaughterObject(ParentObject):
    def hello_daughter(self):
        print "hello daughter"

    def get_brother(self):
        bro = SonObject()
        print type(bro)
        return bro

if __name__ == '__main__':
    son = SonObject()
    son.hello_son()

    daughter = DaughterObject()
    daughter.hello_daughter()

    sis = son.get_sister()
    print type(sis)
    sis.hello_daughter()

    bro = sis.get_brother()
    print type(bro)
    bro.hello_son()

The program crashes, however -- the line sis = son.get_sister() results in the sis object having a type of NoneType. Here is the output:

-smile_warmly - SonObject
hello son

-smile_warmly - DaughterObject
hello daughter

-smile_warmly - SonObject
<class '__main__.DaughterObject'>
<type 'NoneType'>
Traceback (most recent call last):
  File "metaclass_decoration_test.py", line 48, in <module>
    sis.hello_daughter()
AttributeError: 'NoneType' object has no attribute 'hello_daughter'

Why is this happening?

Answer 1

Try changing:

    def _wrapped(cls, *args, **kwargs):
        print "\n-smile_warmly - " +cls.__name__
        the_method(self, *args, **kwargs)

to

    def _wrapped(cls, *args, **kwargs):
        print "\n-smile_warmly - " +cls.__name__
        return the_method(self, *args, **kwargs)

Your _wrapped method is calling the method that is being wrapped, but not returning that method's return value.

Answer 2

Well, I don't really want to even touch the craziness that is going on in this code, but your error specifically is because your "decorator" is not returning anything from the wrapped function:

def _smile_warmly(self, the_method):
    def _wrapped(cls, *args, **kwargs):
        print "\n-smile_warmly - " +cls.__name__
        return the_method(self, *args, **kwargs) # return here
    cmethod_wrapped = classmethod(_wrapped)
    return cmethod_wrapped

Answer 3

The problem is that you are wrapping all methods of your classes, including get_sister . You could do as @Paul McGuire suggests and add the return to the wrapper, but that will mean that the "smile" message is printed when you call son.get_sister , which probably isn't what you want.

What you probably need to do instead is add some logic inside _adjust_methods to decide precisely which methods to wrap. Instead of just checking for callable and not startswith('_') , you could have some naming convention for ones you do or don't want to wrap with smile behavior. However, the more you do this, the less the automatic decoration will benefit you as compared to just manually decorating the methods you want to decorate. It's a little hard to understand why you want to use the structure you apparently want to use (all classmethods, wrapping everything, etc.). Perhaps if you explained what your ultimate goal is here someone could suggest a more straightforward design.

Moreover, even if you add the return or the extra logic for wrapping, you'll still have the problem I mentioned in your other question: since you do the wrapping in __init__ , it is going to happen every time you instantiate a class, so you will keep adding more and more wrappers. This is why I suggested there that you should use a class decorator, or, if you must, a metaclass. Messing with class attributes (including methods) in __init__ is not a good idea because they'll get messed with over and over, once for each instance you create.

Answer 4

The missing return in @PaulMcGuire's reply is the cause of the bug.

On a higher level, it looks like you're trying to do via inheritance what might more "commonly" (this is hardly a common approach) be done via a metaclass. Maybe something like this discussion of metaclasses would point you in a slightly more manageable direction.