Discussion :

[Aelurus_]

Bonjour à tous,

en guise d'exercice je voudrais tenter de solutionner un carré des moyennes pour simuler un transfert thermique à état stationnaire. Pour cela je souhaiterais essayer de construire une Class avec les méthodes utiles aux différentes fonctions. Voici comment je commence par poser les bases comme cela :

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
class bar:
    """
    Cette classe sert à calculer le transfert thermique à etat stationnaire en deux dimensions
    selon la méthode du carré de Dichelet, ou carré des moyennes d'une tranche longitudinale  d'une barre
    """    
    def __init__(self,t_a,t_d,t_f,longueur,hauteur):
        self.t_ambiante = t_a# t en °C
        self.t_debut = t_d# t en °C
        self.t_fin = t_f# t en °C
        self.longueur = longueur# l en mm
        self.hauteur = hauteur# h en mm        
    def make_bar():
        """
        construction du tableau ou de la matrice à état initiale, à l'état initial
        nous avons la température ambiante et celle des extrémités, la température
        initial de la tranche est défini à 0 ou à la valeur mini des entrées...
        A défini selon des critères non sélectionnés            
 
        Returns
        -------
                   t_a  t_a t_a t_a... t_a   
            t_d    0    0   0   0  ... 0   t_f
            t_d    0    0   0   0  ... 0   t_f
                   t_a  t_a t_a t_a... t_a 
 
        """
 
    def calcul_t():
        """
        
 
        Returns
        -------
        None.
 
        """
    def show_bar():
        """
 
        Returns
        -------
        None.
 
        """
    def graph_t():
        """
        
 
        Returns
        -------
        None.
 
        """

Auriez vous des conseils sur comment commencer ou structurer une class ?

Merci

[Sve@r]

Bonjour

Auriez vous des conseils sur comment commencer ou structurer une class ?

"class" c'est le nom Python pour "objet". Essaye donc de penser à ton truc comme un objet. C'est quoi un objet dans la vie ? C'est un truc qui évolue dans le temps. Un frigo par exemple c'est un objet. Et dans le temps, on peut ouvrir sa porte, la fermer. On peut lui rajouter des aliments, ou en enlever. Etc etc etc. C'est donc un truc qui subit une intéraction avec l'extérieur et cette intéraction se traduit par des méthodes.

Par exemple ton objet à toi c'est une collection de valeurs ok. Mais la méthode make_bar(), a-t-elle vraiment une raison d'être ? Est-ce que si tu l'appelles à 2 moments différents de ton programme elle peut donner 2 résultats différents ? Sinon alors elle devient inutile (tu effectues son travail une seule fois dans le __init__()).

Donc voilà. Le seul conseil que je peux te donner, c'est de créer ton objet de façon minimaliste (juste un __init__()). Et ensuite, c'est en l'utilisant que tu te rendras compte de ce qui lui manque et que tu le rajouteras au fur et à mesure.

[Aelurus_]

Ba oui, mon objet bar n'a pas besoin d'une méthode pour le créer, sur le coup je l'ai trouvé logique car je souhaitais pouvoir afficher l'état de départ.
ok je vais suivre tes conseils.

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
def __init__(self,t_a,t_d,t_f,longueur,hauteur):
        """
        construction du tableau ou de la matrice à état initiale, à l'état initial
        nous avons la température ambiante et celle des extrémités, la température
        initial de la tranche est défini à 0 ou à la valeur mini des entrées...
        A défini selon des critères non sélectionnés            
 
        Returns
        -------
                   t_a  t_a t_a t_a... t_a   
            t_d    0    0   0   0  ... 0   t_f
            t_d    0    0   0   0  ... 0   t_f
                   t_a  t_a t_a t_a... t_a 
 
        """
        bar = list()
        for i in range(hauteur+2):
            if i == 0 or i == hauteur+1:
                bar.append(list(["None"]) + list([t_a]*longueur) + list(["None"]))
            else :
                bar.append(list([t_d]) + list([0]*longueur) + list([t_f])) 
        self.bar = bar

