Intégration de code pour fonctionner en interface graphique

Version imprimable

Bonjour à vous toutes et tous,
Je tiens tout d'abord à remercier l'ensemble de la communauté du site sans qui je ne serais jamais arrivé à ce stade.
Quinquagénaire que je suis cela n'ai pas toujours évident de bien comprendre la programmation.
Je voudrais mettre en relation mon programme dans une interface graphique, ce serait plus sympa.

Programme :

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
from math import *
Nombre_Longueurs = input("Entrez le nombre de longueurs : ")
Liste_Longueurs = []
LongueurRail = 0
LongueurPlaco  = 0
LongueurDoublePlaco = 0
LDV_Cloison = 0
NombreTTPC = 0
NombreTRPF = 0
NombreDeCheville = 0
LDV_Plafond = 0
 
i = 0
j = 0
Montants = 0
 
while (i < int(Nombre_Longueurs)) :
    Longueur = input('Entrez une longueur en cm \n')
    Liste_Longueurs.append(int(Longueur))
    LongueurRail = LongueurRail + int(Longueur)
    LongueurPlaco = LongueurPlaco + int(Longueur)
    LongueurDoublePlaco = LongueurDoublePlaco + int(Longueur)
    NombreTTPC  = NombreTTPC  + int(Longueur)
    NombreTRPF = NombreTRPF + int(Longueur)
    NombreDeCheville = NombreDeCheville + int(Longueur)
    LDV_Plafond = LDV_Plafond + int(Longueur)
 
    i = i + 1
 
while (j < len(Liste_Longueurs)) :
    i = 0
    Liste = []
    Longueur = Liste_Longueurs[j]
    while (Longueur > 120) :
        Liste.append(120)
        Longueur = Longueur - 120
    if (Longueur > 0) :
        Liste.append(Longueur)
    while(i < len(Liste)) :
        if (Liste[i] > 0) and (Liste[i] <= 60) :
            Montants = Montants + 2 
        else :	 
            Montants = Montants + 4
        i = i + 1
    j = j + 1
 
# Quantité de montant à l'unité
texte = "Nombre de Montant est de : \n{} unités."
print(texte.format(Montants))
 
# Quantité de rail à l'unité
LongueurRail = LongueurRail * 2 / 300
Rail = ceil(LongueurRail)
texte = "Nombre de Rail est de : \n{} unités."
print(texte.format(Rail))
 
# Quantité de placo pour 1/2 cloison
LongueurPlaco = LongueurPlaco / 120 
Placo = ceil(LongueurPlaco)
texte = "Nombre de Placo 1/2 cloison est de : \n{} plaques."
print(texte.format(Placo))
 
# Quantité de placo pour cloison
LongueurDoublePlaco = LongueurDoublePlaco / 120 * 2 
Placo = ceil(LongueurDoublePlaco)
texte = "Nombre de Placo cloison est de : \n{} plaques."
print(texte.format(Placo))
 
# Quantité de laine de verre au Ml
texte = "Nombre de laine de verre (Cloison) est de : \n{} Ml."
print(texte.format(((Montants) / 2 * 2.5)))
 
# Quantité de laine de verre pour plafond au M²
LDV_Plafond = LDV_Plafond / 120 * 3
LDV_Plafond = ceil(LDV_Plafond)
texte = "Nombre de laine de verre (Plafond) au M² est de : \n{} M²."
print(texte.format(LDV_Plafond))
 
# Quantité de TTPC pour cloison
NombreTTPC  = NombreTTPC  / 120 * 90
NombreTTPC = ceil(NombreTTPC)
texte = "Nombre de TTPC est de : \n{} Unités."
print(texte.format(NombreTTPC))
 
# Quantité de TRPF pour cloison
NombreTRPF  = NombreTRPF  / 120 * 6
NombreTRPF = ceil(NombreTRPF)
texte = "Nombre de TRPF est : \n{} Unités."
print(texte.format(NombreTRPF))
 
# Quantité de Cheville à frapper pour cloison
NombreDeCheville  = NombreDeCheville  / 120 * 4
NombreDeCheville = ceil(NombreDeCheville)
texte = "Nombre de Cheville à frapper est de : \n{} Unités."
print(texte.format(NombreDeCheville))

Mon interface :

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
from tkinter import *
from math import *
 
Longueur = Tk()
Longueur.geometry("550x550+300+300")
Longueur.title('Projet')
 
Frame0 = Frame(Longueur)
Frame0.pack()
Frame1 = Frame(Longueur)
Frame1['bg']='bisque'
Frame1.pack(side=LEFT)
 
