blocks|key|290428|text|首先是一些基础知识。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|290429|对于对象，您需要处理它们的属性。通常，我们使用instance.attribute。有时我们需要更多的控制(当我们事先不知道属性的名称时)。|offset|length|style|CODE|290430|例如，instance.attribute将变为getattr(instance,+attribute_name)。使用此模型，我们可以通过以字符串形式提供attribute_name来获取属性。|290431|__getattr__的使用|290432|您还可以告诉一个类如何处理它没有显式管理的属性，并通过__getattr__方法来实现。|290433|当您请求一个尚未定义的属性时，Python将调用此方法，因此您可以定义如何处理它。|290434|一个经典的用例：|290435|class+A(dict):
++++def+__getattr__(self,+name):
+++++++return+self[name]
a+=+A()
#+Now+a.somekey+will+give+a['somekey']|code-block|syntax|javascript|290436|注意事项和__getattribute__的使用|290437|如果您需要捕获每个属性，而不管它是否存在，请改用__getattribute__。不同之处在于，只为实际不存在的属性调用__getattr__。如果直接设置属性，则引用该属性将在不调用__getattr__的情况下检索它。|290438|__getattribute__总是被调用。|290439|entityMap^0|0|N|I|0|3|I|O|X|0|0|B|0|R|B|0|0|0|0|5|G|0|O|G|1O|B|2K|B|0|0|G|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|15|8|@$D|16|E|17|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|18|8|@$D|19|E|1A|F|G]|$D|1B|E|1C|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|1D|8|@$D|1E|E|1F|F|G]]|9|@]|A|$]]|$1|L|3|M|5|6|7|1G|8|@$D|1H|E|1I|F|G]]|9|@]|A|$]]|$1|N|3|O|5|6|7|1J|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1K|8|@]|9|@]|A|$]]|$1|R|3|S|5|T|7|1L|8|@]|9|@]|A|$U|V]]|$1|W|3|X|5|6|7|1M|8|@$D|1N|E|1O|F|G]]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1P|8|@$D|1Q|E|1R|F|G]|$D|1S|E|1T|F|G]|$D|1U|E|1V|F|G]]|9|@]|A|$]]|$1|10|3|11|5|6|7|1W|8|@$D|1X|E|1Y|F|G]]|9|@]|A|$]]|$1|12|3|-4|5|6|7|1Z|8|@]|9|@]|A|$]]]|13|$]]

<h1>Some basics first.</h1>
With objects, you need to deal with their attributes. Ordinarily, we do <code>instance.attribute</code>. Sometimes we need more control (when we do not know the name of the attribute in advance).
For example, <code>instance.attribute</code> would become <code>getattr(instance, attribute_name)</code>. Using this model, we can get the attribute by supplying the attribute_name as a string.
<h1>Use of <code>__getattr__</code></h1>
You can also tell a class how to deal with attributes which it doesn't explicitly manage and do that via <code>__getattr__</code> method.
Python will call this method whenever you request an attribute that hasn't already been defined, so you can define what to do with it.
A classic use case:
<pre><code>class A(dict):
 def __getattr__(self, name):
 return self[name]
a = A()
# Now a.somekey will give a['somekey']
</code></pre>
<h1>Caveats and use of <code>__getattribute__</code></h1>
If you need to catch every attribute regardless whether it exists or not, use <code>__getattribute__</code> instead. The difference is that <code>__getattr__</code> only gets called for attributes that don't actually exist. If you set an attribute directly, referencing that attribute will retrieve it without calling <code>__getattr__</code>.
<code>__getattribute__</code> is called all the times.

blocks|key|287792|text|每当发生属性访问时，都会调用__getattribute__。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|287793|class+Foo(object):
++++def+__init__(self,+a):
++++++++self.a+=+1

++++def+__getattribute__(self,+attr):
++++++++try:
++++++++++++return+self.__dict__[attr]
++++++++except+KeyError:
++++++++++++return+'default'
f+=+Foo(1)
f.a|code-block|syntax|javascript|287794|这将导致无限递归。这里的罪魁祸首是return+self.__dict__[attr]行。让我们假设(这与事实非常接近)所有属性都存储在self.__dict__中，并按其名称可用。这条线|287795|f.a|287796|尝试访问f的a属性。这将调用f.__getattribute__('a')。然后，__getattribute__尝试加载self.__dict__。__dict__是self+==+f的一个属性，因此python调用f.__getattribute__('__dict__')，它再次尝试访问属性'__dict__‘。这是无限递归。|287797|如果使用了__getattr__，那么|287798|287799|它永远不会运行，因为f有一个它已经运行的a属性(假设您请求了f.b)，那么它就不会被调用来查找__dict__，因为它已经存在，并且只有当所有其他查找属性的方法都失败时，才会调用__getattr__。|ordered-list-item|287800|287801|使用__getattribute__编写上述类的“正确”方法是|287802|class+Foo(object):
++++#+Same+__init__

