Salut à tous !

J'essaie de programmer une calculatrice sur python pour m'initier à tkinter et je bloque depuis un bon moment... Je ne sais pas où ! Ci-dessous le code avec une ou plusieures erreurs que je ne vois pas... Je pense quand même que ça bloque au niveau des boutons avec "command", j'ai peut être pas très bien compris comment ça marchait
Je ne suis qu'à l'étape où l'utilisateur entre des chiffres qui serviront plus tard au calcul et ces derniers s'affichent sur l'écran au fur et à mesure qu'il écrit
Je tiens juste à dire que j'ai mis une classe interface, une fonction __init__ et beaucoup de self parce que j'ai vu ça dans un autre programme qui marchait même si je n'ai pas très bien compris leur utilité...

from tkinter import *

vc=0

class Interface(Frame):

def __init__(self, fenetre, **kwargs):

Frame.__init__(self, fenetre, width=768, height=576,**kwargs)
self.pack(fill=BOTH)

self.champ_label = Label(fenetre, text = "CALCULATRICE", fg="red")
self.champ_label.pack()

self.champ_label = Label(fenetre, text="Entrez ci-dessous le calcul que vous souhaitez effectuer")
self.champ_label.pack()

self.lignedecommande = Label(fenetre, fg= "blue",text=vc)
self.lignedecommande.pack(fill = BOTH)

self.bouton_un = Button(fenetre, text="1", command = modifvariable(1))
self.bouton_un.pack(side = "top", fill = X)

self.bouton_deux = Button(fenetre, text="2", command = self.modifvariable(2))
self.bouton_deux.pack(side = "top", fill = X)

self.bouton_trois = Button(fenetre, text="3", command = self.modifvariable(3))
self.bouton_trois.pack(side = "top", fill = X)

self.bouton_quatre = Button(fenetre, text="4", command = self.modifvariable(4))
self.bouton_quatre.pack(side = "top", fill = X)

self.bouton_cinq = Button(fenetre, text="5", command = self.modifvariable(5))
self.bouton_cinq.pack(side = "top", fill = X)

self.bouton_six = Button(fenetre, text="6", command = self.modifvariable(6))
self.bouton_six.pack(side = "top", fill = X)

self.bouton_sept = Button(fenetre, text="7", command = self.modifvariable(7))
self.bouton_sept.pack(side = "top", fill = X)

self.bouton_huit = Button(fenetre, text="8", command = self.modifvariable(8))
self.bouton_huit.pack(side = "top", fill = X)

self.bouton_neuf = Button(fenetre, text="9", command = self.modifvariable(9))
self.bouton_neuf.pack(side = "top", fill = X)

self.bouton_plus = Button(fenetre, text="+")
self.bouton_plus.pack(side = "top", fill = X)

self.bouton_moins = Button(fenetre, text="-")
self.bouton_moins.pack(side = "top", fill = X)

self.bouton_diviser = Button(fenetre, text="÷")
self.bouton_diviser.pack(side = "top", fill = X)

self.bouton_multiplier = Button(fenetre, text="x")
self.bouton_multiplier.pack(side = "top", fill = X)

self.bouton_egal = Button(fenetre, text="=")
self.bouton_egal.pack(side = "top", fill = X)

def modifvariable (valeur):
global vc
vc += valeur

fenetre = Tk()
interface = Interface(fenetre)
interface.mainloop()
interface.destroy()

Balise please...

<code></code>

#Mon programme
//...

Je tiens juste à dire que j'ai mis une classe interface, une fonction __init__ et beaucoup de self parce que j'ai vu ça dans un autre programme qui marchait même si je n'ai pas très bien compris leur utilité...

Entre nous, ne fais jamais ça en programmation, surtout si tu peux l'éviter.
La programmation nécessite de la rigueur, la moindre erreur peut bloquer le programme, ou change complètement son fonctionnement car l'ordinateur ne corrigera pas pour toi ton code.

Si tu ne comprends pas quelque chose, expérimente le jusqu'à le comprendre, mais vaut mieux faire quelque chose de simple mais plus long et moins optimisé que tu comprends, qu'utiliser des choses que tu ne comprends pas. Ce sera plus sûr si tu agrandis ton programme, et au pire tu pourras toujours revenir de temps à autres pour améliorer et alléger certaines partie de ton code.

Je connais pas le python, mais ça ressemble à l'équivalent this de javascript, si c'est le cas ça se réfère à l'objet/classe qui contient l'élément
.machin
Donc si par exemple tu as une classe en javascript :
class_de_base
this.x = valeur;

et que tu fais des
class_A = new class_de_base
this.x =5

class_B = new class_de_base
this.x = 10;

si t'as une fonction qui fait
this.x += 5;

si tu fais passer ta classe A son x vaudra 10, si tu fais passer ta classe B, son x à elle vaudra 15.
En gros ça t'évites d'écrire
class_A.x
et/ou
class_B.x (et toutes les autres classes créées par la modèle class_de_base), ça t'automatise l'action. Ça éviter aussi de jouer sur des variables globales, et rend ton code plus flexible. Chaque nouvelle itération de cette même classe pouvant utiliser directement les mêmes fonctions.