blocks|key|1396322|text|你不需要删除它。就推翻它吧。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1396323|class+B(A):
+++x+=+None|code-block|syntax|javascript|1396324|或者干脆不引用它。|1396325|或者考虑不同的设计(实例属性？)。|1396326|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

You don't need to delete it. Just override it. 

<pre><code>class B(A):
 x = None
</code></pre>

or simply don't reference it.

Or consider a different design (instance attribute?).

blocks|key|2593608|text|也许您可以将x设置为property，并在有人试图访问它时提高AttributeError。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2593609|>>>+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|code-block|syntax|javascript|2593610|entityMap^0|6|1|A|8|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

Maybe you could set <code>x</code> as <code>property</code> and raise AttributeError whenever someone try to access it.

<pre><code>&gt;&gt;&gt; class C:
 x = 5

&gt;&gt;&gt; class D(C):
 def foo(self):
 raise AttributeError
 x = property(foo)

&gt;&gt;&gt; d = D()
&gt;&gt;&gt; print(d.x)
File "&lt;pyshell#17&gt;", line 3, in foo
raise AttributeError
AttributeError
</code></pre>

blocks|key|2593667|text|仔细想想你为什么要这样做；你可能不这么做。考虑一下不要让B继承A。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2593668|子类化的思想是专门化一个对象。尤其是，类的子类应该是父类的有效实例：|2593669|>>>+class+foo(dict):+pass
>>>+isinstance(foo(),+dict)
...+True|code-block|syntax|javascript|2593670|如果您实现了这个行为(例如，x+=+property(lambda:+AttributeError))，那么您就破坏了子类概念，这是很糟糕的。|offset|length|style|CODE|2593671|entityMap^0|0|0|0|E|10|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@$K|U|L|V|M|N]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Think carefully about why you want to do this; you probably don't. Consider not making B inherit from A.

The idea of subclassing is to specialise an object. In particular, children of a class should be valid instances of the parent class:

<pre><code>&gt;&gt;&gt; class foo(dict): pass
&gt;&gt;&gt; isinstance(foo(), dict)
... True
</code></pre>

If you implement this behaviour (with e.g. <code>x = property(lambda: AttributeError)</code>), you are breaking the subclassing concept, and this is Bad.

blocks|key|2593691|text|我也遇到了同样的问题，我认为我有一个有效的理由来删除子类中的class属性:我的超类(称为A)有一个提供属性值的只读属性，但是在我的子类(称为B)中，该属性是一个读/写实例变量。我发现Python正在调用属性函数，尽管我认为实例变量应该重写它。我本可以创建一个单独的getter函数，用于访问底层属性，但这似乎是接口命名空间中不必要的、不优雅的混乱(似乎这真的很重要)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2593692|事实证明，答案是创建一个新的抽象超类(称为S)，它具有原始的公共属性A，并使A和B派生自S。因为Python有鸭子类型，所以B不扩展A并不重要，我仍然可以在相同的位置使用它们，因为它们隐式地实现了相同的接口。|2593693|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

I'm had the same problem as well, and I thought I had a valid reason to delete the class attribute in the subclass: my superclass (call it A) had a read-only property that provided the value of the attribute, but in my subclass (call it B), the attribute was a read/write instance variable. I found that Python was calling the property function even though I thought the instance variable should have been overriding it. I could have made a separate getter function to be used to access the underlying property, but that seemed like an unnecessary and inelegant cluttering of the interface namespace (as if that really matters).

As it turns out, the answer was to create a new abstract superclass (call it S) with the original common attributes of A, and have A and B derive from S. Since Python has duck typing, it does not really matter that B does not extend A, I can still use them in the same places, since they implicitly implement the same interface.

blocks|key|2593729|text|您可以使用delattr(class,+field_name)从类定义中删除它。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2593730|entityMap^0|5|Q|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

You can use <code>delattr(class, field_name)</code> to remove it from the class definition.

