标签: setattr

我想修改一个对象私有变量

class Example():
    __myTest1 = 1
    __myTest2 = 1
    def __init__(self):
        pass
    def modifyTest(self, name = 'Test1', value):
        setattr(self, '__my'+name, value);

我尝试了上面的代码,似乎无法达到私有变量,

AttributeError: Example instance has no attribute '__myTest1'

有没有办法修改私有变量？

我想要一个虚拟对象,我可以在python中实例化,并以编程方式为via setattr()创建属性.

我在内置对象上尝试了它,但可能是因为一个不起作用的好理由.

我可以在python中使用什么基础对象来实现这样的目的,而不是自己定义一个？

我正在尝试将函数从任意“基”类复制到新对象中。但是，此示例代码出现以下错误。

class my_base:
    def print_hey():
        print("HEY")

    def get_one():
        print(1)

class my_ext:
    def __init__(self, base):
        methods = [method for method in dir(base) if callable(getattr(base, method))]
        for method in methods:
            setattr(self, method, getattr(base, method))


me = my_ext(my_base)
me.get_one()

上面在调用时出现此错误setattr。

 TypeError: __class__ assignment only supported for heap types or ModuleType subclasses

如果在定义以上内容后在提示中键入该语句，则该语句有效。

如果我有一个python类,它允许在实例化时有一个options参数,我怎样才能根据该options参数的值动态设置一个函数.例如,如果我有代码

def hello1():
    print(self.name,"says hi")

def hello2():
    print(self.name,"says hello")

class A:
    def __init__(self, name, opt=0):
        if opt == 1:
            setattr(self,'hello',hello1)
        else:
            setattr(self,'hello',hello2)

if __name__ == "__main__":
    a1 = A("my")
    a2 = A("name",1)
    a1.hello()
    a2.hello()

我收到了追溯错误

Traceback (most recent call last):
  File "dynamic_classes.py", line 17, in <module>
    a1.hello()
  File "dynamic_classes.py", line 5, in hello2
    print(self.name,"says hello")
NameError: global name 'self' is not defined

我还没有看过字典点访问的可切换版本.

我在这里的首次尝试不起作用:

class DottableDict (dict):

    def allowDotting (self, state=True):
        if state:
            self.__setattr__ = dict.__setitem__
            self.__getattr__ = dict.__getitem__
        else:
            del self.__setattr__
            del self.__getattr__

>>> import dot
>>> d = dot.DottableDict()
>>> d.allowDotting()
>>> d.foo = 'bar'
>>> d
{}
>>> d.foo
'bar'
>>> d.__dict__
{'__setattr__': <slot wrapper '__setitem__' of 'dict' objects>, 'foo': 'bar',
'__getattr__': <method '__getitem__' of 'dict' objects>}
>>> d.allowDotting(False)
>>> d.__dict__
{'foo': 'bar'}

我认为签名在setattr和setitem之间不匹配.

我的第二遍也似乎应该有效,但以同样的方式失败:

class DottableDict (dict):

    def dotGet (self, attr):
        return dict.__getitem__(self, attr)

    def dotSet (self, attr, …

所以我看了类似的问题,我找到了一些解决方案,但我不知道如何做到这一点.

我想要做的是从字符串向类中添加一个方法.我可以使用该setattr()方法执行此操作,但这不会让我self在额外方法中用作属性.这是一个例子:(我为变量名称道歉,当我嘲笑一个想法时,我总是使用yolo)

class what:
    def __init__(self):
        s = 'def yolo(self):\n\tself.extra = "Hello"\n\tprint self.extra'
        exec(s)
        setattr(self,"yolo",yolo)

what().yolo()

返回:

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: yolo() takes exactly 1 argument (0 given)

如果s = 'def yolo():\n\tself.extra = "Hello"\n\tprint self.extra' 那时我得到这个结果:

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 2, in yolo
NameError: global name 'self' is not defined

这实际上意味着我不能动态地为类创建方法,我知道这是不好的做法和unpythonic,因为这些方法无法访问类的其余部分可以访问的变量.

我感谢任何帮助.

我有一个定义了多个方法的类。

import mat
class Klass(object):

    @mat.sell(mat.CanSet):
    def method1(self):
        return None

    @mat.sell(mat.CanSet):
    def method2(self):
        return 'value2'

假设我有10种方法需要填充此“ Klass”。我想生成这些方法而不显式地编写它们。所以我想做一个为每种方法做setattr的工厂。问题是我遵循以下方法，并且last方法具有最后一个值。每个都没有获得其相关的值，而是value10。另外下面的解决方案没有实现装饰器，我不知道如何分配装饰器

class Klass(object):
    pass

list1 = [('method1', 'value1'), ('method2', 'value2').....('method10', 'value10')]

for each in list1:
    method_name, method_value = each
    setattr(Klass, method_name, lambda self: method_value)

所以当我跟随时...

k = Klass()
print k.method1(), method2()...., method10()

每种方法的结果均为value10。不明白为什么 ？另外，任何人都可以帮助您实现具有一个属性的装饰器吗？附言：如果您有建议不要使用“ setattr”，那也将受到欢迎。

我想在运行时向对象添加一个方法。

class C(object):
  def __init__(self, value)
    self.value = value

obj = C('test')

def f(self):
  print self.value

setattr(obj, 'f', f)
obj.f()

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: f() takes exactly 1 argument (0 given)

但似乎 setattr 并没有将方法绑定到对象。是否有可能做到这一点？

我想在设置对象属性时调用函数：

class MyClass():
    myattrib = None

    def __setattr__(self, prop, val):
        self.myattrib = val
        print("setting myattrib")

x = MyClass()
x.myattrib = "something"

问题是，这会产生无限递归。

这个想法是在设置成员变量时调用一个函数（并实际设置该成员变量），但同时运行额外的代码（print()在上面的示例中显示了语句）。

另一个明显的方法是使用set_attrib()函数，这在 Java 中很常见，但我想用pythonic 的方式来做，直接设置属性，但同时运行额外的代码。

我有以下代码,其中包含一个person类和一个委托给person类的Manager类.我正在使用new style object(派生自object)并运行python 2.7.我认为最大的递归深度是我无法理解的.我知道当使用setattr时会发生问题(当我在经理类中注释掉它时,我发现它工作正常).为什么会发生这种递归以及如何避免它.

class Person(object):
    def __init__(self,name,job=None, pay=0):
        self.name=name
        self.job=job
        self.pay=pay

    def lastName(self):
        return self.name.split()[-1]

    def giveraise(self,percent):
        self.pay=int(self.pay*(1+percent))

    def __str__(self):
        return '[Person: %s, %s]' %(self.name, self.pay)


class Manager(object):
    def __init__(self,name,pay):
        self.person=Person(name,'mgr',pay)

    def giveraise(self, percent, bonus=0.10):
        self.person.giveraise(percent+bonus)

    def __getattr__(self,attr):
        print "calling getattr"
        return getattr(self.person, attr)

    def __setattr__(self,attr, value):
        print "calling setattr"
        self.person__dict__["attr"]=value

    def __str__(self):
        return str(self.person)


if __name__=="__main__":

    sue = Person("sue Jones","dev",10000)
    sue.giveraise(0.10)
    print sue
    print sue.lastName()

    print "- -"*25

    tom = Manager("Tom mandy", …