blocks|key|237326|text|从类的主体是没有办法的；从self可用的上下文(或类本身)，您可以检查__bases__。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|237327|entityMap^0|Z|9|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|$]]

There is no way from the body of the class; from a context in which self is available (or the class itself), you can examine <code>__bases__</code>.

blocks|key|237329|text|你不能这么做。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|237330|类定义在Python中的工作方式如下。|237331|237332|解释器看到一条class语句，后面跟着一段代码。|ordered-list-item|offset|length|style|CODE|237333|它创建一个新的命名空间并执行该命名空间中的代码。|237334|它使用生成的命名空间、类名、基类和元类调用type内置(如果将结果分配给类的名称。|237335|<+code+>G211|237336|在类定义中运行代码时，您不知道基类是什么，因此无法获取它们的属性。|237337|您可以做的是在定义类之后立即修改它。|237338|237339|编辑:这是一个小的类装饰器，你可以用它来更新属性。这个想法是你给它一个名字和一个函数。它会遍历您的类的所有基类，并获取具有该名称的属性。然后，它使用从基类继承的值列表和您在子类中定义的值调用函数。此调用的结果绑定到名称。|237340|代码可能更有意义：|237341|>>>+def+inherit_attribute(name,+f):
...+++++def+decorator(cls):
...+++++++++++++old_value+=+getattr(cls,+name)
...+++++++++++++new_value+=+f([getattr(base,+name)+for+base+in+cls.__bases__],+old_value)
...+++++++++++++setattr(cls,+name,+new_value)
...+++++++++++++return+cls
...+++++return+decorator
...+
>>>+def+update_x(base_values,+my_value):
...++++return+sum(base_values+%2B+[my_value],+tuple())
...+
>>>+class+Foo:+x+=+(1,)
...+
>>>+@inherit_attribute('x',+update_x)
...+class+Bar(Foo):+x+=+(2,)
...+
>>>+Bar.x
(1,+2)|code-block|syntax|javascript|237342|其想法是在Bar中将x定义为(2,)。然后，装饰器将遍历Bar的子类，找到它们的所有x，并使用它们调用update_x。因此，它将调用|237343|update_x([(1,)],+(2,))|237344|它通过连接它们来将它们组合在一起，然后再次将它们绑定回x。这有意义吗？|237345|entityMap^0|0|0|0|7|5|0|0|L|4|0|0|0|0|0|0|0|0|5|3|A|1|E|4|S|3|16|1|1F|8|0|0|R|1|0^^$0|@$1|2|3|4|5|6|7|1D|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1E|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]|$1|E|3|F|5|G|7|1G|8|@$H|1H|I|1I|J|K]]|9|@]|A|$]]|$1|L|3|M|5|G|7|1J|8|@]|9|@]|A|$]]|$1|N|3|O|5|G|7|1K|8|@$H|1L|I|1M|J|K]]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1N|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|1O|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|1P|8|@]|9|@]|A|$]]|$1|V|3|-4|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1R|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1S|8|@]|9|@]|A|$]]|$1|10|3|11|5|12|7|1T|8|@]|9|@]|A|$13|14]]|$1|15|3|16|5|6|7|1U|8|@$H|1V|I|1W|J|K]|$H|1X|I|1Y|J|K]|$H|1Z|I|20|J|K]|$H|21|I|22|J|K]|$H|23|I|24|J|K]|$H|25|I|26|J|K]]|9|@]|A|$]]|$1|17|3|18|5|12|7|27|8|@]|9|@]|A|$13|14]]|$1|19|3|1A|5|6|7|28|8|@$H|29|I|2A|J|K]]|9|@]|A|$]]|$1|1B|3|-4|5|6|7|2B|8|@]|9|@]|A|$]]]|1C|$]]

You can't.

A class definition works in Python works as follows.

<ol>
<li>The interpreter sees a <code>class</code> statement followed by a block of code.</li>
<li>It creates a new namespace and executes that code in the namespace.</li>
<li>It calls the <code>type</code> builtin with the resulting namespace, the class name, the base classes, and the metaclass (if applicable).</li>
<li>It assigns the result to the name of the class.</li>
</ol>

While running the code inside the class definition, you don't know what the base classes are, so you can't get their attributes.

What you can do is modify the class immediately after defining it.

<hr>

EDIT: here's a little class decorator that you can use to update the attribute. The idea is that you give it a name and a function. It looks through all the base classes of your class, and gets their attributes with that name. Then it calls the function with the list of values inherited from the base class and the value you defined in the subclass. The result of this call is bound to the name.

Code might make more sense:

<pre><code>&gt;&gt;&gt; def inherit_attribute(name, f):
... def decorator(cls):
... old_value = getattr(cls, name)
... new_value = f([getattr(base, name) for base in cls.__bases__], old_value)
... setattr(cls, name, new_value)
... return cls
... return decorator
... 
&gt;&gt;&gt; def update_x(base_values, my_value):
... return sum(base_values + [my_value], tuple())
... 
&gt;&gt;&gt; class Foo: x = (1,)
... 
&gt;&gt;&gt; @inherit_attribute('x', update_x)
... class Bar(Foo): x = (2,)
... 
&gt;&gt;&gt; Bar.x
(1, 2)
</code></pre>

The idea is that you define <code>x</code> to be <code>(2,)</code> in <code>Bar</code>. The decorator will then go and look through the subclasses of <code>Bar</code>, find all their <code>x</code>s, and call <code>update_x</code> with them. So it will call

<pre><code>update_x([(1,)], (2,))
</code></pre>