blocks|key|1396521|text|想这么做可能是个坏主意，但是.|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1396522|它似乎不是通过“适当”继承来实现的，因为默认情况下查找B.x是如何工作的。在获取B.x时，首先在B中查找x，如果在B中找不到，则在A中搜索，但是在设置或删除B.x时，只会搜索B。所以，例如|offset|length|style|CODE|1396523|>>>+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|code-block|syntax|javascript|1396524|这里我们看到，首先，我们似乎无法删除B.x，因为它不存在(A.x存在，是评估B.x时得到的服务)。但是，通过将B.x设置为6，B.x将存在，B.x可以检索它，而del+B.x则可以删除它，从而使它不再存在，因此在此之后，A.x将再次用作对B.x的响应。|1396525|另一方面，您可以做的是使用元类来使B.x提高AttributeError|1396526|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)|1396527|当然，纯粹主义者可能会大喊，这破坏了LSP，但并不是那么简单。归根结底，如果您认为您已经通过这样做创建了一个子类型。issubclass和isinstance方法说是，但LSP拒绝(而且许多程序员会假设“是”，因为您继承了A)。|1396528|LSP意味着如果B是A的一个子类型，那么只要我们可以使用A，我们就可以使用B，但是由于我们在执行这个构造时不能这样做，所以我们可以得出结论，B实际上不是A的一个子类型，因此LSP没有被违反。|1396529|entityMap^0|0|R|3|14|3|1C|1|1G|1|1L|1|1T|1|26|3|2F|1|0|0|I|3|T|3|12|3|1J|3|1R|3|1Y|3|28|7|32|3|3B|3|0|H|3|M|E|0|0|1M|A|1X|A|33|1|0|8|1|A|1|S|1|11|1|1Y|1|24|1|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@$D|10|E|11|F|G]|$D|12|E|13|F|G]|$D|14|E|15|F|G]|$D|16|E|17|F|G]|$D|18|E|19|F|G]|$D|1A|E|1B|F|G]|$D|1C|E|1D|F|G]|$D|1E|E|1F|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|1G|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|1H|8|@$D|1I|E|1J|F|G]|$D|1K|E|1L|F|G]|$D|1M|E|1N|F|G]|$D|1O|E|1P|F|G]|$D|1Q|E|1R|F|G]|$D|1S|E|1T|F|G]|$D|1U|E|1V|F|G]|$D|1W|E|1X|F|G]|$D|1Y|E|1Z|F|G]]|9|@]|A|$]]|$1|O|3|P|5|6|7|20|8|@$D|21|E|22|F|G]|$D|23|E|24|F|G]]|9|@]|A|$]]|$1|Q|3|R|5|J|7|25|8|@]|9|@]|A|$K|L]]|$1|S|3|T|5|6|7|26|8|@$D|27|E|28|F|G]|$D|29|E|2A|F|G]|$D|2B|E|2C|F|G]]|9|@]|A|$]]|$1|U|3|V|5|6|7|2D|8|@$D|2E|E|2F|F|G]|$D|2G|E|2H|F|G]|$D|2I|E|2J|F|G]|$D|2K|E|2L|F|G]|$D|2M|E|2N|F|G]|$D|2O|E|2P|F|G]]|9|@]|A|$]]|$1|W|3|-4|5|6|7|2Q|8|@]|9|@]|A|$]]]|X|$]]

Trying to do this is probably a bad idea, but...

It doesn't seem to be do this via "proper" inheritance because of how looking up <code>B.x</code> works by default. When getting <code>B.x</code> the <code>x</code> is first looked up in <code>B</code> and if it's not found there it's searched in <code>A</code>, but on the other hand when setting or deleting <code>B.x</code> only <code>B</code> will be searched. So for example

<pre><code>&gt;&gt;&gt; class A:
&gt;&gt;&gt; x = 5

&gt;&gt;&gt; class B(A):
&gt;&gt;&gt; pass

&gt;&gt;&gt; B.x
5

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

&gt;&gt;&gt; B.x = 6
&gt;&gt;&gt; B.x
6

&gt;&gt;&gt; del B.x
&gt;&gt;&gt; B.x
5
</code></pre>

Here we see that first we doesn't seem to be able to delete <code>B.x</code> since it doesn't exist (<code>A.x</code> exists and is what gets served when you evaluate <code>B.x</code>). However by setting <code>B.x</code> to 6 the <code>B.x</code> will exist, it can be retrieved by <code>B.x</code> and deleted by <code>del B.x</code> by which it ceases to exist so after that again <code>A.x</code> will be served as response to <code>B.x</code>.

What you could do on the other hand is to use metaclasses to make <code>B.x</code> raise <code>AttributeError</code>:

<pre><code>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)
</code></pre>

Now of course purists may yell that this breaks the LSP, but it's not that simple. It all boils down to if you consider that you've created a subtype by doing this. The <code>issubclass</code> and <code>isinstance</code> methods says yes, but LSP says no (and many programmers would assume "yes" since you inherit from <code>A</code>).

The LSP means that if <code>B</code> is a subtype of <code>A</code> then we could use <code>B</code> whenever we could use <code>A</code>, but since we can't do this while doing this construct we could conclude that <code>B</code> actually isn't a subtype of <code>A</code> and therefore LSP isn't violated.

