Discussion :

[yacinechaouche]

Salut,

Supposons que j'ai une class MaClasse avec 3 méthodes method_a, method_b et method_c.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
class MaClasse(object):
    def method_a(self):
        print "a"
    def method_b(self):
        print "b"
    def method_c(self):
        print "c"

Le code qui va utiliser une instance de cette classe a besoin d'appeler une seule méthode m dans tout le reste du code, m doit être choisi parmi method_a, method_b, ou method_c, par exemple au moment de l'initialisation

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class MaClasse(object):
    def method_a(self):
        print "a"
    def method_b(self):
        print "b"
    def method_c(self):
        print "c"
 
    def __init__(self,mode):
        # faire le necessaire pour que self.m soit définie
        [...]
 
i = MaClasse("b")
i.m() # doit appeler i.method_b
j = MaClasse("c")
j.m() # doit appeler j.method_c

Que proposez vous comme solutions ?

[Grumphette]

Bonjour,

Là comme ça à froid je te dirai de regarder le principe des factory. ça te permet d'encapsuler la création d'objet. Voici un lien qui devrait t'éclairer sur le sujet : https://pythonspot.com/factory-method/

[zancrows]

Bonjour,

tel que tu le décris ça ressemble au design pattern état ( ou "state"). tu devrais peut-être regarder de ce côté là.

[yacinechaouche]

Merci pour le lien. D'après ce que j'en ai lu la factory methode va créer une instance dynamiquement, ce qui va me forcer à écrire plusieurs classes avec une seule méthode m unique, on ne prend pas le problème par le bon côté.

Voici ce que j'ai pensé à faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
ychaouche#ychaouche-PC 12:05:35 ~/CODE/TEST/PYTHON $ cat binding.py
import functools
 
class MaClasse(object):
    def method_a(self):
        print "a"
    def method_b(self):
        print "b"
    def method_c(self):
        print "c"
 
    def __init__(self,mode):
        self.m =functools.partial(self.methods[mode],self)
 
 
    methods = {
        "a":method_a,
        "b":method_b,
        "c":method_c
    }
 
i = MaClasse("b")
i.m() # doit appeler instance.method_b
j = MaClasse("c")
j.m() # doit appeler instance;method_c
 
ychaouche#ychaouche-PC 12:05:35 ~/CODE/TEST/PYTHON $ python binding.py
b
c
ychaouche#ychaouche-PC 12:05:37 ~/CODE/TEST/PYTHON $

[pierjean]

Bonjour,
Ou, plus simple à mon goût :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
class MaClasse(object):
    def method_a(self):
        print ("a")
    def method_b(self):
        print ("b")
    def method_c(self):
        print ("c")
 
    def __init__(self,mode):
        self.m =getattr(self,"method_{}".format(mode))
 
i=MaClasse2("b")

[hotcryx]

Bonjour,
Ou, plus simple à mon goût :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
class MaClasse(object):
    def method_a(self):
        print ("a")
    def method_b(self):
        print ("b")
    def method_c(self):
        print ("c")
 
    def __init__(self,mode):
        self.m =getattr(self,"method_{}".format(mode))
 
i=MaClasse2("b")

de la même façon, avec eval() ça devrait passer aussi

[lg_53]

Merci pour le lien. D'après ce que j'en ai lu la factory methode va créer une instance dynamiquement, ce qui va me forcer à écrire plusieurs classes avec une seule méthode m unique, on ne prend pas le problème par le bon côté.

Voici ce que j'ai pensé à faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
ychaouche#ychaouche-PC 12:05:35 ~/CODE/TEST/PYTHON $ cat binding.py
import functools
 
class MaClasse(object):
    def method_a(self):
        print "a"
    def method_b(self):
        print "b"
    def method_c(self):
        print "c"
 
    def __init__(self,mode):
        self.m =functools.partial(self.methods[mode],self)
 
 
    methods = {
        "a":method_a,
        "b":method_b,
        "c":method_c
    }
 
i = MaClasse("b")
i.m() # doit appeler instance.method_b
j = MaClasse("c")
j.m() # doit appeler instance;method_c
 
ychaouche#ychaouche-PC 12:05:35 ~/CODE/TEST/PYTHON $ python binding.py
b
c
ychaouche#ychaouche-PC 12:05:37 ~/CODE/TEST/PYTHON $

oui c'est bien ça. Tu peux aussi t'abstenir de functools en passant par lambda :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
    def __init__(self,mode):
        self.m = lambda : self.methods[mode](self)

Une autre solution :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class MaClasse(object):
    def method_a(self):
        print "a"
 
    def method_b(self):
        print "b"
 
    def method_c(self):
        print "c"
 
    def __init__(self,mode):
        self.m = {
                "a": self.method_a,
                "b": self.method_b,
                "c": self.method_c
                }[mode]
 
 
 
 
i = MaClasse("b")
i.m() # doit appeler instance.method_b
j = MaClasse("c")
j.m() # doit appeler instance;method_c

[yacinechaouche]

Merci à tous pour vos réponses, j'ai opté pour getattr car apparemment ça n'a aucun impact sur la performance de mon code, mais j'ai bien aimé la solution avec lambda aussi (je dois essayer !). Je ne sais pas si la proposition d'utiliser eval était sérieuse, il y a un smiley à la fin je ne suis pas sûre du ton employé j'ai l'habitude de lire de qu'eval c'est mal.