Frame2 = Frame(Frame1, borderwidth=2,relief=GROOVE)
Frame2.pack(side=LEFT,padx=50,pady=50)
 
# création de widgets 'Label' et 'Entry' :
 
txt1 = Label(Frame2, text ='Nomre de Montant:')
txt2 = Label(Frame2, text ='Nombre de Rail :')
txt3 = Label(Frame2, text ='Placo 1/2 cloison :')
txt4 = Label(Frame2, text ='Placo cloison :')
txt5 = Label(Frame2, text ='Nombre de laine de verre (cloison) :')
txt6 = Label(Frame2, text ='Nombre de laine de verre (plafond) :')
txt7 = Label(Frame2, text ='Nombre de TTPC :')
txt8 = Label(Frame2, text ='Nombre de TRPF :')
txt9 = Label(Frame2, text ='Nombre de Cheville à frapper :')
entr1 = Entry(Frame2)
entr2 = Entry(Frame2)
entr3 = Entry(Frame2)
entr4 = Entry(Frame2)
entr5 = Entry(Frame2)
entr6 = Entry(Frame2)
entr7 = Entry(Frame2)
entr8 = Entry(Frame2)
entr9 = Entry(Frame2)
 
txt = Label(Frame0, text ='Entrer les longueurs :')
entre0 = Entry(Frame0)
button0 = Button(Frame0, text = 'Valider')
txt.pack(side = LEFT, padx = 5, pady = 10)
entre0.pack(side = LEFT, padx = 5, pady = 10)
button0.pack(side = LEFT, padx = 5, pady = 10)
 
 
# Mise en page à l'aide de la méthode 'grid' :
 
txt1.grid(row =1, sticky =E)
txt2.grid(row =2, sticky =E)
txt3.grid(row =3, sticky =E)
txt4.grid(row =4, sticky =E)
txt5.grid(row =5, sticky =E)
txt6.grid(row =6, sticky =E)
txt7.grid(row =7, sticky =E)
txt8.grid(row =8, sticky =E)
txt9.grid(row =9, sticky =E)
entr1.grid(row =1, column =2)
entr2.grid(row =2, column =2)
entr3.grid(row =3, column =2)
entr4.grid(row =4, column =2)
entr5.grid(row =5, column =2)
entr6.grid(row =6, column =2)
entr7.grid(row =7, column =2)
entr8.grid(row =8, column =2)
entr9.grid(row =9, column =2)

Pourriez-vous m'apporter un peu de vos lumières.
Un grand merci par avance

26/03/2019, 10h01
fred1599

Bonjour,

En l'état le code n'est pas testable, il manque la méthode mainloop.

Ensuite quel est votre problème, que souhaitez vous qu'on vous explique ?

Si j'avais à donner un conseil, le 1er serait de penser "boucles", vous diviseriez pas 2 ou 3 le nombre de lignes.
C'est un mode de pensée différent du vôtre, mais essentiel en programmation.

Citation:

Envoyé par fred1599

Bonjour,

En l'état le code n'est pas testable, il manque la méthode mainloop.

Ensuite quel est votre problème, que souhaitez vous qu'on vous explique ?

Si j'avais à donner un conseil, le 1er serait de penser "boucles", vous diviseriez pas 2 ou 3 le nombre de lignes.
C'est un mode de pensée différent du vôtre, mais essentiel en programmation.

Bonjour Fred1599,
Merci à toi de m'aider.
Je reconnais vos citations et ce n'est pas la première fois que j'ai eu conseil de ta part indirectement, en regardant vos explications.
Effectivement, j'ai oublié de coller mainloop, mais il est dans mon code.
J'ai essayé de le diviser mais j'ai des difficultés.
Mon problème, c'est que dans l'état il fonctionne très bien en invite de commande.
Je voudrais faire apparaître le résultat dans les différentes parties de mon graphique.
Dans mon programme, il faut que je rentre toutes les longueurs séparément car avec une seule longueur totale cela ne me donnait pas le même résultat en quantité.
Il faudrait que je puisse l'intégrer comme dans le fonctionnement sous invite de commande.
Merci à toi
Voici une autre avancée que je travail :

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
class entree_nombre_de_longueur():
	def donnee():
		LongueurRail = 0
		LongueurPlaco  = 0
		LongueurDoublePlaco = 0
		LDV_Cloison = 0
		NombreTTPC = 0
		NombreTRPF = 0
		NombreDeCheville = 0
		LDV_Plafond = 0
	def __init__():
		Nombre_Longueurs = input("Entrez le nombre de longueurs : ")
		Liste_Longueurs = []
		i = 0
		j = 0
		Montants = 0
	def function2():
		while (i < int(Nombre_Longueurs)) :
		    Longueur = input('Entrez une longueur en cm \n')
		    Liste_Longueurs.append(int(Longueur))
 
 
		    i = i + 1
 
		while (j < len(Liste_Longueurs)) :
		    i = 0
		    Liste = []
		    Longueur = Liste_Longueurs[j]
		    while (Longueur > 120) :
		        Liste.append(120)
		        Longueur = Longueur - 120
		    if (Longueur > 0) :
		        Liste.append(Longueur)
		    while(i < len(Liste)) :
		        if (Liste[i] > 0) and (Liste[i] <= 60) :
		            Montants = Montants + 2 
		        else :	 
		            Montants = Montants + 4
		        i = i + 1
		    j = j + 1
 
