Discussion :

[Slash941210]

Bonjour !

Avant toute chose j'ai précisé "Python 3.x" car c'est la version du langage que j'utilise mais cela ne rentre pas en compte dans le souci auquel je fais face (il n'est pas non plus propre à Python d'ailleurs)

C'est une question de POO. Je suis actuellement en train de traiter des fichiers contenant l'historique de centaines de milliers de commandes, une commande étant une suite alphanumérique.
J'ai donc créé une classe Command me permettant d’interagir plus facilement avec tout ça. Il y a plusieurs niveaux de commandes. Une commande appartient à une des 2 grandes catégories (envoyées, reçues). Parmi les commandes envoyées il y a des commandes de contrôle, d'action, ... et ainsi de suite jusqu'à donner une arborescence assez complexe.

Le problème auquel je suis confronté est que je ne suis capable de déterminer la catégorie d'une commande qu'une fois celle-ci décortiquée. C'est comme si je savais que j'avais affaire à des animaux mais que je ne sois capable d'en donner l'espèce et la race qu'après une étude de celui-ci.

Si on garde le schéma des animaux, je souhaiterais appeler une fonction ou constructeur indifférencié qui me retourne la race (donc l'espèce) de l'objet différencié au plus possible.

Animal("Vache") me retournerait un objet de la classe Bovin, étant une classe fille de Mammifère, elle même classe fille de Vertébré, ...
Animal("Chat") me retournerait un objet de la classe Félin étant elle aussi fille de Mammifère, ... et ainsi de suite

Est-ce que faire des appels de constructeurs en cascade est la bonne solution ?
Animal("Vache") redirigerait vers le constructeur de Vertébré arrivé au test de présence d'os, qui lui même redirigerait vers le constructeur de Mammifère car cette espèce allaite, ...


Si vous pouviez m'aider à y voir plus clair je vous en serais très reconnaissant. C'est la fondation de mon projet, je souhaiterais donc y passer du temps pour partir sur une base solide dès le départ

[Dan737]

Bonjour,

Vu qu'on est en Python, il suffit tout simplement d'avoir une méthode statique dans la classe mère, qui prend en argument une suite alphanumérique et qui retourne une instance de la classe voulue. La logique pour découvrir de quelle classe tu as besoin se trouve dans cette méthode statique.

On pourrait bien entendu juste en faire une fonction toute simple. Mais en la marquant comme méthode statique de la classe mère, on indique que c'est une fonction qui a un rapport avec la classe mère.

Ce design pattern est connu sous le nom de Factory method​.

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
31
32
33
34
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
class Command:
    def __repr__(self):
        return "Classe Command"
 
    @staticmethod
    def create_from(token):
        if token == "a":
            return Action()
        elif token == "c":
            return Control()
        else:
            raise ValueError("Cannot determine command from token {}".format(token))
 
class Action(Command):
    def __repr__(self):
        return "Classe Action"
 
class Control(Command):
    def __repr__(self):
        return "Classe Control"
 
if __name__ == '__main__':
    commands_string = "a c a"
    commands = []
    for command in commands_string.split():
        cmd = Command.create_from(command)
        commands.append(cmd)
 
    print("Objects instanciés:")
    for cmd in commands:
        print(cmd)

[Slash941210]

Je pense avoir compris l'idée !

Merci beaucoup pour ton aide !