类装饰器，继承，super（）和最大递归 [英] Class Decorators, Inheritance, super(), and maximum recursion

问题描述

我试图弄清楚如何在使用 super（）的子类上使用装饰器。由于我的类装饰器创建了另一个子类，因此装饰类似乎在更改 className 时阻止使用 super（）传递给 super（className，self）。下面是一个示例：

I'm trying to figure out how to use decorators on subclasses that use super(). Since my class decorator creates another subclass a decorated class seems to prevent the use of super() when it changes the className passed to super(className, self). Below is an example:

def class_decorator(cls):
    class _DecoratedClass(cls):
        def __init__(self):
            return super(_DecoratedClass, self).__init__()
    return _DecoratedClass

class BaseClass(object):
    def __init__(self):
        print "class: %s" % self.__class__.__name__
    def print_class(self):
        print "class: %s" % self.__class__.__name__

bc = BaseClass().print_class()

class SubClass(BaseClass):
    def print_class(self):
        super(SubClass, self).print_class()

sc = SubClass().print_class()

@class_decorator
class SubClassAgain(BaseClass):
    def print_class(self):
        super(SubClassAgain, self).print_class()

sca = SubClassAgain()
# sca.print_class() # Uncomment for maximum recursion

输出应为：

class: BaseClass
class: BaseClass
class: SubClass
class: SubClass
class: _DecoratedClass
Traceback (most recent call last):
File "class_decorator_super.py", line 34, in <module>
sca.print_class()
File "class_decorator_super.py", line 31, in print_class
super(SubClassAgain, self).print_class()
...
...
RuntimeError: maximum recursion depth exceeded while calling a Python object

时，超过了最大递归深度使用装饰器时不破坏使用 super（）的子类的一种方法？理想情况下，我想不时地重用一个类，并简单地对其进行装饰而不会破坏它。

Does anyone know of a way to not break a subclass that uses super() when using a decorator? Ideally I'd like to reuse a class from time to time and simply decorate it w/out breaking it.

推荐答案

装饰器造成一种钻石继承的情况。您可以通过不使用 super（）来避免这些问题。将 SubClassAgain 更改为以下内容将防止无限递归：

The decorator creates a kind-of diamond inheritance situation. You can avoid these problems by not using super(). Changing SubClassAgain to the following will prevent infinite recursion:

@class_decorator
class SubClassAgain(BaseClass):
    def print_class(self):
        BaseClass.print_class(self)

这篇关于类装饰器，继承，super（）和最大递归的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！