if __name__ == "__main__":
 
	# Quantité de montant à l'unité
	texte = "Nombre de Montant est de : \n{} unités."
	print(texte.format(Montants))
 
	# Quantité de rail à l'unité
	LongueurRail = LongueurRail * 2 / 300
	Rail = ceil(LongueurRail)
	texte = "Nombre de Rail est de : \n{} unités."
	print(texte.format(Rail))
 
	# Quantité de placo pour 1/2 cloison
	LongueurPlaco = LongueurPlaco / 120 
	Placo = ceil(LongueurPlaco)
	texte = "Nombre de Placo 1/2 cloison est de : \n{} plaques."
	print(texte.format(Placo))
 
	# Quantité de placo pour cloison
	LongueurDoublePlaco = LongueurDoublePlaco / 120 * 2 
	Placo = ceil(LongueurDoublePlaco)
	texte = "Nombre de Placo cloison est de : \n{} plaques."
	print(texte.format(Placo))
 
	# Quantité de laine de verre au Ml
	texte = "Nombre de laine de verre (Cloison) est de : \n{} Ml."
	print(texte.format(((Montants) / 2 * 2.5)))
 
	# Quantité de laine de verre pour plafond au M²
	LDV_Plafond = LDV_Plafond / 120 * 3
	LDV_Plafond = ceil(LDV_Plafond)
	texte = "Nombre de laine de verre (Plafond) au M² est de : \n{} M²."
	print(texte.format(LDV_Plafond))
 
	# Quantité de TTPC pour cloison
	NombreTTPC  = NombreTTPC  / 120 * 90
	NombreTTPC = ceil(NombreTTPC)
	texte = "Nombre de TTPC est de : \n{} Unités."
	print(texte.format(NombreTTPC))
 
	# Quantité de TRPF pour cloison
	NombreTRPF  = NombreTRPF  / 120 * 6
	NombreTRPF = ceil(NombreTRPF)
	texte = "Nombre de TRPF est : \n{} Unités."
	print(texte.format(NombreTRPF))
 
	# Quantité de Cheville à frapper pour cloison
	NombreDeCheville  = NombreDeCheville  / 120 * 4
	NombreDeCheville = ceil(NombreDeCheville)
	texte = "Nombre de Cheville à frapper est de : \n{} Unités."
	print(texte.format(NombreDeCheville))

26/03/2019, 11h11
fred1599
Quand vous cliquez sur "valider", vous devez exécuter un callback, c'est à dire le nom donné à une fonction sans l'exécuter (donc sans parenthèses).

La fonction qui sera exécuter lors de l'appui sur "valider", devra contenir la récupération des valeurs entrées dans l'interface, ainsi que l'exécution de votre code "Programme".
Cependant il n'est plus question d'utiliser input, il faut donc créer une ou des fonctions qui permettrait les calculs.

Vos calculs sont bizarres, mais je ne juge pas de leur justesse, c'est plutôt la syntaxe... Cependant je trouve juste marrant d'ajouter une longueur de cheville avec une longueur de Placo. :ptdr:

Une fonction ressemblerait à
Code:

1 2 3 4 def calculate(length, *args): for detail in args: length += detail return length
Une fonction devant retourner quelque chose, pas afficher.

Votre callback ressemblerait à
Code:

1 2 3 4 def callback(): # Récupération des mes entrées utilisateur value = calculate(..., ...) label['text'] = value # modification sur l'interface du label représentant le résultat
et le callback serait appelé,

Code:

b = Button(root, text='...', command=callback)

Je peux guère expliquer plus, sinon on entre dans l'écriture d'un tutoriel, et il y en a bien assez sur le net ;)

Salut,

Citation:

Envoyé par zaza11

Mon problème, c'est que dans l'état il fonctionne très bien en invite de commande.
Je voudrais faire apparaître le résultat dans les différentes parties de mon graphique.

