如何用类变量解决__getattribute__中的无限递归问题
在Python中，当我们在类中定义了__getattribute__方法时，如果在该方法中再次调用实例的属性或方法，就会导致无限递归的问题。为了解决这个问题，可以使用类变量来绕过__getattribute__方法的调用。
具体的解决方法是，在__getattribute__方法中使用super().__getattribute__()来获取实例的属性或方法。这样做的原因是，super().__getattribute__()会直接调用父类的__getattribute__方法，而不会再次触发当前类的__getattribute__方法，从而避免了无限递归的问题。
下面是一个示例代码：
class MyClass:
class_var = "This is a class variable"
def __getattribute__(self, name):
# 使用super().__getattribute__()获取实例的属性或方法
return super().__getattribute__(name)
my_obj = MyClass()
print(my_obj.class_var) # 输出：This is a class variable在上面的示例中，我们定义了一个MyClass类，其中包含一个类变量class_var。在__getattribute__方法中，我们使用super().__getattribute__()来获取实例的属性或方法。当我们访问my_obj.class_var时，__getattribute__方法会被调用，但由于使用了super().__getattribute__()，不会再次触发__getattribute__方法，从而避免了无限递归的问题。
需要注意的是，使用类变量解决__getattribute__中的无限递归问题只是一种解决方法，具体是否适用取决于实际情况。在实际开发中，还需要根据具体需求和代码结构来选择合适的解决方案。
相关·内容
我的脚本在Python3上遇到了递归循环，我尝试用items替换iteritems，但没有解决这个问题，Python2运行得很好。__getattribute__有没有什么我不知道的变化？
class Map(object):
def __init__(self, *args, **kwargs):
for arg in args:
if isinstance(arg, dict):
for k, v in arg.items():
self.__dict__[k]
浏览 0提问于2017-02-14得票数 2
1回答
当我使用__getattribute__访问一个类的属性时，我试图打印一些东西，这里的大问题是递归，而事实上我正在重写getattribute方法。
恐怕我得用元类来解决这个问题。不管怎样，如果你对这个问题有什么答案的话。
浏览 4提问于2014-06-04得票数 1
回答已采纳
这个代码有什么问题？
class Spam(object):
def __init__(self, a, b):
self.a = a
self.b = b
# using this to mark field "c" as deprecated. As per my understanding this gets called only for fields that do not exist.
def __getattr__(self, c):
print("Deprecated")
浏览 1提问于2019-02-04得票数 0
回答已采纳
1回答
class Shadow(object):
pass
class Test(object):
a = 1
b = 2
_shadow = Shadow()
def __getattribute__(self, name):
try:
return object.__getattribute__(self._shadow, name)
except: print "not shadowed"
return object.__getattribute__(self,
浏览 3提问于2014-04-10得票数 1
回答已采纳
就像标题上说的。似乎无论我做什么，__getattr__都不会被称为。例如，我也尝试过(我知道，这是荒谬的)，没有任何反应。就好像__getattr__在元类中被禁止一样。
我希望有任何关于这方面的文档的指针。
守则：
class PreinsertMeta(type):
def resolvedField(self):
if isinstance(self.field, basestring):
tbl, fld = self.field.split(".")
self.field = (tbl, fl
浏览 0提问于2014-07-01得票数 3
回答已采纳
我有一个包含成员对象的类。我想像调用容器类的方法一样调用成员的方法。
下面的示例说明了我想要做的事情(但是在不同的上下文中)。
假设我们有两个类代表两种不同的产品：Toys和Shoes。每个类都有两个方法，比方说，weight()和description()，它们明显地返回项的权重和项的描述。
现在，我想将这些产品放在单独的框中，-每个框将包含单个Toy或单个Shoe。
我仍然希望能够访问weight()和description()方法，但是我希望它们成为Box实例的成员。另外，我不希望具体实现weight()和description()类中的方法，因为每当向Toy和Shoe添加新方法时，我都
浏览 0提问于2009-11-27得票数 2
回答已采纳
声明在查找特殊方法时可以绕过__getattribute__。这是通过语言语法或内置函数隐式调用的结果。
例如,
elem = container[0]
与以下情况不同：
elem = container.__getattribute__('__getitem__')[0]
以下是另一个例子：
class WrappedList:
def __init__(self):
object.__setattr__(self, 'interal_list', ['apple', 'pear', 'orang
浏览 1提问于2018-02-24得票数 6
1回答
我正在尝试实现redis实际拥有属性的类，但类的用户并不知道这一点(即。跨多个客户端的对象持久性)。我知道有几个库为python包装了redis，但没有一个库能以这种简单的方式做到这一点(但如果我说错了，请纠正我！)
我已经成功地实现了属性的自动redis存储，但是如果没有无限的递归，我似乎无法使用__getattribute__进行检索。我认为我在使用object.__getattribute__等东西时很小心，但显然我肯定遗漏了一些东西：
class redisStored(object):
global redis
# A class method to impleme
浏览 1提问于2013-02-10得票数 3
1回答
我的类Config有问题，即充当用户和ini文件之间的代理。它可以从ini文件中加载参数，并在dataclass中将它们设置为等效的名称。我已经意识到，我想要得到一些像Config()._BASE_DIR这样的点的属性，它返回str值，因为ConfigParser可以以str的形式获得值。我的想法是创建一些方法，它将用property和property.setter对我的所有属性进行修补，以便能够使用点访问dataclass属性，但是用注释类包装它们，因此，例如，Config()._minAR将返回的不是字符串，而是浮点。
我的想法是可以接受的，还是我需要以不同的方式去做？
配置代码部件：
i
浏览 4提问于2022-09-18得票数 0
我试图理解__getattr__和__getattribute__之间的区别，然而，我在这方面做得不够好。
堆栈溢出问题的 说：
__getattribute__是在查看对象的实际属性之前调用的，因此要正确实现可能很棘手。你可以很容易地在无限递归中结束。
我完全不知道那是什么意思。
然后它继续说：
你几乎肯定想要__getattr__。
为什么？
我读到如果__getattribute__失败，就会调用__getattr__。那么为什么会有两种不同的方法做同样的事情呢？如果我的代码实现了新的样式类，我应该使用什么？
我正在寻找一些代码示例来解决这个问题。我已经搜索了我最大的能力，但我找到
浏览 85提问于2010-11-28得票数 241
回答已采纳
我的问题是关于__getattribute__的。请考虑以下代码：
class Product():
def __init__(self, name, quantity = 1, price = 0.0):
self.name = name
self.quantity = quantity
self.price = price
def __getattribute__(self, attr):
if (attr == 'price'):
return 30 * object.__getattribute_
浏览 2提问于2017-04-18得票数 0
我只是遇到了一种意想不到的行为。这是一个带有__getattr__方法和属性属性的简单类，其中包含一个错误：
class A(object):
def __getattr__(self, attr):
if not attr.startswith("ignore_"):
raise AttributeError(attr)
@property
def prop(self):
return self.some_typo
a = A() # Instantiating
a.ignore_this #
浏览 2提问于2014-08-04得票数 12
回答已采纳
为了避免无限循环，需要仔细编写__getattribute__方法。例如：
class A:
def __init__(self):
self.x = 100
def __getattribute__(self, x):
return self.x
>>> a = A()
>>> a.x # infinite looop
RuntimeError: maximum recursion depth exceeded while calling a Python object
class B:
浏览 3提问于2012-11-24得票数 28
回答已采纳
2回答
假设我有以下简化的类：
class ExampleClass:
def __init__(self, input_1):
self.input_1 = input_1
def method_1(self):
# Do something
return self
def method_2(self):
# Do something
return self
def method_3(self):
# Do something
return self
浏览 2提问于2022-07-07得票数 1
这是我在这里的第一个问题，也是我在Python中的第一个项目。
我试图存储一个名为Ip500Device的类的实例
class Ip500Device(object):
list = []
def __init__(self, shortMac, mac, status, deviceType):
self.__shortMac =shortMac
self.__mac=mac
self.__status=status
self.__deviceType=deviceType
self.__nbO
浏览 0提问于2016-12-29得票数 2
回答已采纳
我想重写对类中一个变量的访问，但正常返回所有其他变量。如何使用__getattribute__实现这一点
我尝试了下面的方法(这也应该说明我正在尝试做什么)，但我得到了一个递归错误：
class D(object):
def __init__(self):
self.test=20
self.test2=21
def __getattribute__(self,name):
if name=='test':
return 0.
else:
return
浏览 1提问于2008-12-16得票数 119
回答已采纳
我想重写类中的变量的get方法。(我不知道怎么解释。)
我试着看过谷歌，但是没有什么对我有帮助。
我的代码：
class Class():
self.foo = ['foo','bar']
print(Class().foo)
我想要这样做，所以它将打印出默认的' '.join(Class().foo)，而不仅仅是Class().foo。
有什么可以添加到代码中使其成为这样吗？
浏览 1提问于2019-04-29得票数 1
回答已采纳
在Python的中，它说：
注意，如果通过正常机制找到该属性，则不会调用__getattr__()。(这是__getattr__()和__setattr__()之间有意的不对称。)这既是出于效率原因，也是因为否则__getattr__()将无法访问实例的其他属性。
我很难理解最后一项声明：
将无法访问实例的其他属性。
它怎么可能没有办法访问其他属性呢？(我猜这与无限递归有关，但是没有其他方法来访问实例属性，比如从self.__dict__ directy?)
浏览 4提问于2012-11-07得票数 8
我试图在dataclass中重写__getattribute__特殊方法，以便获得一个属性的格式化版本。
@dataclass
class _BaseRouteRegistry:
VERSION = '1'
USERS = 'users'
def __getattribute__(self, item):
route = object.__getattribute__(self, item)
return f"/api/{route}/v{self.VERSION}"
BaseRoute
浏览 4提问于2021-12-26得票数 2
回答已采纳
假设我们使用的是python 3.x或更新版本，而不是python 2.x
Python和许多语言一样，有一个点运算符：
# Create a new instance of the Rectangle class
robby = Rectangle(3, 10)
# INVOKE THE DOT OPERATOR
x = robby.length
Python的点运算符是，有时实现为__getattribute__。
以下内容等价于x = robby.length
x = Rectangle.__getattribute__(robby, "length")
浏览 2提问于2021-01-02得票数 0
因此，假设我想编写自己的类，重写__getattribute__函数。每当有人调用未定义的属性时，我都希望它生成一个随机int。
X = GetAttribute()
print(X.predefined_attribute) # "First attribute"
X.attr2 = "Hi"
print(X.attr2) # "Hi"
print(X.attr3) # random int
显然，我不能写这样的东西，因为它会导致递归。
class GetAttribute(object):
def __init__(self):
浏览 10提问于2017-05-31得票数 1
回答已采纳
我有以下课程：
class MyInt:
def __init__(self, v):
if type(v) != int:
raise ValueError('value must be an int')
self.v = v
def __getattr__(self, attr):
return getattr(self.v, attr)
i = MyInt(0)
print(i + 1)
我得到了错误：TypeError: unsupported operand type(s) f
浏览 0提问于2016-07-10得票数 5
回答已采纳
我与此斗争了一整天，并做了大量的谷歌搜索。我现在有一个似乎是继承问题。
我有一个名为BaseClass的类，它为我做了一些简单的事情，比如设置日志默认设置、保存日志和管理只读属性。在过去，我对这个类没有任何问题，但我可以说，我现在只使用python几个月了。此外，我怀疑有几个注意事项很重要：
所有过去的继承都是单一继承。换句话说，我继承了BaseClass，但是继承BaseClass的类不会被另一个类继承。在今天的问题中，我将BaseClass继承到BaseFormData，然后继承到July2013FormData，然后继承到Jan2014FormData。所以很明显现在有更多的层。
浏览 10提问于2014-12-03得票数 4
回答已采纳
关于以下代码，我有一个“问题”(更多的是一个理论，而不是一个我需要批准的问题)。
当我启动程序时，它将导致一个异常: System.StackOverflowException："Exception_WasThrown“。
我的理论是，这个异常是由gettin‘引起的，因为我在主方法中创建一个" LOG“对象，在日志中创建一个FileSize对象，在FileSize内部创建一个日志对象，它也试图创建一个对象FileSize，这个过程及其循环。
这是对的，还是我误解了，如果是，请向我解释。
static void Main(string[] args)
{
浏览 19提问于2022-08-14得票数 0
1回答
我有一个类似的课程：
class C(object):
_use_obj = 'attr1 attr2'.split()
def __init__(self, obj):
self.obj = obj
# class definition continues here defining a few attributes and methods
我希望能够通过特定规则通过obj访问C的属性。
c.this应该返回：
obj.this如果this在C._use_obj中
C.this如果this是在C中定义的
如果obj.t
浏览 0提问于2014-06-10得票数 0
回答已采纳
2回答
class test():
name = 'arthur'
def __getattribute__(self, value):
return super().__getattribute__(value)
x = test()
x.name
------------------------------------------
Output: 'arthur'
我正在努力理解__getattribute__的底层机制。我理解(希望)在这种情况下，super().__getattribute__(value)会扩展到对象类。但是object实
浏览 1提问于2019-12-13得票数 2
回答已采纳
class Foo(object):
pass
foo = Foo()
def bar(self):
print 'bar'
Foo.bar = bar
foo.bar() #bar
来自JavaScript，如果一个“类”原型增加了某个属性。已知该“类”的所有实例将在其原型链中具有该属性，因此不必对其任何实例或“子类”进行任何修改。
从这个意义上说，像Python这样的基于类的语言如何实现Monkey patching？
浏览 0提问于2011-06-09得票数 14
回答已采纳
我正在构建一个系统，其中每个其他对象都使用一个基类。每个基本对象内部都有一个_fields字典，基类的实现可以在其中存储它们的信息。
基类实现非常简单：
class A(object):
def __init__(self, fields=dict()):
self._fields = fields
类的实现可以在__init__调用中将字段设置为其super()。
我想补充的是，这些字段可以作为属性访问，而不必将@property装饰器添加到一大堆函数中。为此，我在基类中重写了__getattr__，如下所示：
class A(object):
def __i
浏览 3提问于2017-08-30得票数 2
我将一个对象包装在另一个对象中。“包装器”通过重写__getattr__来访问“包装”对象中的属性。在我需要重写子类上的属性，然后使用super()从基类访问属性之前，这种方法工作得很好。
我仍然可以直接从__getattr__访问该属性，但为什么super()不起作用？
class Wrapped(object):
def __init__(self, value):
self.value = value
def hello_world(self):
print 'hello world', self.value
class
浏览 0提问于2012-08-21得票数 19
回答已采纳
除了为了正确性而绕过任何实例属性之外，隐式特殊方法查找通常也会绕过对象的元类的__getattribute__()方法。
提到了一些特殊的方法，比如__hash__、__repr__和__len__，我从经验中知道它还包括__iter__ for Python2.7。
引用
魔术__methods__()被特别对待:它们在内部被分配到类型数据结构中的“插槽”，以加快查找速度，并且它们只在这些插槽中被查找。
为了改进我对的回答，我需要知道:具体而言，我们讨论的是哪些方法？
浏览 7提问于2012-10-13得票数 11
回答已采纳
我正在尝试理解什么时候使用__getattr__或__getattribute__。提到__getattribute__适用于新样式的类。什么是新风格的类？
浏览 5提问于2010-07-19得票数 492
回答已采纳
这个对我来说似乎有点棘手。不久前，我已经设法用下面的内容覆盖了一个实例的方法：
def my_method(self, attr):
pass
instancemethod = type(self.method_to_overwrite)
self.method_to_overwrite = instancemethod(my_method, self, self.__class__)
这对我来说工作得很好；但现在我试图重写一个实例的__getattribute__()函数，该函数对我不起作用，原因是该方法似乎是
<type 'method-wrapper'&g
浏览 1提问于2009-10-13得票数 4
回答已采纳
我正在尝试使用__getattribute__打印方法的名称 但是我每次调用该方法时都会得到typeerror，并且该方法不会被执行，有没有办法摆脱类型错误并执行该方法呢？ class Person(object):
def __init__(self):
super()
def test(self):
print(1)
def __getattribute__(self, attr):
print(attr)
p = Person()
p.test() 上面的代码给出了错误 test
Traceback (
浏览 10提问于2019-10-03得票数 1
回答已采纳
我正在为across编写一个程序，遇到了以下问题：
在我的一个类中，有许多布尔属性，它们使用KVO (即valueForKey:和setValue:forKey:方法)访问。它们的数量可能会增加。
每次设置这些属性之一时，都需要更改上次修改的日期，这也是一个属性。因此，我不得不为每一个新的属性编写一个新的setter。
相反，我想要做的是重写setValue:forKey:方法，以便它设置相应的属性和上次修改的日期，但如果不将ifs添加到setValue:forKey:方法(检查密钥的名称并设置相应的_variable)，则无法知道如何做到这一点；和( b)不陷入无限循环。
有办法吗？还是完全
浏览 2提问于2013-09-14得票数 0
回答已采纳
我有一个元类和和类，它们都使用__getattribute__来拦截属性调用。它们看起来是这样的：
class B(type):
def __getattribute__ (self, name) :
print(f'hello {self}')
return super().__getattribute__(name)
class C(metaclass=B):
MY_ATTR = 'hello attr'
def __getattribute__ (self, name) :
浏览 2提问于2017-03-02得票数 0
回答已采纳
3回答
假设我有以下课程
class Headings:
standard_heading = {
'height': 3.72,
'width': 25.68,
'left': 1.65,
'top': 0.28
}
例如，我希望得到以下结果，其中所有值都乘以10：
Headings.standard_heading
>>> {
'height': 37.2,
'wi
浏览 1提问于2018-04-10得票数 0
回答已采纳
如果这个问题有一个重复，对不起，我没有找到它，如果有人这样做，我会修改这个问题。
我有一个简单的python类：
class NothingSpecial:
@classmethod
def meth(cls):
print("hi!")
试着用不同的方法得到这个方法：
a = (object.__getattribute__(NothingSpecial, 'meth'))
b = (getattr(NothingSpecial, 'meth'))
问题是，如果我这样做了：
b()
$hi！
浏览 4提问于2017-06-19得票数 4
回答已采纳
我正在寻找这个错误的解决方案，控制台上写的是Exception in thread "AWT-EventQueue-0" java.lang.StackOverflowError at sun.awt.Win32GraphicsConfig.getBounds(Native Method) at sun.awt.Win32GraphicsConfig.getBounds(Unknown Source) at java.awt.Window.init(Unknown Source) at java.awt.Window.<init>(U
浏览 0提问于2015-01-21得票数 1
回答已采纳
我们使用另一个内部团队提供的库。(不可靠的类比现在开始)
from externalTeam import dataCreator
datacreator.createPizza()
datacreator.createBurger()
datacreator.createHotDog()
最近，我们发现他们的一个方法在某些情况下需要一分钟以上的时间来执行。要调试此方法，我必须进入我们的代码，并在每次调用此方法时添加超时。
import time
from externalTeam import dataCreator
start = time.clock()
datacreator.crea
浏览 0提问于2011-07-07得票数 5
回答已采纳
看起来好像__getattribute__只有两个参数(self, name)。
然而，在实际的代码中，我截取的方法实际上采用了参数。
有什么方法可以访问这些参数吗？
谢谢,
查利
浏览 0提问于2009-05-26得票数 4
根据这个关于python描述符的指南，
新样式类中的方法对象是使用描述符来实现的，以避免在属性查找中使用特殊的大小写。
我理解这一点的方式是，有一个方法对象类型实现__get__，并在调用绑定方法对象时返回一个绑定方法对象，当调用一个实例时，返回一个未绑定方法对象，当调用它时不使用实例，只返回一个类。本文还指出，该逻辑是在object.__getattribute__方法中实现的。就像这样：
def __getattribute__(self, key):
"Emulate type_getattro() in Objects/typeobject.c"
v =
浏览 4提问于2014-07-21得票数 6
回答已采纳
2回答
我有一种情况，我需要从另一个实现者那里获得需求，遵循我的基类设计：
class ExemplaryClass:
pass
class Base(ABC):
@abstractmethod
def process(self):
# should return specific type, for instance ExemplaryClass
class Derived(Base):
def process(self):
# if return sth different from ExemplaryClass, should
浏览 2提问于2017-09-07得票数 0
1回答
我正在使用google的v8 javascript引擎在我的项目中有一个嵌入式js解释器，它必须能够执行用户提供的代码，但是我想知道是否有可能在调用任何用户代码之前设置一些东西，这样可以确保如果代码试图无限期地恢复(或者即使它只是执行了太长时间)，它可以以某种方式被中止，抛出一个本来没有意义的异常，并将问题报告给调用者。
谢谢大家到目前为止的回复。是的，在我贴出这篇文章后不久，我意识到我基本上是在寻求某种解决止住问题的方法，我知道这个问题是无法解决的，而且实际上远远超出了我真正需要的。
我需要的是某种机制来检测在v8环境中运行的东西何时返回得足够快，或者仅仅是一种检测递归是否发生的机制.我的用
浏览 2提问于2014-08-20得票数 1
回答已采纳
我正在尝试使用IBInspectable为我的视图添加边框。
extension UIView {
private func getBorder(integer: Int) -> UIRectEdge {
if integer == 1 {
return .top
} else if integer == 2 {
return .left
} else if integer == 3 {
return .right
} else if inte
浏览 2提问于2016-08-29得票数 0
回答已采纳
为什么Foo2会导致无限递归调用__getattribute__中的类变量的getattr，而Foo在__getattr__中可以很好地进行同样的调用？对如何让Foo2正常工作有什么建议吗？ class Foobar(object):
def __init__(self):
super().__init__()
self.bar = 5
def getbar(self):
return self.bar
class Foo(object):
def __init__(self):
super()._
浏览 20提问于2020-04-25得票数 1
回答已采纳
1回答
我的希望是使属性不区分大小写。但是，覆盖__getattr__和__setattr__有点不同，如下面的玩具示例所示：
class A(object):
x = 10
def __getattr__(self, attribute):
return getattr(self, attribute.lower())
## following alternatives don't work ##
# def __getattr__(self, attribute):
# return self.__getattr__(at
浏览 1提问于2018-07-10得票数 1
回答已采纳
我想了解一下__getattribute__和__getattr__如何在Python中使用未实例化的类和子类。具体来说，我想在超类中捕获一个getattribute调用，并可能相应地修改它。
在下面的代码片段中，我希望在调用任何方法时至少会有一些中间打印语句，但我什么也没有得到。类变量被找到并返回，但是似乎没有调用任何神奇的方法。为什么会这样呢？
class SuperbClass:
def __getattribute__(self, attr):
print(f"called in superb, found {attr}")
#
浏览 3提问于2021-11-02得票数 1
回答已采纳
1回答
在使用最新的用于C#的Csharp驱动程序1.9.1将这个MongoDB类序列化为BSON文档时，我遇到了麻烦:-
public class Node
{
public string name
{
get;
set;
}
public List<Node> children
{
get;
set;
}
public int size
{
get;
set;
}
public Node()
{
浏览 4提问于2014-06-03得票数 1
1回答
为了理解实现、操作等，我从JDK中复制了LinkedList类，并以非泛型(仅限字符串)的方式进行了修改。您可以找到实际的代码。与这个问题相关，这里
addLast()
public void addLast(String e){
System.out.println("Invoked:addLast()");
linkLast(e);
}
节点内类
private static class Node {
String item;
Node next;
Node prev;
Node(Node prev, String e
浏览 1提问于2015-11-24得票数 3
回答已采纳
1回答
我有一个Python对象，我想保护它不受任何内部和外部访问的影响，并通过代理运行每个请求。到目前为止，我使用了代码，它运行得很好。我将其子类化，并使用我想要代理的对象初始化它。
不幸的是，它没有涵盖从代理对象内部进行访问的情况。
class A(object):
def do_something(self):
self.foo.perform_action()
class MyProxy(Proxy):
def __init__(self, obj):
super(MyProxy, self).__init__(obj)
浏览 5提问于2015-02-10得票数 0
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
即时通信 IM活动推荐
腾讯云开发者