Si je suis ta logique je n'ais plus qu'a faire les méthodes dont j'ai besoins.

[Sve@r]

Code python :

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

1
2
3
4
if i == 0 or i == hauteur+1:
	bar.append(list(["None"]) + list([t_a]*longueur) + list(["None"]))
else:
	bar.append(list([t_d]) + list([0]*longueur) + list([t_f]))

Alors c'est vrai que j'ai dit que je prenais l'habitude de mettre list() tout le temps... sauf quand le truc placé entre parenthèses est déjà une liste !!!
Soit tu écris [None,] (j'avais aussi précisé que je mettais la virgule tout le temps), soit tu écris list((None,)) signifiant que tu transformes en liiste un truc qui ne l'est pas nativement, mais écrire list([None]) pour le coup là ça ne sert pas à grand chose

Code python :

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

1
2
3
4
if i == 0 or i == hauteur+1:
	bar.append(["None",] + [t_a,]*longueur + ["None",])
else:
	bar.append([t_d,] + [0,]*longueur + [t_f,])

Ensuite, d'un point de vue algo, boucler n+2 fois et tester donc n+2 fois si tu te trouves aux bornes produit donc n tests inutiles qui sont autant de charge inutile. Ce n'est pas parce qu'on fait du Python qu'il ne faut pas prendre soin de son processeur. Quel dommage, toi qui aime tant les listes en intension c'était ici une occasion rêvée de t'en servir avec efficience

Code python :

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

1
2
borne=["None",] + [t_a,]*longueur + ["None",]
self.bar=borne[:] + list(([t_d,] + [0,]*longueur + [t_f,]) for i in range(hauteur)) + borne[:]

Et le borne[:] c'est pour produire une copie de borne en mémoire. Si on écrit bêtement bar=borne + list(...) + borne, alors on n'ajoute que l'adresse de "borne" ce qui fait que bar[0] et bar[hauteur+1] pointent vers la même zone (souci quand on copie des tableaux). Remarque pour le coup là j'aurais pu effectivement mettre bar=list(borne) + list(...) + list(borne) qui aurait produit le même effet et là le cast list() se justifiait pleinement.

Si je suis ta logique je n'ais plus qu'a faire les méthodes dont j'ai besoins.

Exactement.

[Aelurus_]

Salut,

Alors c'est vrai que j'ai dit que je prenais l'habitude de mettre list() tout le temps... sauf quand le truc placé entre parenthèses est déjà une liste !!!
Soit tu écris [None,] (j'avais aussi précisé que je mettais la virgule tout le temps), soit tu écris list((None,)) signifiant que tu transformes en liiste un truc qui ne l'est pas nativement, mais écrire list([None]) pour le coup là ça ne sert pas à grand chose

Code python :

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

1
2
3
4
if i == 0 or i == hauteur+1:
	bar.append(["None",] + [t_a,]*longueur + ["None",])
else:
	bar.append([t_d,] + [0,]*longueur + [t_f,])

Oui trés juste, j'ai zappé la virgule et me suis embrouillé en regardant ce que celà faisait avec les dictionnaire....

Ensuite, d'un point de vue algo, boucler n+2 fois et tester donc n+2 fois si tu te trouves aux bornes produit donc n tests inutiles qui sont autant de charge inutile. Ce n'est pas parce qu'on fait du Python qu'il ne faut pas prendre soin de son processeur. Quel dommage, toi qui aime tant les listes en intension c'était ici une occasion rêvée de t'en servir avec efficience

Looool, oui c'est trés vrai, je me suis forcé à rester avec des listes de base, histoire de .

Code :

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

1
2
3
4
5
6
7
  bar = list()
        for i in range(hauteur+2):
            if i == 0 or i == hauteur+1:
                bar.append(list((t_d,)) + list([t_a]*longueur) + list((t_f,)))
            else :
                bar.append(list((t_d,)) + list([0]*longueur) + list((t_f,))) 
        self.bar = bar

Code python :

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

1
2
borne=["None",] + [t_a,]*longueur + ["None",]
self.bar=borne[:] + list(([t_d,] + [0,]*longueur + [t_f,]) for i in range(hauteur)) + borne[:]

Et le borne[:] c'est pour produire une copie de borne en mémoire. Si on écrit bêtement bar=borne + list(...) + borne, alors on n'ajoute que l'adresse de "borne" ce qui fait que bar[0] et bar[hauteur+1] pointent vers la même zone (souci quand on copie des tableaux). Remarque pour le coup là j'aurais pu effectivement mettre bar=list(borne) + list(...) + list(borne) qui aurait produit le même effet et là le cast list() se justifiait pleinement.

Bon cette partie-là je dois la regarder de plus près dans la console pour mieux appréhender la chose. Là je slice ^^pour le calcul et l'affichage

[13, 13] -- [13, 13]
__________________________
0 | [0, 0, 0, 0, 0, 0] ---- [0, 0, 0, 0, 0, 0] | 30
0 | [0, 0, 0, 0, 0, 0] ---- [0, 0, 0, 0, 0, 0] | 30
0 | [0, 0, 0, 0, 0, 0] ---- [0, 0, 0, 0, 0, 0] | 30
0 | [0, 0, 0, 0, 0, 0] ---- [0, 0, 0, 0, 0, 0] | 30
0 | [0, 0, 0, 0, 0, 0] ---- [0, 0, 0, 0, 0, 0] | 30
0 | [0, 0, 0, 0, 0, 0] ---- [0, 0, 0, 0, 0, 0] | 30
0 | [0, 0, 0, 0, 0, 0] ---- [0, 0, 0, 0, 0, 0] | 30
0 | [0, 0, 0, 0, 0, 0] ---- [0, 0, 0, 0, 0, 0] | 30
0 | [0, 0, 0, 0, 0, 0] ---- [0, 0, 0, 0, 0, 0] | 30
0 | [0, 0, 0, 0, 0, 0] ---- [0, 0, 0, 0, 0, 0] | 30
__________________________
[13, 13] -- [13, 13]

Bon attention au carnage ^^

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
    def calcul_t(self):
        """
        
 
        Returns
        -------
        None.
 
        """
        a = 0
        while a<50:
            for i in range(len(self.bar[:-1])):
                for n in range(len(self.bar[i][:])):
                    if i == 0 or n == 0 or n == self.longueur+1 :
                        None
                    else : 
                        self.bar[i][n] = round((self.bar[i][n-1]+self.bar[i][n+1]+self.bar[i-1][n]+self.bar[i+1][n])/4,1)
            a+=1
 
    def show_bar(self):
        """
 
        Returns
        -------
        None.
 
        """
        print("   ",self.bar[0][1:3],"  --  ",self.bar[0][-3:-1],"  ")
        print("  ","_"*26," ")
        bar=self.bar[1:-1]
        for i in range(len(bar)): 
            print(self.t_debut,"|",bar[i][1:7],"----",bar[i][-7:-1],"|",self.t_fin)
        print("  ","_"*26," ")
        print("   ",self.bar[0][1:3],"  --  ",self.bar[0][-3:-1],"  ")

Pour l'instant c'est juste fonctionnel et je crois que ça fait le taff demandé aussi ^^. C'est quand même super les objets, je trouve cela assez impressionnant. Je suis bien conscient que je dois être dans 1% de son potentiel . Mais rien que cette syntaxe est top :

Code :

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

1
2
3
4
5
c = Bar(13,0,30,30,10)
c.show_bar()
c.calcul_t()
c.show_bar()
c.graph_t()

Bon numpy te revoila ^^, surtout que je voudrais voir à essayer de traiter mes effets de bord avec la température ambiante ce qui risque de bien alourdir le bousin ^^.

Merci

[Aelurus_]

Salut,
mais oui biensur ^^.

Ensuite, d'un point de vue algo, boucler n+2 fois et tester donc n+2 fois si tu te trouves aux bornes produit donc n tests inutiles qui sont autant de charge inutile. Ce n'est pas parce qu'on fait du Python qu'il ne faut pas prendre soin de son processeur. Quel dommage, toi qui aime tant les listes en intension c'était ici une occasion rêvée de t'en servir avec efficience

Code python :

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

1
2
borne=["None",] + [t_a,]*longueur + ["None",]
self.bar=borne[:] + list(([t_d,] + [0,]*longueur + [t_f,]) for i in range(hauteur)) + borne[:]

Et le borne[:] c'est pour produire une copie de borne en mémoire. Si on écrit bêtement bar=borne + list(...) + borne, alors on n'ajoute que l'adresse de "borne" ce qui fait que bar[0] et bar[hauteur+1] pointent vers la même zone (souci quand on copie des tableaux). Remarque pour le coup là j'aurais pu effectivement mettre bar=list(borne) + list(...) + list(borne) qui aurait produit le même effet et là le cast list() se justifiait pleinement.

Par contre j'ai besoin de faire [borne,] comme je veux une liste par ligne.

[Sve@r]

Par contre j'ai besoin de faire [borne,] comme je veux une liste par ligne.

Exact... mais pas tout à fait. Tu as besoin de faire [borne[:],] et non [borne,] car sinon tu ne places que l'adresse de "borne" dans ta nouvelle liste.

Exemple1

Code python :

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

1
2
3
4
5
6
7
8
class toto:
	def __init__(self,t_a,t_d,t_f,longueur,hauteur):
		borne=["None",] + [t_a,]*longueur + ["None",]
		self.bar=[borne,] + list(([t_d,] + [0,]*longueur + [t_f,]) for i in range(hauteur)) + [borne,]
 
a=toto(1, 2, 3, 4, 2)
a.bar[0][0]="xxx"
print(a.bar)

Exemple2

Code python :

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

1
2
3
4
5
6
7
8
class toto:
	def __init__(self,t_a,t_d,t_f,longueur,hauteur):
		borne=["None",] + [t_a,]*longueur + ["None",]
		self.bar=[borne[:],] + list(([t_d,] + [0,]*longueur + [t_f,]) for i in range(hauteur)) + [borne[:],]
 
a=toto(1, 2, 3, 4, 2)
a.bar[0][0]="xxx"
print(a.bar)

C'est un des soucis quand on copie des tableaux. Python travaille à l'économie (ce qui, dans 80% des cas, est suffisant). Mais si tu veux que t2 contienne une duplication de t1, il te faut la demander explicitement.
Remarque peut-être que dans ton cas l'exemple 1 est suffisant mais c'était pour te montrer le danger.

Code python :

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

1
2
3
4
a = 0
while a<50:
	...
	a+=1

Là franchement...

Code python :

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

1
2
for a in range(50):
	...

Code python :

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

1
2
3
4
if i == 0 or n == 0 or n == self.longueur+1 :
	None
else : 
	self.bar[i][n] = round((self.bar[i][n-1]+self.bar[i][n+1]+self.bar[i-1][n]+self.bar[i+1][n])/4,1)

Au-moins t'as cherché et ça c'est bien. En fait, l'instruction neutre c'est pas None mais pass.
Maintenant, d'un point de vue logique, écrire "si ceci alors rien sinon autre" peut s'écrire plus simplement "si pas ceci alors autre" ce qui évite un "then" ne faisant rien et un "else" facultatif devenu obligatoire. Faut juste se rappeler les lois de De Morgan qui sont

• not (a ou b) = not a et not b
• not (a et b)=not a ou not b

Code python :

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

1
2
if i != 0 and n != 0 and n != self.longueur+1 :			# if i != 0 and n not in (0, self.longueur+1)
	self.bar[i][n] = round((self.bar[i][n-1]+self.bar[i][n+1]+self.bar[i-1][n]+self.bar[i+1][n])/4,1)

[MPython Alaplancha]

Auriez vous des conseils sur comment commencer ou structurer une class ?

Merci

Bonjour,
En ce qui concerne le passage d'argument à ton __init__, tu peux faire:

Code :

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

1
2
def __init__(self, *args):
        t_a, t_d, t_f, longueur, hauteur = args

[Aelurus_]

Merci, hominidé je trouve la démarche surtout si tu dois gérer une tripoté d'arguments