La mécanique que vous devez mettre en place est guère différente de:

saisir un nombre,
appeler une fonction de ce nombre qui retourne un résultat,
afficher le résultat.

à la console, c'est "facile":
Code:

1 2 3 4 5 def f(a): return 10 * a a = float(input()) r = f(a) print (r)
Avec une interface graphique, çà se corse:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 import tkinter as tk def f(a): return 10 * a root = tk.Tk() e = tk.Entry(root) e.pack() r = tk.Label(root) r.pack() def callback(): a = float(e.get()) r['text'] = str(f(a)) tk.Button(root, text='valider', command=callback).pack() tk.mainloop()
On a peut être gardé la fonction, mais toute la logique est chamboulée.
C'est ce qui rend la programmation d'une interface graphique "compliquée" et sans ouvrir un tuto. pour apprendre ce que vous impose ce style de programmation, c'est pas gagné.

- W

26/03/2019, 14h20
zaza11

Merci encore à vous
Je vais regarder tout cela et essayer d'y arriver

Citation:
Envoyé par wiztricks
Salut,

La mécanique que vous devez mettre en place est guère différente de:

saisir un nombre,
appeler une fonction de ce nombre qui retourne un résultat,
afficher le résultat.

à la console, c'est "facile":
Code:

1 2 3 4 5 def f(a): return 10 * a a = float(input()) r = f(a) print (r)
Avec une interface graphique, çà se corse:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 import tkinter as tk def f(a): return 10 * a root = tk.Tk() e = tk.Entry(root) e.pack() r = tk.Label(root) r.pack() def callback(): a = float(e.get()) r['text'] = str(f(a)) tk.Button(root, text='valider', command=callback).pack() tk.mainloop()
On a peut être gardé la fonction, mais toute la logique est chamboulée.
C'est ce qui rend la programmation d'une interface graphique "compliquée" et sans ouvrir un tuto. pour apprendre ce que vous impose ce style de programmation, c'est pas gagné.

- W
c'est vrai que ce n'est pas facile en graphique, mais le résultat est sympa. Je viens de me mettre à la programmation et je trouve cela magnifique, cela dépasse notre propre personnalité et j'adore les défis. Devrais-je ouvrir un tuto ? Merci à vous deux

26/03/2019, 16h54
wiztricks

Citation:

Envoyé par zaza11

Devrais-je ouvrir un tuto ?

Le soucis est que si vous ne savez pas ce qu'est la programmation d'une interface graphique, vous n'arriverez pas à "penser" comment construire/programmer votre application.
L'avantage des tutos est qu'ils vous donnent des bases "minimales" pour commencer.
Sûr que si vous voulez faire des choses un peu plus compliquées, çà ne suffira pas: il faudra ouvrir la documentation, voir comment mettre en œuvre différent widgets pour réaliser l'interface,... et éventuellement demander de l'aide ici.

- W
26/03/2019, 22h24
zaza11

Citation:

Envoyé par wiztricks

Le soucis est que si vous ne savez pas ce qu'est la programmation d'une interface graphique, vous n'arriverez pas à "penser" comment construire/programmer votre application.
L'avantage des tutos est qu'ils vous donnent des bases "minimales" pour commencer.
Sûr que si vous voulez faire des choses un peu plus compliquées, çà ne suffira pas: il faudra ouvrir la documentation, voir comment mettre en œuvre différent widgets pour réaliser l'interface,... et éventuellement demander de l'aide ici.

- W

Je vais travailler le sujet.
je pense que je devrais retravailler mon programme afin de bien le structurer comme il m'a été recommandé par fred1599.
Des explications sur les tutos ne me sont pas toujours compréhensibles, mais je persistes.
Je n'hésiterais pas à revenir vers vous et ce serait avec grand plaisir d'avoir un peu de votre aide.
J'y passe du temps mais c'est le prix à payer pour parvenir à de bon résultat.
Merci encore
27/03/2019, 08h57
wiztricks

Salut,

Citation:

Envoyé par zaza11

Des explications sur les tutos ne me sont pas toujours compréhensibles, mais je persistes.

C'est normal: un tuto. n'est pas un roman vous devez en faire une lecture "active" i.e. lire, faire des exos., relire, ...
Une relecture après avoir fait quelques exercices vous fera comprendre autre chose qu'à la première lecture.
C'est toute la subtilité de la transformations d'informations (le tuto.) en connaissances (ce que vous apprenez) et qui rend inutile de sauter d'un tuto. à l'autre : il vaut mieux prendre le temps de se familiariser avec un (bon) tuto. histoire de pouvoir revenir là où çà parle de... que butiner de tuto. en tuto.

- W