Comment utiliser setattr correctement, éviter une récursion infinie

Je veux définir une classe contenant read et write methode, qui peut être appelé comme suit:

instance.read
instance.write
instance.device.read
instance.device.write

De ne pas utiliser entrelacé classes, mon idée était de remplacer le __getattr__ et __setattr__ méthodes et de vérifier si le nom donné est device pour rediriger le retour à self. Mais j'ai rencontré un problème en donnant un récurrences. L'exemple de code est comme suit:

class MyTest(object):
    def __init__(self, x):
        self.x = x

    def __setattr__(self, name, value):
        if name=="device":
            print "device test"
        else:
            setattr(self, name, value)

test = MyTest(1)

Comme dans __init__ le code essayé de créer un nouvel attribut x, il appelle __setattr__, qui appelle de nouveau __setattr__ et ainsi de suite. Comment dois-je changer ce code, qui, dans ce cas, un nouvel attribut x de self est créé, le maintien de la valeur 1?

Ou est-il une meilleure façon de gérer les appels comme instance.device.read être 'lié' à instance.read?

Il y a toujours des questions sur le pourquoi: j'ai besoin de créer des abstractions de xmlrpc appels, pour lesquels très facile de méthodes comme le myxmlrpc.instance,device.read et similaires peuvent être créés. J'ai besoin de "se moquer de" ce jusqu'à mimer ces multi-dot-appels de méthode.

ce cas d'utilisation serait plus facilement résolu en utilisant @property

InformationsquelleAutor Alex | 2013-06-10

Vous devez appeler la classe parent __setattr__ méthode:

class MyTest(object):

    def __init__(self, x):
        self.x = x

    def __setattr__(self, name, value):
        if name=="device":
            print "device test"
        else:
            super(MyTest, self).__setattr__(name, value)
            # in python3+ you can omit the arguments to super:
            #super().__setattr__(name, value)

Concernant les meilleures pratiques, puisque vous prévoyez d'utiliser ce par le biais d' xml-rpc je pense que c'est probablement mieux le faire à l'intérieur de la _dispatch méthode.

Une façon rapide et sale est de tout simplement faire:

class My(object):
    def __init__(self):
        self.device = self

J'aime le quick-and-dirty façon: Juste une ligne pour obtenir le comportement souhaité! Merci
Cela est également mentionné dans le Python docs.

InformationsquelleAutor Bakuriu

18

Ou vous pouvez modifier self.__dict__ de l'intérieur __setattr__():
```
class SomeClass(object):

    def __setattr__(self, name, value):
        print(name, value)
        self.__dict__[name] = value

    def __init__(self, attr1, attr2):
        self.attr1 = attr1
        self.attr2 = attr2


sc = SomeClass(attr1=1, attr2=2)

sc.attr1 = 3
```
- Pourquoi n'est-ce pas appel setattr(self, "__dict__", value), répétant à l'origine d'une récursion infinie problème?
- Parce que ce n'est pas le réglage de la __dict__ attribut, de l'intestin de l'obtenir et de définir ensuite un article sur le retour de l'dict, c'est à dire, il appelle qqch comme: getattr(self, "__dict__").__setitem__(name, value)
InformationsquelleAutor Vindolin

Vous pouvez également utiliser objet.

class TestClass:
    def __init__(self):
            self.data = 'data'
    def __setattr__(self, name, value):
            print("Attempt to edit the attribute %s" %(name))
            object.__setattr__(self, name, value)

InformationsquelleAutor Danny Harpigny

ou vous pouvez simplement utiliser @property:

class MyTest(object):

    def __init__(self, x):
        self.x = x

    @property
    def device(self):
        return self

InformationsquelleAutor Aviad Rozenhek

Vous devez vous connecter pour publier un commentaire.