Me gustaría modificar una variable privada de objeto class Example(): __myTest1 = 1 __myTest2 = 1 def __init__(self): pass def modifyTest(self, name = ‘Test1’, value): setattr(self, ‘__my’+name, value); Intenté el código anterior y parece que no es posible alcanzar una variable privada, AttributeError: Example instance has no attribute ‘__myTest1’ ¿Hay alguna forma de modificar una […]
No sé si este es un comportamiento esperado del método getattr built_in. getattr ejecuta el argumento predeterminado (3º), incluso si el argumento real (2º) cumple la condición. Ejemplo: def func(): print(‘In Function’) class A: def __init__(self): self.param = 12 a = A() Cuando ejecuto getattr(a, ‘param’, func()) da este resultado: In Function 12 Tenga en […]
Mi pregunta: Parece que __getattr__ no se llama para operaciones de indexación, es decir, no puedo usar __getattr__ en una clase A para proporcionar A[…] . ¿Hay alguna razón para esto? ¿O una forma de __getattr__ para que __getattr__ pueda proporcionar esa funcionalidad sin tener que definir explícitamente __getitem__ , __setitem__ , etc. en A […]
por ejemplo yo uso este código: class A(object): def __init__(self): self.dict1 = { ‘A’: 3, ‘B’: self.A} def __getattr__(self, key): if key in self.dict1: return self.dict1[key] a = A() y cuando se ejecuta, arroja una profundidad de recursión máxima excedida. ¿Puede alguien decirme qué estoy haciendo mal aquí?
Así que al jugar con getattr en mi código descubrí lo siguiente: myVariable = foo.A.bar Funciona … pero algo como esto: B = “A” myVariable = getattr(foo, B + “.bar”) devuelve un error que foo no contiene un atributo A.bar. ¿A dónde me voy mal? ¡Gracias!
Tengo una clase de plato de caldera que delega algunas acciones a una clase de referencia. Se parece a esto: class MyClass(): def __init__(self, someClass): self.refClass = someClass def action1(self): self.refClass.action1() def action2(self): self.refClass.action2() def action3(self): self.refClass.action3() Esta es la clase de referencia: class RefClass(): def __init__(self): self.myClass = MyClass(self) def action1(self): #Stuff to execute […]
Sé que este código es correcto: class A: def __init__(self): self.a = ‘a’ def method(self): print “method print” a = A() print getattr(a, ‘a’, ‘default’) print getattr(a, ‘b’, ‘default’) print getattr(a, ‘method’, ‘default’) getattr(a, ‘method’, ‘default’)() Y esto está mal: # will __getattr__ affect the getattr? class a(object): def __getattr__(self,name): return ‘xxx’ print getattr(a) Esto […]
Dado: In [37]: class A: ….: f = 1 ….: In [38]: class B(A): ….: pass ….: In [39]: getattr(B, ‘f’) Out[39]: 1 Bien, ¿eso llama super o arrastra el mro? In [40]: getattr(A, ‘f’) Out[40]: 1 Esto es lo esperado. In [41]: object.__getattribute__(A, ‘f’) Out[41]: 1 In [42]: object.__getattribute__(B, ‘f’) ————————————————————————— AttributeError Traceback (most […]
Tengo que personalizar __getattr__ para llamar a otra función para leer. Esto funciona bien, excepto que la ayuda (object.attr) no funciona. Este código se utiliza en un entorno interactivo, por lo que la ayuda () se vuelve importante para nosotros. ¿Hay un diseño mejor para lograr las mismas características pero con ayuda () que funciona […]
¿Hay alguna forma de determinar la diferencia entre un método y una llamada de atributo utilizando __getattr__? Es decir, en class Bar(object): def __getattr__(self, name): if THIS_IS_A_METHOD_CALL: # Handle method call def method(**kwargs): return ‘foo’ return method else: # Handle attribute call return ‘bar’ foo=Bar() print(foo.test_method()) # foo print(foo.test_attribute) # bar Los métodos no son […]