court circuiter getitem par attribut

Version imprimable

Voir 40 message(s) de cette discussion en une page

court circuiter __getitem__ par attribut

Bonjour,

Lorsque l'on assigne un attribut ayant le même nom qu'une méthode, celui ci prends la priorité sur cette dernière. Est ce normal si cela ne fonctionne pas pour l'attribut __getitem__, accédé avec la syntaxe d[] ? (Je suis en Py25)

Merci d'avance

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
class A(dict):
    def __init__(self):
        dict.__init__(self)
    def __getitem__(self, k):
        print "A.get ",k
        return dict.__getitem__(self, k)
 
class D(A):
    def __init__(self):
        A.__init__(self)
        self._inner= dict()
        "Shortcuts __getattr__ to self._inner"
        self.__getattr__= self._inner.__getitem__
 
if __name__ == '__main__':
    d=D()
    d._inner[0]= 1 
    d[0]= 1
    print "d.__getattr__(0)"
    d.__getattr__(0) # does not call A.__getitem__, as expected
    print "d[0]"
    d[0] # this CALLS A.__getitem__, UNEXPECTED !

24/07/2012, 08h35
mont29

M’enfin, d._inner est un objet dict normal, pas un objet A*! Donc quand tu fais d.__getattr__(0) tu appelles la méthode __getitem__() de dict, pas de A.

Par contre, puisque D hérite de A, quand tu appelles directement le __getitem__ de D (via le raccourci syntaxique d[0]), puisque D n’en a pas, python recherche dans la hiérarchie d’héritage, et trouve le __getitem__ de A.

À noter, je ne crois pas (à vérifier) qu’il soit possible d’obtenir la “partie parent” d’un objet, comme c’est le cas en C++ (et même en C, dans une certaine mesure) avec le système de cast de pointeurs… Je me trompe peut-être, mais j’ai bien l’impression que c’est ce que tu essayes de faire avec _inner*?
24/07/2012, 09h53
fred1599
J'ai du mal à comprendre le but, mais

Citation:

Lorsque l'on assigne un attribut ayant le même nom qu'une méthode

Pour assigner un attribut, on utilise __setattr__()

Sinon

Citation:

Code:

self.__getattr__= self._inner.__getitem__

Bizarre, syntaxiquement il y a pas d'erreur?

J'aurais plutôt fais un truc du genre
Code:

1 2 3 def __getattr__(self, attr): if attr in self._inner: return self.__getitem__(attr)
Tu as un exemple d'application, car la théorie et moi ça fait 2 :lol:

Bonjour,

En fait je pense que VV33D parle de ceci:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
class A(dict):
    def __init__(self):
        dict.__init__(self)
 
    def __getitem__(self, k):
        print "A.__getitem__", k
        return dict.__getitem__(self, k)
 
 
class D(A):
    def __init__(self):
        A.__init__(self)
        self._inner = dict()
        self.__setitem__ = self._inner.__setitem__
        self.__getitem__ = self._inner.__getitem__
        self.__delitem__ = self._inner.__delitem__
 
 
    def getinner(self):
        return self._inner
 
 
if __name__ == '__main__':
    d = D()
    d[0] = 1
    print "d[0]", d[0]
    print d.getinner()

Code:

1
2
3
d[0] A.__getitem__ 0
1
{}

Par rapport à la surcharge suivante:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
class A(dict):
    def __init__(self):
        dict.__init__(self)
 
    def __getitem__(self, k):
        print "A.__getitem__", k
        return dict.__getitem__(self, k)
 
 
class D(A):
    def __init__(self):
        A.__init__(self)
        self._inner = dict()
 
    def __setitem__(self, k, v):
        self._inner[k] = v
 
    def __getitem__(self, k):
        return self._inner[k]
 
    def __delitem__(self, k):
        del self._inner[k]
 
    def getinner(self):
        return self._inner
 
 
if __name__ == '__main__':
    d = D()
    d[0] = 1
    print "d[0]", d[0]
    print d.getinner()

Code:

1
2
d[0] 1
{0: 1}

Que l'on pourrais écrire:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
class A(dict):
    def __init__(self):
        dict.__init__(self)
 
    def __getitem__(self, k):
        print "A.__getitem__", k
        return dict.__getitem__(self, k)
 
 
class D(A):
    def __init__(self):
        A.__init__(self)
        self._inner = dict()
 
    __setitem__ = lambda self, k, v:  self._inner.__setitem__(k, v)
    __getitem__ = lambda self, k: self._inner.__getitem__(k)
    __delitem__ = lambda self, k: self._inner.__delitem__(k)
 
    def getinner(self):
        return self._inner
 
 
