Enchainer construction et appel / comparaison profonde

Version imprimable

23/02/2009, 19h00
sopsag

Enchainer construction et appel / comparaison profonde
Bonjour,
y a-t-il un moyen d'enchaîner la construction et l'appel d'une de ses méthodes ?

Voici un bout de code pour comprendre ma question :
Code:

1 2 3 4 5 6 class Spam: def __init__(self): self.eggs = 0 def set (self,x,message): self.eggs = x print message,': eggs =',self.eggs
ce qui fonctionne mais ne me plait pas :roll:
Code:

1 2 3 4 s1 = Spam() s1.set( 12,'appels séparés') # appels séparés : eggs = 12 print s1 # <__main__.Spam instance at 0x00B557B0> print s1.eggs # 12
ce qui me plait mais ne fonctionne pas :evilred: (s2 vaut None)
Code:

1 2 s2 = Spam().set( 5,'appels enchainés') # appels enchainés : eggs = 5 print s2 # None
Et d'ailleur, pourquoi ai-je None ?
Je n'arrive pas à comprendre le mécanisme sous-jacent de python qui me donne None...

Attention, je ne veux pas polluer ma fontion __init__ en ajoutant un paramètre x.
Ici, c'est un exemple très simplifié.
Dans mon vrai code, __init__ a déjà plein de paramètres et je trouverais très laid d'en ajouter juste pour résoudre ce problème.

And now for something completely different !
Un autre problème, celui de la comparaison profonde :
Code:

1 2 3 4 5 6 7 class Bean: def __init__ (self,x): self.eggs = x bean1 = Bean( 5 ) bean2 = Bean( 5 ) print bean1 == bean2 # False
Comment recevoir True ?
Autrement dit, y a-t-il un moyen de comparer les contenus (et non les pointeurs) ?

Voilà, si quelqu'un a des idées, je suis preneur.

Merci d'avance.
Hadrien
(z'avez vu, j'ai mis des balises CODE :yaisse2:)
23/02/2009, 19h47
Guigui_
Citation:
Envoyé par sopsag

Bonjour,
y a-t-il un moyen d'enchaîner la construction et l'appel d'une de ses méthodes ?

Voici un bout de code pour comprendre ma question :

Code:

1 2 3 4 5 6 class Spam: def __init__(self): self.eggs = 0 def set (self,x,message): self.eggs = x print message,': eggs =',self.eggs

ce qui fonctionne mais ne me plait pas :roll:

Code:

1 2 3 4 s1 = Spam() s1.set( 12,'appels séparés') # appels séparés : eggs = 12 print s1 # <__main__.Spam instance at 0x00B557B0> print s1.eggs # 12
A part en recréant une fonction qui fait ses 2 successivement ses 2 étapes, je vois pas.
Si tu veux simplement que cela tienne en une ligne, utilise le ; entre les 2 instructions

Code:

s1 = Spam() ; s1.set( 12,'appels séparés')
Citation:
Envoyé par sopsag

ce qui me plait mais ne fonctionne pas :evilred: (s2 vaut None)

Code:

1 2 s2 = Spam().set( 5,'appels enchainés') # appels enchainés : eggs = 5 print s2 # None

Et d'ailleur, pourquoi ai-je None ?
Je n'arrive pas à comprendre le mécanisme sous-jacent de python qui me donne None...
s2 a la valeur de retour de la fonction set, donc None

Citation:

Envoyé par sopsag

Attention, je ne veux pas polluer ma fontion __init__ en ajoutant un paramètre x.
Ici, c'est un exemple très simplifié.
Dans mon vrai code, __init__ a déjà plein de paramètres et je trouverais très laid d'en ajouter juste pour résoudre ce problème.

si ta fonction __init__ est déjà inbuvable, c'est qu'elle est peut-être mal conçue ? Tu peux utiliser les *args et **dict: http://python.developpez.com/faq/?pa...nFuncSurcharge
Citation:
Envoyé par sopsag

And now for something completely different !
Un autre problème, celui de la comparaison profonde :

Code:

1 2 3 4 5 6 7 class Bean: def __init__ (self,x): self.eggs = x bean1 = Bean( 5 ) bean2 = Bean( 5 ) print bean1 == bean2 # False

Comment recevoir True ?
Autrement dit, y a-t-il un moyen de comparer les contenus (et non les pointeurs) ?

Voilà, si quelqu'un a des idées, je suis preneur.

Merci d'avance.
Hadrien
(z'avez vu, j'ai mis des balises CODE :yaisse2:)
tu peux surcharger la fonction égalité
Code:

1 2 3 4 5 6 7 8 9 10 11 >>> class Bean(object): def __init__ (self,x): self.eggs = x def __eq__(self, other): return self.eggs == other.eggs >>> b =Bean(5) >>> c = Bean(5) >>> b == c True
quelques détails ici: http://python.developpez.com/faq/?pa...ratorSurcharge

en retournant l'objet par la méthode set et en implementant la méthode __repr__ tu peux obtenir le comportement désiré:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# -*- coding: iso-8859-15 -*-
class Spam(object):
 
    def __init__(self):
        self.eggs = 0
 
    def set(self, x, message):
        self.eggs = x
        print message, ': eggs = ', self.eggs
        return self
 
    def __repr__(self):
        return "%s" % self.eggs
 
 
s1 = Spam()
s1.set(12, 'appels séparés')
print s1
 
s2 = Spam().set(5, 'appels enchainés')
print s2

on obtient:

Code:

1
2
3
4
appels séparés : eggs =  12
12
appels enchainés : eggs =  5
5

24/02/2009, 11h15
sopsag

Super !

Mais bon sang, mais c'est bien sûr, None c'est le retour de set !
Il suffisait d'ajouter return self !
En fait, tout ça c'est pour faire une élégante compréhension de liste :mrgreen:.

Quant à la comparaison profonde, j'esperais une fonction super sioux qui utiliserait l'introspection pour tester récursivement l'égalité de 2 instances, champ par champ.
Surcharger __eq__ donne un meilleur controle mais suppose de le faire pour toutes les sous classes.
Ca fait très c++ mais ça me va...

Merci à vous 2 :king:
(super ton ornithorynque pacificator)