blocks|key|2593899|text|所有的答案对我都没有用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2593900|例如，delattr(SubClass,+"attrname")+(或其完全等价的del+SubClass.attrname)不会“隐藏”父方法，因为这不是方法解析的工作方式。相反，它将在AttributeError('attrname',)中失败，因为子类没有attrname。当然，用None替换属性并不会实际删除它。|offset|length|style|CODE|2593901|让我们考虑这个基类：|2593902|class+Spam(object):
++++#+Also+try+with+`expect+=+True`+and+with+a+`@property`+decorator
++++def+expect(self):
++++++++return+"This+is+pretty+much+expected"|code-block|syntax|javascript|2593903|我只知道两种子类方法，即隐藏expect属性：|2593904|使用__get__的描述符类。在属性查找中，将出现异常，通常与查找失败没有区别。
最简单的方法就是声明一个引发AttributeError的属性。这本质上就是“JBernardo”所暗示的。
类SpanishInquisition(垃圾邮件)：@property+(Self)：引发AttributeError(“没人期望西班牙宗教裁判所！”)断言hasattr(垃圾邮件，"expect")+==+True+#+assert+(SpanishInquisition，"expect")+==+False+#失败！断言hasattr(SpanishInquisition()，"expect")+==+False
但是，这只适用于实例，而不适用于类(+hasattr(SpanishInquisition,+"expect")+==+True断言将被打破)。
如果您希望上述所有断言都为真，请使用以下命令：
类AttributeHider(对象)：def+__get__(self，实例，所有者)：引发AttributeError(“这不是您要寻找的属性”)类SpanishInquisition(垃圾邮件)：expect+=+AttributeHider()断言hasattr(垃圾邮件，"expect")+==+True+assert+hasattr(SpanishInquisition，"expect")+==+False+#+Works！断言hasattr(SpanishInquisition()，"expect")+==+False
我相信这是最优雅的方法，因为代码清晰、通用和紧凑。当然，如果删除属性是他们真正想要的，那么确实应该仔细考虑。|ordered-list-item|BOLD|2593905|重写属性查找魔术法。您可以在子类中(或者类似于下面的示例，我只想编写一次)来实现这一点，这将隐藏在子类实例上。如果您也想对子类隐藏该方法，则需要使用元类。
类ExpectMethodHider(对象)：def+__getattribute__(self，name)：如果名称==+"expect"：引发AttributeError(“没有人期望西班牙宗教裁判所！”)返回超级().__getattribute__(名称)类.__getattribute__类型)：pass+#我在这里使用了Python3.x，因此语法。#用于Python2.x使用__metaclass__+=+ExpectMethodHidingMetaclass+class+SpanishInquisition(ExpectMethodHider，Spam，metaclass=ExpectMethodHidingMetaclass)：传递断言hasattr(Spam，"expect")+==+True+assert+(SpanishInquisition，"expect")+==+False+assert+hasattr(SpanishInquisition()，"expect")+==+False
这看起来比上面的方法更糟糕(更详细，更不通用)，但是我们也可以考虑这种方法。
注意，不是在特殊(“魔术”)方法(例如__len__)上工作，因为这些方法绕过了__getproperty__。有关更多细节，请参阅Python中的特殊方法查找部分。如果这是您需要撤消的内容，只需重写它并调用object的实现，跳过父程序。|2593906|不用说，这只适用于“新样式类”(继承自object的类)，因为那里不支持神奇的方法和描述符协议。希望这些都是过去的事。|2593907|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3/reference/datamodel.html#object.__get__|1|https://docs.python.org/3/reference/datamodel.html#object.__getattribute__|2|https://docs.python.org/3/reference/datamodel.html#special-method-lookup^0|0|3|T|15|L|2M|R|3N|8|40|4|0|0|0|E|6|0|2|7|1J|E|92|19|JZ|8|2|7|0|0|G7|2|GN|7|H8|F|J0|6|6|3|1|I6|6|2|0|J|6|0^^$0|@$1|2|3|4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1B|8|@$D|1C|E|1D|F|G]|$D|1E|E|1F|F|G]|$D|1G|E|1H|F|G]|$D|1I|E|1J|F|G]|$D|1K|E|1L|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|1M|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|1N|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1O|8|@$D|1P|E|1Q|F|G]]|9|@]|A|$]]|$1|Q|3|R|5|S|7|1R|8|@$D|1S|E|1T|F|G]|$D|1U|E|1V|F|G]|$D|1W|E|1X|F|G]|$D|1Y|E|1Z|F|T]]|9|@$D|20|E|21|1|22]]|A|$]]|$1|U|3|V|5|S|7|23|8|@$D|24|E|25|F|T]|$D|26|E|27|F|G]|$D|28|E|29|F|G]|$D|2A|E|2B|F|G]]|9|@$D|2C|E|2D|1|2E]|$D|2F|E|2G|1|2H]]|A|$]]|$1|W|3|X|5|6|7|2I|8|@$D|2J|E|2K|F|G]]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|2L|8|@]|9|@]|A|$]]]|Z|$10|$5|11|12|13|A|$14|15]]|16|$5|11|12|13|A|$14|17]]|18|$5|11|12|13|A|$14|19]]]]