if __name__ == '__main__':
    d = D()
    d[0] = 1
    print "d[0]", d[0]
    print d.getinner()

Ou, suivant les besoins:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
class A(dict):
    def __init__(self):
        dict.__init__(self)
 
    def __getitem__(self, k):
        print "A.__getitem__", k
        return dict.__getitem__(self, k)
 
 
class D(A):
 
    INNER = dict()
 
    def __init__(self):
        A.__init__(self)
 
    __setitem__ = INNER.__setitem__
    __getitem__ = INNER.__getitem__
    __delitem__ = INNER.__delitem__
 
    def getinner(self):
        return self.INNER
 
 
if __name__ == '__main__':
    d = D()
    d[0] = 1
    print "d[0]", d[0]
    print d.getinner()

Mais je n'ai peut être pas compris la question.

@+

J'allais oublier:

Code:

1
2
3
4
5
6
class D(A):
    def __init__(self):
        A.__init__(self)
        self._inner = dict()
        self.__class__.__getitem__ = self._inner.__getitem__
        self.__class__.__setitem__ = self._inner.__setitem__

24/07/2012, 16h35
shaiHulud

Merci à tous pour vos réponses,

Je repars du code de PauseKawa et je récapitule :
Quand je fais d.__getitem__(0), python vérifie dans self.__dict__ la présence de __getitem__, avant d'aller voir dans les classes, ce qui est le comportement attendu.

Par contre, d[0] ne vérifie pas dans self.__dict__ et utilise directement le __getitem__ renvoyé par la hiérarchie de classes. C'est bien ce comportement qui me choque. Pourquoi diable est ce que Python n'utilise pas
getattr(self,'__getitem__') ? (Du coup j'imagine qu'il en va de même pour les autres opérateurs)

En ce qui concerne les alternatives proposées par PauseKawa, aucune ne me satisfait car
* La première (avec lambdas) me fait perdre la vitesse builtin de dict.__getitem__ (même si dans l'idée, elle fait ce que je voudrais).
* La seconde suppose que inner est un état partagé par toutes les instances de D

En ce qui concerne les autres remarques
@fred1599: désolé pour l'erreur, je voulais effectivement écrire self.__getitem__ = self._inner.__getitem__

Citation:

Pour assigner un attribut, on utilise __setattr__()

-> self.__getitem__ = ... marche aussi

Citation:

ce que tu essayes de faire avec _inner

J'essaye juste de 'surcharger' une méthode sur une instance particulière (bon ici c'est fait dans le constructeur donc ça affectera toutes les instances de D) . Et j'obtiens bien le comportement souhaité avec la syntaxe d.__getitem__(0), mais pas avec d[0]
24/07/2012, 16h43
PauseKawa

C'est bien cela : [] fait directement appel à la méthode de classe.
La dernière proposition devrais plus vous convenir (self.__class__).
24/07/2012, 16h45
fred1599

Citation:

J'essaye juste de 'surcharger' une méthode sur une instance particulière

Désolé je ne comprend pas, une surcharge opérateur sur une instance?

Là j’apprends quelque-chose, je veux bien qu'on m'explique.

Il ne serait pas possible en terme d'objet de donner un exemple d'utilisation de ce que tu souhaites faire, j'ai vraiment du mal à cerner le problème qui me semble intéressant, ce serait dommage de passer à côté. :P
24/07/2012, 17h02
shaiHulud
@fred: une solution limitée pour surcharger une méthode sur une instance seulement consiste à définir un attribut avec le même nom. Par exemple:
Code:

1 2 3 4 5 6 class A: def foo(self): return 1 b= A() a= A() a.foo= lambda:2 # foo est "surchargée" pour l'instance a seulement
Bien sur cette approche a quelques limites:
* Faire attention si on veut que a.foo dépende de l'etat de self
* Cela casse la MRO attendue si l'on dérive la classe A (i.e c'est a.foo qui sera appelé, et non classe_dérivée_de_A.foo)
* Ne marche pas avec __getitem__ dans la syntaxe a[key] !!!
24/07/2012, 17h10
shaiHulud
@PauseKawa: je n'avais pas pensé à cette approche, mais il me semble que
le comportement est partagé par toutes les instances :
Code:

