Modifier un objet

Version imprimable

Modifier un objet

Bonjour,

j'ai une classe qui prend un objet et lui ajoute des propriétés en modifiant son MRO.

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
43
44
45
46
47
48
49
50
51
52
53
54
 
# objet quelconque
class UnObjet:
 
    def __init__(self,x):
        self.x = x
        print('foo')
 
 
 
# classe qui modifie un objet
class Mod:
 
    def __new__(cls,objet,*args):
        objet.__class__ = type('**',(cls,objet.__class__),{})
        return objet
 
    def __init__(self,*args):
        print('mod')
 
    @property
    def y(self):
        return self.x + 2
 
 
 
#classe qui cree un objet et le modifie
class Mod2(Mod):
 
    #ici il faut surcharger __new__
    def __new__(cls,x,z):
        instance = Mod.__new__(cls,UnObjet(x))
        return instance
 
    def __init__(self,x,z):
 
        Mod.__init__(self)
        print('mod2')
 
    #d'autres propriétés ici
 
 
 
 
objet = Mod(UnObjet(5))
print(objet.y)
#foo
#mod
#7
objet = Mod2(8,3)
print(objet.y)
#foo
#mod
#10

y a-t-il une façon de faire ceci sans passer par __new__ ? Car les classes qui héritent de Mod doivent aussi surcharger __new__.
la seule solution qui me vient à l'esprit c'est de passer par une fonction qui retourne une instance.
qu'en pensez-vous ?

Merci.

23/02/2023, 11h48
wiztricks

Salut,

Citation:

Envoyé par josmiley

y a-t-il une façon de faire ceci sans passer par __new__ ? Car les classes qui hérites de Mod doivent aussi surcharger __new__.
la seule solution qui me vient à l'esprit c'est de passer par une fonction qui retourne une instance.

Le code modifie l'attribut __class__ de l'instance d'UnObjet avec une nouvelle classe ** qui hérite de Mod et UnObjet.
Ce qui est discutable est que le __new__ de Mod retourne un ** plutôt qu'un Mod: on cannibalise une interface système existante pour faire quelque chose qui pourrait se faire très bien ailleurs (et donc à faire autrement... d'où peut être la question).

Ceci dit, en POO, le changement de comportement d'un objet est généralement traité avec le state pattern qui fait cela sans bidouiller l'attribut système __class__ (option qui n'est pas disponible dans beaucoup de langages objets)...
Personnellement quand je le fais, je garde quand même l'ossature du pattern (ça permet de documenter la bidouille).

- W
23/02/2023, 13h42
josmiley

J'ai beau lire et relire les exemples que j'ai trouvé sur le state pattern , je ne vois pas comment cela s'applique ici. Mais il est probable que je n'ai rien compris :)
23/02/2023, 13h58
wiztricks

Citation:

Envoyé par josmiley

J'ai beau lire et relire les exemples que j'ai trouvé sur le state pattern , je ne vois pas comment cela s'applique ici. Mais il est probable que je n'ai rien compris :)

Il faudrait reprendre le state pattern basique... puis le faire évoluer petit à petit vers.
Ou bien on reformule le besoin initial avec... mais comme on l'ignore, refaire le boulot de conception risque de voir surgir d'autres solutions.