++++def+__getattribute__(self,+attr):
++++++++return+super(Foo,+self).__getattribute__(attr)|287803|super(Foo,+self).__getattribute__(attr)将“最近”超类的__getattribute__方法(正式地说，是该类的方法解析顺序中的下一个类)绑定到当前的对象self，然后调用它，让它来完成这项工作。|287804|所有这些麻烦都可以通过使用__getattr__来避免，它让Python做一些正常的事情，直到找不到属性为止。在这一点上，Python将控制权交给您的__getattr__方法，并让它提供一些东西。|287805|同样值得注意的是，使用__getattr__可能会遇到无限递归。|287806|class+Foo(object):
++++def+__getattr__(self,+attr):
++++++++return+self.attr|287807|我会把这个作为练习。|287808|entityMap^0|E|G|0|0|H|Q|1W|D|0|0|4|1|6|1|E|N|15|G|1P|D|23|8|2C|9|31|U|45|9|0|5|B|0|0|A|1|K|1|U|3|1B|8|2H|B|0|0|2|G|0|0|0|13|1B|G|2O|4|0|D|B|23|B|0|B|B|0|0|0^^$0|@$1|2|3|4|5|6|7|1D|8|@$9|1E|A|1F|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1G|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1H|8|@$9|1I|A|1J|B|C]|$9|1K|A|1L|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|1M|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1N|8|@$9|1O|A|1P|B|C]|$9|1Q|A|1R|B|C]|$9|1S|A|1T|B|C]|$9|1U|A|1V|B|C]|$9|1W|A|1X|B|C]|$9|1Y|A|1Z|B|C]|$9|20|A|21|B|C]|$9|22|A|23|B|C]|$9|24|A|25|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|26|8|@$9|27|A|28|B|C]]|D|@]|E|$]]|$1|S|3|-4|5|6|7|29|8|@]|D|@]|E|$]]|$1|T|3|U|5|V|7|2A|8|@$9|2B|A|2C|B|C]|$9|2D|A|2E|B|C]|$9|2F|A|2G|B|C]|$9|2H|A|2I|B|C]|$9|2J|A|2K|B|C]]|D|@]|E|$]]|$1|W|3|-4|5|6|7|2L|8|@]|D|@]|E|$]]|$1|X|3|Y|5|6|7|2M|8|@$9|2N|A|2O|B|C]]|D|@]|E|$]]|$1|Z|3|10|5|H|7|2P|8|@]|D|@]|E|$I|J]]|$1|11|3|12|5|6|7|2Q|8|@$9|2R|A|2S|B|C]|$9|2T|A|2U|B|C]|$9|2V|A|2W|B|C]]|D|@]|E|$]]|$1|13|3|14|5|6|7|2X|8|@$9|2Y|A|2Z|B|C]|$9|30|A|31|B|C]]|D|@]|E|$]]|$1|15|3|16|5|6|7|32|8|@$9|33|A|34|B|C]]|D|@]|E|$]]|$1|17|3|18|5|H|7|35|8|@]|D|@]|E|$I|J]]|$1|19|3|1A|5|6|7|36|8|@]|D|@]|E|$]]|$1|1B|3|-4|5|6|7|37|8|@]|D|@]|E|$]]]|1C|$]]

<code>__getattribute__</code> is called whenever an attribute access occurs.

<pre><code>class Foo(object):
 def __init__(self, a):
 self.a = 1

 def __getattribute__(self, attr):
 try:
 return self.__dict__[attr]
 except KeyError:
 return 'default'
f = Foo(1)
f.a
</code></pre>

This will cause infinite recursion. The culprit here is the line <code>return self.__dict__[attr]</code>. Let's pretend (It's close enough to the truth) that all attributes are stored in <code>self.__dict__</code> and available by their name. The line

<pre><code>f.a
</code></pre>

attempts to access the <code>a</code> attribute of <code>f</code>. This calls <code>f.__getattribute__('a')</code>. <code>__getattribute__</code> then tries to load <code>self.__dict__</code>. <code>__dict__</code> is an attribute of <code>self == f</code> and so python calls <code>f.__getattribute__('__dict__')</code> which again tries to access the attribute <code>'__dict__</code>'. This is infinite recursion.

If <code>__getattr__</code> had been used instead then 