1 2 3 4 d= D() # d.__getitem__ pointe vers d._inner dd= D() # dd.__getitem__ pointe vers dd._inner, mais maintenant d.__getitem__ aussi non ?
24/07/2012, 17h39
fred1599

Ah ben voilà, j'ai compris, je peux enfin réfléchir sur le sujet :mouarf:

Donc vous voulez une surcharge juste pour une instance ? Comme ceci ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
class A(dict):
    def __init__(self):
        dict.__init__(self)
 
    def __getitem__(self, k):
        print "A.__getitem__", k
        return dict.__getitem__(self, k)
 
 
class B(A):
    def __init__(self):
        A.__init__(self)
 
    def getinner(self):
        return self._inner
 
 
class Dummy:
    def __init__(self):
        self._inner = dict()
        self.__class__.__getitem__ = self._inner.__getitem__
        self.__class__.__setitem__ = self._inner.__setitem__
        self.__class__.__delitem__ = self._inner.__delitem__
 
 
if __name__ == '__main__':
    b = type('Justme', (Dummy, B), {})()
    b[0] = 1
    print "b[0]", b[0]
    print b.getinner()

...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class A(dict):
    def __init__(self):
        dict.__init__(self)
 
    def __getitem__(self, k):
        print "A.__getitem__", k
        return dict.__getitem__(self, k)
 
 
class B(A):
    def __init__(self):
        A.__init__(self)
 
 
class Dummy:
    def __init__(self):
        self.__class__.__getitem__ = self._inner.__getitem__
        self.__class__.__setitem__ = self._inner.__setitem__
        self.__class__.__delitem__ = self._inner.__delitem__
 
 
if __name__ == '__main__':
    b = type('Justme', (Dummy, B), {'_inner': dict(), 'getinner': lambda self : self._inner})()
    b[0] = 1
    print "b[0]", b[0]
    print b.getinner()

Etc...

Et un dernier avec type

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class A(dict):
    def __init__(self):
        dict.__init__(self)
 
    def __getitem__(self, k):
        print "A.__getitem__", k
        return dict.__getitem__(self, k)
 
 
class B(A):
    def __init__(self):
        A.__init__(self)
 
 
if __name__ == '__main__':
    b = type('_', (B,), {'_inner': dict(), 'getinner': lambda self : self._inner,
                        '__getitem__': lambda self, k: self._inner.__getitem__(k),
                        '__setitem__': lambda self, k, v : self._inner.__setitem__(k, v),
                        '__delitem__': lambda self, k : self._inner.__delitem__(k)})()
    b[0] = 1
    print "b[0]", b[0]
    print b.getinner()
    c = B()
    c[0] = 1
    print "c[0]", c[0]

Code:

1
2
3
4
b[0] 1
{0: 1}
c[0] A.__getitem__ 0
1

24/07/2012, 21h06
PauseKawa

Bonsoir,

Ceci dit:

Citation:

Envoyé par VV33D

* La première (avec lambdas) me fait perdre la vitesse builtin de dict.__getitem__

Vu la taille du bloc et la closure de lambda je ne pense pas que cela soit si énorme... A tester sur sur une longue itération/des itérations multiples.
Ce ne sera sans doute pas au même niveau mais la question se pose sur le besoin de 'vitesse'.

type propose une flexibilité via le dico. C'est énorme pour construire de multiples instances 'personnalisées'.

@+
25/07/2012, 00h10
wiztricks

Salut,

Au cas où, cela est documenté ici.

J'ai compris que c'était une histoire de clou qu'on essaie de faire entrer là où çà ne veut pas... Pourquoi insister? Une colle pourrait très bien faire l'affaire!
D'autant que Python est assez fourni côté "collages".
Mais, désolé, je n'ai pas compris le cas d'utilisation i.e. le lien qu'on cherche à construire entre B, A et le dict...
Bon courage
- W

Citation:

Mais, désolé, je n'ai pas compris le cas d'utilisation i.e. le lien qu'on cherche à construire entre B, A et le dict...

Si j'ai bien compris l'objectif est de faire vérifier que le nom de l'attribut d'un objet n'est pas le même nom qu'une méthode de l'objet.

Dans le cas où le nom de l'attribut est équivalent au nom de la méthode de l'objet, il faut éviter l'assignation, sinon, l'assignation a lieu.

Je ferais quelque-chose de très simple du genre
Code:

1 2 3 4 5 6 7 8 class A: def foo(self): return 1 def __setattr__(self, attr, value): if attr in dir(self): raise ValueError else: self.__dict__[attr] = value

Bonjour fred1599,

