Méthode à définir au moment de l'initialisation

Salut,

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

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:

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 ?

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/

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à.

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:

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 $

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

Code:

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")

Citation:

Envoyé par pierjean

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

Code:

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 :P

Citation:

Envoyé par 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:

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:

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

Une autre solution :

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
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

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.