<ol>
<li>It never would have run because <code>f</code> has an <code>a</code> attribute.</li>
<li>If it had run, (let's say that you asked for <code>f.b</code>) then it would not have been called to find <code>__dict__</code> because it's already there and <code>__getattr__</code> is invoked only if all other methods of finding the attribute have failed. </li>
</ol>

The 'correct' way to write the above class using <code>__getattribute__</code> is

<pre><code>class Foo(object):
 # Same __init__

 def __getattribute__(self, attr):
 return super(Foo, self).__getattribute__(attr)
</code></pre>

<code>super(Foo, self).__getattribute__(attr)</code> binds the <code>__getattribute__</code> method of the 'nearest' superclass (formally, the next class in the class's Method Resolution Order, or MRO) to the current object <code>self</code> and then calls it and lets that do the work.

All of this trouble is avoided by using <code>__getattr__</code> which lets Python do it's normal thing until an attribute isn't found. At that point, Python hands control over to your <code>__getattr__</code> method and lets it come up with something.

It's also worth noting that you can run into infinite recursion with <code>__getattr__</code>.

<pre><code>class Foo(object):
 def __getattr__(self, attr):
 return self.attr
</code></pre>

I'll leave that one as an exercise.

blocks|key|290497|text|我认为其他答案已经很好地解释了__getattr__和__getattribute__之间的区别，但有一件事可能不清楚，那就是为什么要使用__getattribute__。__getattribute__最酷的一点是，它允许您在访问类时重载点。这允许您自定义如何在较低级别访问属性。例如，假设我想定义一个类，其中只接受self参数的所有方法都被视为属性：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|290498|#+prop.py
import+inspect

class+PropClass(object):
++++def+__getattribute__(self,+attr):
++++++++val+=+super(PropClass,+self).__getattribute__(attr)
++++++++if+callable(val):
++++++++++++argcount+=+len(inspect.getargspec(val).args)
++++++++++++#+Account+for+self
++++++++++++if+argcount+==+1:
++++++++++++++++return+val()
++++++++++++else:
++++++++++++++++return+val
++++++++else:
++++++++++++return+val|code-block|syntax|javascript|290499|和来自交互式解释器的：|290500|>>>+import+prop
>>>+class+A(prop.PropClass):
...+++++def+f(self):
...+++++++++++++return+1
...+
>>>+a+=+A()
>>>+a.f
1|290501|当然，这是一个愚蠢的示例，您可能永远不会想要这样做，但它向您展示了通过覆盖__getattribute__可以获得的强大功能。|290502|entityMap^0|F|B|R|G|1X|G|2E|G|0|0|0|0|11|G|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]|$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|H|7|13|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|14|8|@$9|15|A|16|B|C]]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|R|$]]

I think the other answers have done a great job of explaining the difference between <code>__getattr__</code> and <code>__getattribute__</code>, but one thing that might not be clear is why you would want to use <code>__getattribute__</code>. The cool thing about <code>__getattribute__</code> is that it essentially allows you to overload the dot when accessing a class. This allows you to customize how attributes are accessed at a low level. For instance, suppose I want to define a class where all methods that only take a self argument are treated as properties:

<pre><code># prop.py
import inspect

class PropClass(object):
 def __getattribute__(self, attr):
 val = super(PropClass, self).__getattribute__(attr)
 if callable(val):
 argcount = len(inspect.getargspec(val).args)
 # Account for self
 if argcount == 1:
 return val()
 else:
 return val
 else:
 return val
</code></pre>

And from the interactive interpreter:

<pre><code>&gt;&gt;&gt; import prop
&gt;&gt;&gt; class A(prop.PropClass):
... def f(self):
... return 1
... 
&gt;&gt;&gt; a = A()
&gt;&gt;&gt; a.f
1
</code></pre>

Of course this is a silly example and you probably wouldn't ever want to do this, but it shows you the power you can get from overriding <code>__getattribute__</code>.

blocks|key|289656|text|我已经看过别人的精彩解释了。然而，我从这个博客Python+Magic+Methods+and+__getattr__中找到了一个简单的答案。以下所有内容都是从那里开始的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|289657|使用__getattr__的神奇方法，我们可以拦截不存在的属性查找，并执行一些操作，使其不会失败：|289658|class+Dummy(object):

++++def+__getattr__(self,+attr):
++++++++return+attr.upper()

d+=+Dummy()
d.does_not_exist+#+'DOES_NOT_EXIST'
d.what_about_this_one++#+'WHAT_ABOUT_THIS_ONE'|code-block|syntax|javascript|289659|但如果该属性确实存在，则不会调用__getattr__：|289660|class+Dummy(object):

++++def+__getattr__(self,+attr):
++++++++return+attr.upper()

d+=+Dummy()
d.value+=+"Python"
print(d.value)++#+"Python"|289661|__getattribute__类似于__getattr__，但重要的不同之处在于，__getattribute__将在每次查找属性时拦截，而不管属性是否存在。|BOLD|289662|class+Dummy(object):

++++def+__getattribute__(self,+attr):
++++++++return+'YOU+SEE+ME?'