It combines them by concatenating them, then binds that back to <code>x</code> again. Does that make sense?

blocks|key|2897790|text|您可以使用元类或类装饰器。下面是如何在Python+2.x中使用元类：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2897791|class+Klass(object):
++++my_list+=+[1,+2,+3]

class+KlassMeta(type):

++++def+__new__(cls,+name,+bases,+attrs):
++++++++#+grab+last+base+class,+which+in+this+case+is+Klass
++++++++attrs['my_list']+=+bases[-1].my_list+%2B+[4,+5]
++++++++return+super(KlassMeta,+cls).__new__(cls,+name,+bases,+attrs)

class+SubKlass(Klass):
++++__metaclass__+=+KlassMeta|code-block|syntax|javascript|2897792|在Python+3中，您将使用较新的语法声明元类：|2897793|class+SubKlass(Klass,+metaclass=KlassMeta):
++++pass|2897794|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|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

You could use a metaclass or a class decorator. Here's how you would use a metaclass in Python 2.x:

<pre><code>class Klass(object):
 my_list = [1, 2, 3]

class KlassMeta(type):

 def __new__(cls, name, bases, attrs):
 # grab last base class, which in this case is Klass
 attrs['my_list'] = bases[-1].my_list + [4, 5]
 return super(KlassMeta, cls).__new__(cls, name, bases, attrs)

class SubKlass(Klass):
 __metaclass__ = KlassMeta
</code></pre>

With Python 3 you'd declare the metaclass using the newer syntax:

<pre><code>class SubKlass(Klass, metaclass=KlassMeta):
 pass
</code></pre>

blocks|key|237364|text|正如你已经从其他回复中看到的那样，比如katriealex的回答:不，你不能。至少不容易。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|237365|问:你真正想做的是什么？|237366|问:为什么要这样做？|237367|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

As you've seen from the other responses such as katriealex's: No, you can't. At least not easily.

Q: What are you actually trying to do?

Q: Why do you want to do this?

blocks|key|2897824|text|正如@katrielalex回答的那样，在创建类之前，默认情况下my_list不在名称空间中。然而，在Python3中，如果您想深入研究元类，则可以手动将my_list添加到名称空间：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2897825|class+Meta(type):
++++def+__prepare__(name,+bases,+**kwds):
++++++++print("preparing+{}".format(name),+kwds)
++++++++my_list+=+[]
++++++++for+b+in+bases:
++++++++++++if+hasattr(b,+'my_list'):
++++++++++++++++my_list.extend(b.my_list)
++++++++return+{'my_list':+my_list}

class+A(metaclass=Meta):
++++my_list+=+["a"]

class+B(A):
++++my_list.append(2)

print(A().my_list)
print(B().my_list)|code-block|syntax|javascript|2897826|请注意，这个示例可能还没有很好地处理菱形继承结构。|2897827|在PEP+3115中定义了新的__prepare__属性。|2897828|entityMap|0|LINK|mutability|MUTABLE|url|https://www.python.org/dev/peps/pep-3115/^0|W|7|25|7|0|0|0|F|B|1|8|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|12|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|13|8|@$9|14|A|15|B|C]]|D|@$9|16|A|17|1|18]]|E|$]]|$1|O|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]]]

As answered by @katrielalex, <code>my_list</code> is not in the namespace by default before the class has been created. What you could do however in Python 3, if you want to dive into metaclasses, is to add <code>my_list</code> to the namespace manually:

<pre><code>class Meta(type):
 def __prepare__(name, bases, **kwds):
 print("preparing {}".format(name), kwds)
 my_list = []
 for b in bases:
 if hasattr(b, 'my_list'):
 my_list.extend(b.my_list)
 return {'my_list': my_list}

class A(metaclass=Meta):
 my_list = ["a"]

class B(A):
 my_list.append(2)

print(A().my_list)
print(B().my_list)
</code></pre>

Note that this example probably does not yet handle diamond-shaped inheritance structures well.

The new <code>__prepare__</code> attribute is defined in <a href="https://www.python.org/dev/peps/pep-3115/" rel="nofollow">PEP 3115</a>.

I have a class <code>Klass</code> with a class attribute <code>my_list</code>. I have a subclass of it <code>SubKlass</code>, in which i want to have a class attribute <code>my_list</code> which is a modified version of the same attribute from parent class:

<pre><code>class Klass():
 my_list = [1, 2, 3]


class SubKlass(Klass):
 my_list = Klass.my_list + [4, 5] # this works, but i must specify parent class explicitly
 #my_list = super().my_list + [4, 5] # SystemError: super(): __class__ cell not found
 #my_list = my_list + [4, 5] # NameError: name 'my_list' is not defined 


print(Klass.my_list)
print(SubKlass.my_list)
</code></pre>

So, is there a way to access parent class attribute without specifying its name?

UPDATE:

There is a bug on Python issue tracker: <a href="http://bugs.python.org/issue11339" rel="noreferrer">http://bugs.python.org/issue11339</a> . Let's hope it will be <a href="http://ericsnowcurrently.blogspot.com/2013/12/goals-for-python-35.html" rel="noreferrer">solved</a> at some point.

Accessing parent class attribute from sub-class body

解释器

Python

我有一个具有my_list属性的类Klass。我有一个SubKlass的子类，在这个子类中我想有一个类属性my_list，它是父类中相同属性的修改版本：class Klass():    my_list = [1, 2, 3]class SubKlass(Klass):    my_list = Klass.my_li...

问从子类体访问父类属性
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问从子类体访问父类属性EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问从子类体访问父类属性
EN