note: Ceux qui connaissent bien Python reformulent un problème avec les structures de bases du langage (liste, dict, ...). Si je pense POO, je reformule avec des patterns. Ce qui est un exercice bien en amont du codage (et qui n'a rien à voir avec un langage particulier).

- W

Bonjour

Citation:

Envoyé par josmiley

j'ai une classe qui prend un objet et lui ajoute des propriétés en modifiant son MRO.

Je ne vois pas trop, dans ton exemple, où tu rajoutes des propriétés. Tu parles de "y"? Mais "y" ce n'est pas une propriété, c'est un getter !!!

Citation:

Envoyé par josmiley

la seule solution qui me vient à l'esprit c'est de passer par une fonction qui retourne une instance.
qu'en pensez-vous ?

Peut-être les métaclasses?
Voici un exemple complet. La métaclasse "custom" récupère des classes pour les customiser. Et pour chaque classe récupérée, elle transforme chaque méthode "xxx", quelle qu'elle soit, en méthode nommée "custom_xxx"

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
43
44
#!/usr/bin/env python3
# coding: utf-8
 
# La fonction de customisation
# Chaque méthode de la classe customisée sera nommée "custom_<nom de la méthode>"
def custom(cls, parents, attr):
	# Un petit affichage préalable pour montrer ce qui se passe…
	print("custom: cls=%s, parents=%s, attr=%s" % (cls, parents, attr))
 
	# Elle commence par créer le dictionnaire des nouveaux attributs
	nouveaux_attr=dict()
 
	# Puis elle traite les méthodes de la classe reçue en paramètre
	for (k, v) in attr.items():
		# La nouvelle clef est créée selon le nom de la méthode d'origine (si celle-ci n’est pas une méthode spéciale)
		new_k=("custom_" if not k.startswith("__") else "") + k
		print(k, v, new_k)
 
		# Le code de la méthode d'origine est recopié dans le nouveau dictionnaire avec son nouveau nom
		nouveaux_attr[new_k]=v
	# for
	print(nouveaux_attr)
 
	# La fonction renvoie une nouvelle classe créée dynamiquement depuis la classe reçue
	return type(cls, parents, nouveaux_attr)
# custom()
 
# L’objet "toto" qui sera customisé par la fonction
class toto(metaclass=custom):
	def affich(self):
		print("my name is toto!!!")
# class toto
 
# L’objet "titi" qui sera customisé par la fonction
class titi(metaclass=custom):
	def print(self):
		print("my name is titi!!!")
# class titi
 
# Test de la customisation
to=toto()
ti=titi()
to.custom_affich()		# La méthode "affich" d'origine a été renommée en "custom_affich"
ti.custom_print()		# La méthode "print" d'origine a été renommée en "custom_print"

Citation:

Envoyé par Sve@r

Bonjour

Je ne vois pas trop, dans ton exemple, où tu rajoutes des propriétés. Tu parles de "y"? Mais "y" ce n'est pas une propriété, c'est un getter !!!

Peut-être les métaclasses?
Voici un exemple complet. La métaclasse "custom" récupère des classes pour les customiser. Et pour chaque classe récupérée, elle transforme chaque méthode "xxx", quelle qu'elle soit, en méthode nommée "custom_xxx"

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
43
44
#!/usr/bin/env python3
# coding: utf-8
 
# La fonction de customisation
# Chaque méthode de la classe customisée sera nommée "custom_<nom de la méthode>"
def custom(cls, parents, attr):
	# Un petit affichage préalable pour montrer ce qui se passe…
	print("custom: cls=%s, parents=%s, attr=%s" % (cls, parents, attr))
 
	# Elle commence par créer le dictionnaire des nouveaux attributs
	nouveaux_attr=dict()
 
	# Puis elle traite les méthodes de la classe reçue en paramètre
	for (k, v) in attr.items():
		# La nouvelle clef est créée selon le nom de la méthode d'origine (si celle-ci n’est pas une méthode spéciale)
		new_k=("custom_" if not k.startswith("__") else "") + k
		print(k, v, new_k)
 
		# Le code de la méthode d'origine est recopié dans le nouveau dictionnaire avec son nouveau nom
		nouveaux_attr[new_k]=v
	# for
	print(nouveaux_attr)
 
	# La fonction renvoie une nouvelle classe créée dynamiquement depuis la classe reçue
	return type(cls, parents, nouveaux_attr)
# custom()
 
# L’objet "toto" qui sera customisé par la fonction
class toto(metaclass=custom):
	def affich(self):
		print("my name is toto!!!")
# class toto
 
# L’objet "titi" qui sera customisé par la fonction
class titi(metaclass=custom):
	def print(self):
		print("my name is titi!!!")
# class titi
 
# Test de la customisation
to=toto()
ti=titi()
to.custom_affich()		# La méthode "affich" d'origine a été renommée en "custom_affich"
ti.custom_print()		# La méthode "print" d'origine a été renommée en "custom_print"

salut,
pour la première question j'ai donner un exemple simple vite fait.
pour les metaclass, ça implique de modifier le code des classes "class toto(metaclass=custom):", et que la customisation s'applique à toutes les instances non ?

voilà une version avec fonction qui retourne une instance; finalement plus simple que de surcharger __new__.

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
43
44
45
46
47
48
49
 
 
# objet quelconque
class UnObjet:
 
    def __init__(self,x):
        self.x = x
        print('foo')
 
 
# classe qui modifie un objet
class Mod:
 
    def __new__(cls,objet,*args):
        objet.__class__ = type('**',(cls,objet.__class__),{})
        return objet
 
    def __init__(self,*args):
        print('mod')
 
    @property
    def y(self):
        return self.x + 2
 
 
 
def Mod2(x,z): 
 
    #classe qui cree un objet et le modifie
    class Mod2_(Mod):
 
        def __init__(self,objet,z):
            Mod.__init__(self)
            print('mod2')
            print('z =',z)
 
        #d'autres propriétés ici
 
    objet = UnObjet(x)
    return Mod2_(objet,z)
 
 
objet = Mod2(8,3)
print(objet.y)
#foo
#mod
#mod2
#z = 3
#10

23/02/2023, 18h12
Sve@r

Citation:

Envoyé par josmiley

pour la première question j'ai donner un exemple simple vite fait.

Effectivement j'avais pas fait attention que tu passes UnObjet. Toutefois ce n'est pas une vraie modif. Tu ne fais que créer un objet "Mod" contenant les attributs de "UnObjet" et un getter. A la limite tu hériterais de "UnObjet" ça ferait pareil.

Citation:

Envoyé par josmiley

pour les metaclass, ça implique de modifier le code des classes "class toto(metaclass=custom):", et que la customisation s'applique à toutes les instances non ?

Ah effectivement. On n'a même pas à parler d'instance tellement c'est implicite. C'est la classe elle-même qui est modifiée dans sa définition ; les instances seront donc automatiquement instances de la classe modifiée. Mais je pensais que c'était ce que tu voulais (qui dit "modifier un objet" dit par transitivité "modifier toutes les instances de l'objet")...
23/02/2023, 18h57
josmiley

Oui en héritant de UnObjet ça serait pareil , mais c'était pour l'exemple ,en fait ça peut être n'importe quel objet .

Plus concrètement j'ai différents objets graphiques,boutons ,fenêtres ,image, etc...
En passant cet objet en argument d'instanciation à une classe Cursor celui-ci devient draggable.
Ça peut servir entre autres à faire differents types de toggleswitch.
En gros , ma logique c'est pas, "fait un toggleswitch avec ce bouton", mais plutôt "prend n'importe quel objet et fais en un toggleswitch".