Python复合模式异常处理& 皮林特

发布于 2024-07-26 18:30:34 字数 1003 浏览 12 评论 0原文

1）“抽象”组件是：

class Component(object):
    """Basic Component Abstraction"""
    def __init__(self, *args, **kw):
        raise NotImplementedError("must be subclassed")

    def status(self):
        """Base Abstract method"""
        raise NotImplementedError("must be implemented")

2）叶子：

class Leaf(Component):
    """Basic atomic component
    """
    def __init__(self, *args, **kw):
        self.dict = {}

    def status(self):
        """Retrieves properties
        """
        return self.dict

问题是 pylint 当然会生成此警告：

Leaf.__init__: __init__ method from base class 'Component' is not called

但在我的叶子中，我无法调用：

def __init__(self, *args, **kw):
    Component.__init__(self, *args, **kw)
    self.dict = {}

不引发异常。

我必须忽略 pylint 警告还是存在一些错误的编码？

原文

I'm implementig a Composite pattern in this way:

1) the "abstract" component is:

class Component(object):
    """Basic Component Abstraction"""
    def __init__(self, *args, **kw):
        raise NotImplementedError("must be subclassed")

    def status(self):
        """Base Abstract method"""
        raise NotImplementedError("must be implemented")

2) a leaf:

class Leaf(Component):
    """Basic atomic component
    """
    def __init__(self, *args, **kw):
        self.dict = {}

    def status(self):
        """Retrieves properties
        """
        return self.dict

The Problem is that pylint generates, of course, this warning:

Leaf.__init__: __init__ method from base class 'Component' is not called

but into my Leaf i cannot call for:

def __init__(self, *args, **kw):
    Component.__init__(self, *args, **kw)
    self.dict = {}

without raise of the exception.

Must I ignore pylint warning or there is some bad coding?

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

梦回旧景 2024-08-02 18:30:34

抽象初始化器是一个坏主意。您的代码可能会演变，以便您想要在根组件中进行一些初始化。即使您不知道为什么需要实现初始化程序。对于某些子类，空的初始值设定项是可以接受的选择。

如果您不需要 Component 类的任何实例，请在初始化程序中检查：

class Component(object):
    def __init__(self, **kwargs):
        assert type(self) != Component, "Component must not be instantiated directly"

class Leaf(Component):
    def __init__(self, some, args, **kwargs):
        # regular initialization
        Component.__init__(self, **kwargs)

Abstract initializers are a bad idea. Your code might evolve so that you want to do some initialization in the root component. And even if you don't why require the implementation of the initializer. For some subclasses an empty initializer would be an acceptable choice.

If you don't want any instances of the Component class around, check for that in the initializer:

class Component(object):
    def __init__(self, **kwargs):
        assert type(self) != Component, "Component must not be instantiated directly"

class Leaf(Component):
    def __init__(self, some, args, **kwargs):
        # regular initialization
        Component.__init__(self, **kwargs)

回复收藏 0 原文

幸福丶如此 2024-08-02 18:30:34

补充 Markus 想法的另一个建议：

如果您确实必须这样做，我建议您使用 __new __ 并检查给定的对象类型。当它是“Component”时，您可以触发异常：

class Component(object):
"""Basic Component Abstraction"""

def __new__(objType, *args, **kwargs):
    if objType == Component:
       raise NotImplementedError("must be subclassed")
    return object.__new__(type, *args, **kwargs)

创建子类时，objType 将是！= Component，一切都会好起来的！

Another suggestion to complement the idea of Markus:

If you really must, I suggest that you use __new __ and check for the given object type. When it is "Component" you could fire your exception:

class Component(object):
"""Basic Component Abstraction"""

def __new__(objType, *args, **kwargs):
    if objType == Component:
       raise NotImplementedError("must be subclassed")
    return object.__new__(type, *args, **kwargs)

When a subclass is created, objType will be != Component and all will be fine!

回复收藏 0 原文