Question

我有一个表示接口的抽象基类。此类的子类存储为此类的其他子类的属性。

例如：

class AbstractBase(object):
    pass

class Child(AbstractBase):
    def __init__(self, cls1, cls2):
        assert isinstance(cls1, AbstractBase)
        assert isinstance(cls2, AbstractBase) # just to show they're instances

        self.cls1 = cls1
        self.cls2 = cls2

层次结构的深度和布局无法事先知道，但不会递归。

我可以将__repr__放在AbstractBase上，以便让我以有用的方式看待每个儿童班的特性？

我目前的做法是：

from pprint import pformat

class AbstractBase(object):
    def __repr__(self):
        return self.__class__.__name__ + '\n' \ 
                + pformat({k:v for k,v in self.__dict__.iteritems()
                           if not '__' in k})

对于基类（没有属性为AbstractBase的子类，这会输出可读的内容，例如：

MyClass
{'var1': 1,
 'var2': 2}

但是，对于具有AbstractBase子类的类，它会中断，因为很难判断父类的起始位置和另一个结束的位置（假设嵌套的进一步级别未被进一步缩进）上面的__repr__。

我对下面的内容感到满意，想象cls1和cls2有一个int属性var：

Child
{'cls1': {
          'var': 1,
         },
 'cls2': {
          'var': 0,
         }
}

可悲的是，我不知道如何实现这一目标（或者如果可能的话）。有什么想法吗？

Answer 1

我喜欢我这样做的方式：

class AbstractBase(object):
    def __repr__(self, indent=2):
        result = self.__class__.__name__ + '\n'
        for k,v in self.__dict__.iteritems():
            if k.startswith('__'):
                continue
            if isinstance(v, AbstractBase):
                vStr = v.__repr__(indent + 2)
            else:
                vStr = str(v)
            result += ' '*indent + k + ': ' + vStr
        result += '\n'
        return result

Answer 2

这是John Zwinck提出的稍微修改过的版本。

它考虑如何格式化序列，并稍微改变格式。尽管如此，它目前并不完美 - 我认为特别是它会破坏字典，因为可迭代组件只会打印密钥。

   def __repr__(self, indent=2):
        result = self.__class__.__name__ + '\n'
        items = self.__dict__.items()

        for i,(k,v) in enumerate(items):
            if '__' in k:   
                continue    
            if isinstance(v, AbstractBase):
                vStr = '\n' + ' '*(indent + 2) + v.__repr__(indent + 4)
            elif isinstance(v, collections.Iterable):
                s = str(v)
                bstart = s[0]
                bend = s[-1]

                newIndent = indent + 3
                vStr = '\n' + ' '*(newIndent - 1) + bstart
                for j,item in enumerate(v):
                    if isinstance(item, AbstractBase):
                        if j:
                            vStr += ' '*newIndent
                        vStr += item.__repr__(newIndent + 2)
                    else:    
                        vStr += repr(item)
                    vStr += ',\n'
                vStr += ' '*(newIndent - 1) + bend
            else:              
                vStr = str(v)  
            result += ' '*indent + k + ': ' + vStr

            if i != len(items) - 1:
                result += '\n'

        result = re.sub('\n+', '\n', result)
        return result

嵌套类实例的有用默认repr

2 个答案:

嵌套类实例的有用默认__repr__

2 个答案:

嵌套类实例的有用默认repr