d+=+Dummy()
d.value+=+"Python"
print(d.value)++#+"YOU+SEE+ME?"|289663|在这个例子中，d对象已经有了一个属性值。但是，当我们试图访问它时，我们并没有得到最初的期望值(“Python”)；我们只是得到了__getattribute__返回的任何值。这意味着我们实际上已经失去了value属性；它变成了“不可达”。|289664|entityMap|0|LINK|mutability|MUTABLE|url|https://blog.rmotr.com/python-magic-methods-and-getattr-75cf896b3f88^0|1C|B|N|10|0|0|2|B|0|0|G|B|0|0|0|G|J|B|16|G|1S|5|0|0|7|1|1S|G|0^^$0|@$1|2|3|4|5|6|7|15|8|@$9|16|A|17|B|C]]|D|@$9|18|A|19|1|1A]]|E|$]]|$1|F|3|G|5|6|7|1B|8|@$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|1E|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1F|8|@$9|1G|A|1H|B|C]]|D|@]|E|$]]|$1|O|3|P|5|J|7|1I|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1J|8|@$9|1K|A|1L|B|C]|$9|1M|A|1N|B|C]|$9|1O|A|1P|B|C]|$9|1Q|A|1R|B|S]]|D|@]|E|$]]|$1|T|3|U|5|J|7|1S|8|@]|D|@]|E|$K|L]]|$1|V|3|W|5|6|7|1T|8|@$9|1U|A|1V|B|C]|$9|1W|A|1X|B|C]]|D|@]|E|$]]|$1|X|3|-4|5|6|7|1Y|8|@]|D|@]|E|$]]]|Y|$Z|$5|10|11|12|E|$13|14]]]]

I have gone through other's excellent explanation. However, I found a simple answer from this blog <a href="https://blog.rmotr.com/python-magic-methods-and-getattr-75cf896b3f88" rel="noreferrer">Python Magic Methods and <code>__getattr__</code></a>. All the following are from there.

Using the <code>__getattr__</code> magic method, we can intercept that inexistent attribute lookup and do something so it doesn’t fail:

<pre><code>class Dummy(object):

 def __getattr__(self, attr):
 return attr.upper()

d = Dummy()
d.does_not_exist # 'DOES_NOT_EXIST'
d.what_about_this_one # 'WHAT_ABOUT_THIS_ONE'
</code></pre>

But if the attribute does exist, <code>__getattr__</code> won’t be invoked:

<pre><code>class Dummy(object):

 def __getattr__(self, attr):
 return attr.upper()

d = Dummy()
d.value = "Python"
print(d.value) # "Python"
</code></pre>

<code>__getattribute__</code> is similar to <code>__getattr__</code>, with the important difference that <code>__getattribute__</code> will intercept EVERY attribute lookup, doesn’t matter if the attribute exists or not. 

<pre><code>class Dummy(object):

 def __getattribute__(self, attr):
 return 'YOU SEE ME?'

d = Dummy()
d.value = "Python"
print(d.value) # "YOU SEE ME?"

</code></pre>

In that example, the <code>d</code> object already has an attribute value. But when we try to access it, we don’t get the original expected value (“Python”); we’re just getting whatever <code>__getattribute__</code> returned. It means that we’ve virtually lost the value attribute; it has become “unreachable”.

I am trying to understand the difference between <code>__getattr__</code> and <code>__getattribute__</code>, however, I am failing at it.

The <a href="https://stackoverflow.com/a/3278104/3798217">answer</a> to the Stack Overflow question <a href="https://stackoverflow.com/q/3278077/3798217">Difference between <code>__getattr__</code> vs <code>__getattribute__</code></a> says:

<blockquote>
 <code>__getattribute__</code> is invoked before looking at the actual attributes on
 the object, and so can be tricky to
 implement correctly. You can end up in
 infinite recursions very easily.
</blockquote>

I have absolutely no idea what that means.

Then it goes on to say:

<blockquote>
 You almost certainly want <code>__getattr__</code>.
</blockquote>

Why? 

I read that if <code>__getattribute__</code> fails, <code>__getattr__</code> is called. So why are there two different methods doing the same thing? If my code implements the new style classes, what should I use? 

I am looking for some code examples to clear this question. I have Googled to best of my ability, but the answers that I found don't discuss the problem thoroughly.

If there is any documentation, I am ready to read that.

Understanding the difference between __getattr__ and __getattribute__

解释器

Python

我试图理解__getattr__和__getattribute__之间的区别，然而，我在这方面做得不够好。堆栈溢出问题的 说： __getattribute__是在查看对象的实际属性之前调用的，因此要正确实现可能很棘手。你可以很容易地在无限递归中结束。我完全不知道那是什么意思。然后它继续说：你几乎肯定想要__getat...

问了解getattr和getattribute之间的区别
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问了解__getattr__和__getattribute__之间的区别EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问了解getattr和getattribute之间的区别
EN