Discussion :

[toitoinebzh]

Bonjour,

Je code un peu de temps en temps et je rencontre actuellement une situation qui n'est pas bloquante mais que je ne sais pas affrontée "proprement".

En gros, je cherche à coder un outil qui permet de connaître les propriétés physiques d'un matériau dans des conditions données.
Pour cela j'ai créer une classe qui vise a représenter un matériau avec des méthodes qui me permettent de calculer l'évolution de ces propriétés physiques.
La problématique qui se pose maintenant est que je souhaite que cette class prenne en compte le fait que chaque matériau à des lois de comportement (équations) différentes avec des paramètres différents, que je souhaite pouvoir ajouter de manière assez simple de nouveaux matériaux pour faire une sorte de base de données (idéalement un fichier par matériau que la classe viendrait lire), et c'est là que cela se corse.

J'espère que ma question est claire, si vous avez des suggestions je suis intéressé

Merci

[lg_53]

Si c'était juste des paramètres qui différaient tu pourrais stockés leur valeur dans un dictionnaire par exemple (chaque entrée est un matériau, et les valeurs du dictionnaires serait des listes de valeurs de paramètres (ou des dictionnaires aussi si tu veux que tes paramètres soient nommés)). Ce genre de structure s'exporte ensuite très bien dans un fichier (cf. la librairie json de python).

Là comme les équations diffèrent c'est un peu plus complexe. Soit tu arrives à créé une équation à partir d'une chaine de caractère par exemple (mais c'est un peu dangereux), et dans ce cas ton équation pourra aussi s'exportée dans un fichier. Soit sinon tu utilises le polymorphisme :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Materiau(): 
    pass
 
class Or(Materiau):
    def comportement(self) :
        #### la loi de comportement de l'or
 
class Argent(Materiau):
    def comportement(self) :
        #### la loi de comportement de l'argent
 
class Cuivre(Materiau):
    def comportement(self) :
        #### la loi de comportement du cuivre

Les méthodes doivent avoir exactement le même prototype (les mêmes arguments). Dans ce cas si dans ton code tu veux changer le matériau, tu n'auras que la ligne où tu construis ton matériau à changer. Le reste du code (notemment l'appel à la méthode de comportement) restera inchangé.

[toitoinebzh]

Merci pour ce retour,
en effet je n'avais pas pensé à la solution du polymorphisme que je n'ai jamais utilisé jusqu'ici et à l’interprétation d'une chaîne de caractère pour l'équation
quel est le risque par rapport à cette dernière solution ? peux t on appeler des méthodes de cette manière ?

[lg_53]

Stocker l'équation dans un fichier c'est donc la stocker sous la forme d'une chaine de caractère. Et ensuite tu feras :

Code :

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

1
2
3
s="def f(x) : return x*x"
eval(s)
print(f(5))

Mais là faudra imaginer que s ne sera pas défini dans ton code, et à fortiori pas juste au dessus de ton instruction eval. Ca sera une chaine de caractère qui proviendra d'un fichier d'input. Donc rien ne te garantira que :
- cette chaine contient un code python valide
- cette chaine définisse bien une fonction nommée f, et qui prend exactement un seul paramètre

Avant l'instruction eval, python ne connait pas f, après oui. Mais si dans la chaine de caractère il n'y a pas ce qu'il faut, ca va être compliqué pour débugger.

Une solution intermédiaire (pour laquelle j'opterais) serait de donner un nom aux lois. Ainsi dans le fichier au lieu d'écrire la loi, tu écris son nom. Et après en fonction du nom, en python, tu peux aller chercher la loi qu'il faut.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def loi1(x) : return x*x
 
def loi2(x) : return 2*x
 
lois = { "nom_loi1":loi1 , "nom_loi2": loi2 }   ### Un dictionnaire de fonction
 
class Materiau():
   def __init__(self, nom_loi):
          assert( nom_loi in lois ),"Loi inconnue"
          self.nom_loi = nom_loi
 
   def comportement(self,x):
         f = lois[self.nom_loi]  ### On récupère la bonne loi (une fonction)
         return f(x)

[Sve@r]

Bonjour

Code :

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

1
2
3
4
5
def loi1(x) : return x*x
 
def loi2(x) : return 2*x
 
lois = { "nom_loi1":loi1 , "nom_loi2": loi2 }   ### Un dictionnaire de fonction

Ici l'utilisation de lambda peut s'avérer utile. Et si les lois appartiennnent à l'objet, alors on peut les intégrer en tant que membre statique de l'objet

Code :

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

1
2
3
4
5
class Materiau():
	lois={ "nom_loi1": lambda x: x*x , "nom_loi2" : lambda x: x*2 }   ### Un dictionnaire de fonction
	def __init__(self, nom_loi):
		assert(nom_loi in Materiau.lois), "Loi inconnue"
		self.nom_loi = nom_loi

[toitoinebzh]

merci lg_53, je pense que ta solution est la bonne
je vais oublier les eval et je comprend mieux ces défauts avec tes explications