C'est justement le fait qu'avec [] __dict__ n'est pas utilisé qui gène VV33D:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class A(dict):
    def __init__(self):
        dict.__init__(self)
 
    def __getitem__(self, k):
        print "A.__getitem__", k
        return dict.__getitem__(self, k)
 
 
class B(A):
    def __init__(self):
        A.__init__(self)
        self._inner = dict()
        self.__dict__['__getitem__'] = self._inner.__getitem__
        self.__dict__['__setitem__'] = self._inner.__setitem__
 
 
if __name__ == '__main__':
    b = B()
    b[0] = 1
    print "b[0]", b[0]

Bonjour,

Merci pour ces remarques.

Citation:

x[i] is roughly equivalent to type(x).__getitem__(x, i)

Pourquoi est ce que type(x).__getitem__(x, i) revient à chercher i d'abord dans les classes, puis dans l'instance. Ou puis-je trouver de la doc sur la fonction type() svp?
En effet, si les classes ne définissent pas de getitem, mais que l'instance le fait, c'est l'attribut d'instance qui sera utilisé (cf classe DD ci dessous)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 class A(dict): def __init__(self): dict.__init__(self) def __getitem__(self, k): print "A.get ",k return dict.__getitem__(self, k) class D(A): def __init__(self): A.__init__(self) self._inner= dict() "Shortcuts __getitem__ to self._inner" self.__getitem__= self._inner.__getitem__ self.__setitem__= self._inner.__setitem__ class DD(): def __init__(self): self._inner= dict() self.__getitem__= self._inner.__getitem__ self.__setitem__= self._inner.__setitem__ if __name__ == '__main__': d=D() dd=DD() d._inner[0]= 1 d[0]= 1 dd._inner[0]= 1 dd[0]= 1 print "d[0]" d[0] # CALLS __getitem__, UNEXPECTED ! print "d.__getattr__(0)" d.__getitem__(0) # does not call __getitem__, as expected print "="*20 print "dd[0]" dd[0] # does not call __getitem__, as expected print "dd.__getattr__(0)" dd.__getitem__(0) # does not call __getitem__, as expected
@wiztricks: il n'y a pas vraiment de cas d'utilisation. Disons que je veux court-circuiter dans D les appels à A.__getitem__, pour des pb de performances (donc avec une simple buitin). Je devrais sans doute plutôt refaire ma hiérarchie de classe !

@PauseKawa: je fais beaucoup plus d'accès particuliers (d[key]) que d'itérations sur d. Du coup, je pense que le lambda me fait vraiment perdre du temps (car l'appel qu'il wrappe est court) .Par contre faut vraiment que je me mette à type(), merci pour les exemples

et un cas qui fait planter

Si on dérive d'object et de la classe qui particularise la méthode dans le constructeur, on obtient une jolie

Citation:

TypeError: 'xD' object does not support item assignment

J'en conclus que type() se comporte très différemment quand on dérive d'object, mais ça ma laisse perplexe quand même. Pourquoi Python a-t'il besoin de faire type(x).__getitem__(x, i) , plutôt que getattr(x,'__getitem__')(i) ???

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
class A(dict):
    def __init__(self): dict.__init__(self)
    def __getitem__(self, k):
        print "A.get ",k
        return dict.__getitem__(self, k)
 
class D(A):
    def __init__(self):
        A.__init__(self)
        self._inner= dict()
        "Shortcuts __getitem__ to self._inner"
        self.__getitem__= self._inner.__getitem__
        self.__setitem__= self._inner.__setitem__
 
class DD:
    def __init__(self):       
        self._inner= dict()        
        self.__getitem__= self._inner.__getitem__
        self.__setitem__= self._inner.__setitem__    
 
class xD(DD,object):
    def __init__(self): DD.__init__(self)
 
def test(d):
    d._inner[0]= 1 
    d[0]= 1
    print "d[0]"
    d[0]
    print "d.__getitem__(0)"
    d.__getitem__(0)
 
if __name__ == '__main__':
#    d=D()
#    print "D---"*20
#    test(d)
#    d=DD()
#    print "DD--"*20
#    test(d)
    d=xD()
    print "xD--"*20
    test(d)

25/07/2012, 14h04
wiztricks

Citation:

Envoyé par VV33D

Pourquoi Python a-t'il besoin de faire type(x).__getitem__(x, i) , plutôt que getattr(x,'__getitem__')(i) ???

Il faut lire la doc plus loin.
- W

Voir 40 message(s) de cette discussion en une page