Python：删除子类中的类属性

Question

我有一个子类，我希望它不包含基类上存在的类属性。

我尝试了这个，但它不起作用：

>>> class A(object):
...     x = 5
>>> class B(A):
...     del x
Traceback (most recent call last):
  File "<pyshell#1>", line 1, in <module>
    class B(A):
  File "<pyshell#1>", line 2, in B
    del x
NameError: name 'x' is not defined

我该怎么做？

Answer 1

您可以使用 delattr(class, field_name) 将其从类定义中删除。

Answer 2

你不需要删除它。只需覆盖它即可。

class B(A):
   x = None

或者干脆不引用它。

或者考虑不同的设计（实例属性？）。

Answer 3

没有一个答案对我有用。

例如，delattr(SubClass, "attrname")（或其完全相同的，del SubClass.attrname）不会“隐藏”父方法，因为这不是隐藏方法方法解析工作。它会失败，并显示 AttributeError('attrname',)，因为子类没有 attrname。当然，用 None 替换属性并不会真正删除它。

让我们考虑这个基类：

class Spam(object):
    # Also try with `expect = True` and with a `@property` decorator
    def expect(self):
        return "This is pretty much expected"

我只知道两种对其进行子类化的方法，即隐藏 expect 属性：

1. 使用 从 __get__ 引发 AttributeError。在属性查找时，会出现异常，通常与查找失败无法区分。

   最简单的方法就是声明一个引发AttributeError的属性。这基本上就是 @JBernardo 的建议。

   类西班牙宗教裁判所（垃圾邮件）：
       @财产
       def 期望（自我）：
           raise AttributeError("没有人预料到西班牙宗教裁判所！")
   
   断言 hasattr(Spam, "expect") == True
   # 断言 hasattr(SpanishInquisition, "expect") == False # 失败！
   断言 hasattr(SpanishInquisition(), "expect") == False
   

   但是，这仅适用于实例，不适用于类（hasattr(SpanishInquisition, "expect") == True 断言将被破坏）。

   如果您希望上述所有断言成立，请使用以下内容：

   类 AttributeHider(对象):
       def __get__(自身、实例、所有者):
           raise AttributeError("这不是您要查找的属性")
   
   西班牙宗教裁判所类（垃圾邮件）：
       期望 = AttributeHider()
   
   断言 hasattr(Spam, "expect") == True
   断言 hasattr(SpanishInquisition, "expect") == False # 有效！
   断言 hasattr(SpanishInquisition(), "expect") == False
   

   我相信这是最优雅的方法，因为代码清晰、通用且紧凑。当然，如果删除属性是他们真正想要的，那么应该真的三思而后行。

2. 使用 __getattribute__ 魔术方法覆盖属性查找 。您可以在子类（或 mixin，如下面的示例中，因为我只想编写一次）中执行此操作，这将隐藏子类实例上的属性。如果您还想对子类隐藏该方法，则需要使用元类。

   class ExpectMethodHider(对象):
       def __getattribute__(自身，名称)：
           如果名称==“期望”：
               raise AttributeError("没有人预料到西班牙宗教裁判所！")
           返回 super().__getattribute__(名称)
   
   类 ExpectMethodHidingMetaclass(ExpectMethodHider, 类型):
       经过
   
   # 我在这里使用了 Python 3.x，因此语法也是如此。
   # 对于 Python 2.x 使用 __metaclass__ = ExpectMethodHidingMetaclass
   西班牙宗教裁判所类（ExpectMethodHider，垃圾邮件，
                            元类=ExpectMethodHidingMetaclass）：
       经过
   
   断言 hasattr(Spam, "expect") == True
   断言 hasattr(SpanishInquisition, "expect") == False
   断言 hasattr(SpanishInquisition(), "expect") == False
   

   这看起来比上面的方法更糟糕（更冗长且不太通用），但人们也可以考虑这种方法。

   请注意，这不适用于特殊（“魔术”）方法（例如__len__），因为它们会绕过__getproperty__。查看 Python 文档的特殊方法查找部分更多细节。如果这是您需要撤消的，只需覆盖它并调用 object 的实现，跳过父级。

不用说，这只适用于“新式类”（从 object 继承的类），因为那里不支持魔术方法和描述符协议。希望这些都成为过去。

Answer 4

也许您可以将 x 设置为 property 并在有人尝试访问它时引发 AttributeError。

>>> class C:
        x = 5

>>> class D(C):
        def foo(self):
             raise AttributeError
        x = property(foo)

>>> d = D()
>>> print(d.x)
File "<pyshell#17>", line 3, in foo
raise AttributeError
AttributeError

Answer 5

仔细思考为什么要这样做；你可能不知道。考虑不要让 B 继承 A。

子类化的想法是专门化一个对象。特别是，类的子类应该是父类的有效实例：

>>> class foo(dict): pass
>>> isinstance(foo(), dict)
... True

如果您实现此行为（例如使用 x = property(lambda: AttributeError)），那么您就破坏了子类化概念，并且这是坏的。

Answer 6

我也遇到了同样的问题，我认为我有充分的理由删除子类中的类属性：我的超类（称之为 A）有一个提供属性值的只读属性，但在我的子类（称之为 B），该属性是一个读/写实例变量。我发现 Python 正在调用属性函数，尽管我认为实例变量应该覆盖它。我本可以创建一个单独的 getter 函数来用于访问底层属性，但这似乎对接口命名空间造成不必要且不雅的混乱（就好像这真的很重要一样）。

事实证明，答案是创建一个新的抽象超类（称之为 S），具有 A 的原始公共属性，并让 A 和 B 派生自 S。由于 Python 有鸭子类型，所以 B 是否这样做并不重要不扩展 A，我仍然可以在相同的地方使用它们，因为它们隐式实现相同的接口。

Answer 7

尝试这样做可能是一个坏主意，但是......

由于默认情况下查找 Bx 的工作方式，这似乎不是通过“正确的”继承来实现的。当获取 Bx 时，首先在 B 中查找 x，如果没有找到，则在 A 中搜索，但另一方面，当设置或删除Bx时，只会搜索B。例如，

>>> class A:
>>>     x = 5

>>> class B(A):
>>>    pass

>>> B.x
5

>>> del B.x
Traceback (most recent call last):
File "<stdin>", line 1, in <module>  
AttributeError: class B has no attribute 'x'

>>> B.x = 6
>>> B.x
6

>>> del B.x
>>> B.x
5

在这里我们看到，首先我们似乎无法删除 Bx 因为它不存在（Ax 存在，并且是当您评估时得到的服务Bx）。然而，通过将 Bx 设置为 6，Bx 将存在，它可以通过 Bx 检索并通过 del Bx 删除这样它就不再存在，因此之后 Ax 将再次作为对 Bx 的响应。

另一方面，您可以做的是使用元类使Bx引发AttributeError：

class NoX(type):
    @property
    def x(self):
        raise AttributeError("We don't like X")

class A(object):
    x = [42]

class B(A, metaclass=NoX):
    pass

print(A.x)
print(B.x)

现在纯粹主义者当然可能会大喊这破坏了LSP ，但事情没那么简单。这一切都归结为如果您认为您已经通过这样做创建了一个子类型。 issubclass 和 isinstance 方法表示“是”，但 LSP 表示“否”（并且许多程序员会假设“是”，因为您是从 A 继承的）。

LSP 意味着如果 B 是 A 的子类型，那么只要我们可以使用 A，我们就可以使用 B，但由于我们在执行此构造时无法执行此操作，因此我们可以得出结论，B 实际上不是 A 的子类型，因此没有违反 LSP。