None of the answers had worked for me.

For example <code>delattr(SubClass, "attrname")</code> (or its exact equivalent, <code>del SubClass.attrname</code>) won't "hide" a parent method, because this is not how method resolution work. It would fail with <code>AttributeError('attrname',)</code> instead, as the subclass doesn't have <code>attrname</code>. And, of course, replacing attribute with <code>None</code> doesn't actually remove it.

Let's consider this base class:

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

I know only two only ways to subclass it, hiding the <code>expect</code> attribute:

<ol>
<li>Using a descriptor class that <a href="https://docs.python.org/3/reference/datamodel.html#object.__get__" rel="noreferrer">raises <code>AttributeError</code> from <code>__get__</code></a>. On attribute lookup, there will be an exception, generally indistinguishable from a lookup failure.

The simplest way is just declaring a property that raises <code>AttributeError</code>. This is essentially what @JBernardo had suggested.

<pre><code>class SpanishInquisition(Spam):
 @property
 def expect(self):
 raise AttributeError("Nobody expects the Spanish Inquisition!")

assert hasattr(Spam, "expect") == True
# assert hasattr(SpanishInquisition, "expect") == False # Fails!
assert hasattr(SpanishInquisition(), "expect") == False
</code></pre>

However, this only works for instances, and not for the classes (the <code>hasattr(SpanishInquisition, "expect") == True</code> assertion would be broken).

If you want all the assertions above to hold true, use this:

<pre><code>class AttributeHider(object):
 def __get__(self, instance, owner):
 raise AttributeError("This is not the attribute you're looking for")

class SpanishInquisition(Spam):
 expect = AttributeHider()

assert hasattr(Spam, "expect") == True
assert hasattr(SpanishInquisition, "expect") == False # Works!
assert hasattr(SpanishInquisition(), "expect") == False
</code></pre>

I believe this is the most elegant method, as the code is clear, generic and compact. Of course, one should really think twice if removing the attribute is what they really want.</li>
<li>Overriding attribute lookup <a href="https://docs.python.org/3/reference/datamodel.html#object.__getattribute__" rel="noreferrer">with <code>__getattribute__</code> magic method</a>. You can do this either in a subclass (or a mixin, like in the example below, as I wanted to write it just once), and that would hide attribute on the subclass instances. If you want to hide the method from the subclass as well, you need to use metaclasses.

<pre><code>class ExpectMethodHider(object):
 def __getattribute__(self, name):
 if name == "expect":
 raise AttributeError("Nobody expects the Spanish Inquisition!")
 return super().__getattribute__(name)

class ExpectMethodHidingMetaclass(ExpectMethodHider, type):
 pass

# I've used Python 3.x here, thus the syntax.
# For Python 2.x use __metaclass__ = ExpectMethodHidingMetaclass
class SpanishInquisition(ExpectMethodHider, Spam,
 metaclass=ExpectMethodHidingMetaclass):
 pass

assert hasattr(Spam, "expect") == True
assert hasattr(SpanishInquisition, "expect") == False
assert hasattr(SpanishInquisition(), "expect") == False
</code></pre>

This looks worse (more verbose and less generic) than the method above, but one may consider this approach as well.

Note, this does not work on special ("magic") methods (e.g. <code>__len__</code>), because those bypass <code>__getproperty__</code>. Check out <a href="https://docs.python.org/3/reference/datamodel.html#special-method-lookup" rel="noreferrer">Special Method Lookup</a> section of the Python documentation for more details. If this is what you need to undo, just override it and call <code>object</code>'s implementation, skipping the parent.</li>
</ol>

Needless to say, this only applies to the "new-style classes" (the ones that inherit from <code>object</code>), as magic methods and descriptor protocols aren't supported there. Hopefully, those are a thing of the past.

I have a subclass and I want it to not include a class attribute that's present on the base class.

I tried this, but it doesn't work:

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

How can I do this?

Python: deleting a class attribute in a subclass

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我有一个子类，我希望它不包括基类中存在的类属性。我试过了，但没用：>>> class A(object):... x = 5>>> class B(A):... del xTraceback (most recent call last): File "<pyshell#1>", line 1, in...

问Python:删除子类中的类属性
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python:删除子类中的类属性EN