Tkinter, l'exécution des fonctions au fil du temps

La programmation événementielle nécessite une mentalité différente de code de procédure. Votre demande est en cours d'exécution dans une boucle infinie, tirant des événements hors de la file d'attente et de traitement. Pour faire de l'animation, tout ce que vous devez faire est de placer les éléments sur cette file d'attente à un moment approprié.

Widgets Tkinter ont une méthode nommée après qui permet de programmer les fonctions à exécuter après une certaine période de temps. La première étape est d'écrire une fonction qui ne fait qu'une "image" de votre animation. Dans votre cas, vous êtes à la définition de l'animation de la commutation entre les deux couleurs. Une fonction qui vérifie la couleur actuelle, puis passe à l'autre couleur est tout ce dont vous avez besoin:

def blink(rect, canvas):
    current_color = canvas.itemcget(rect, "fill")
    new_color = "red" if current_color == "white" else "white"
    canvas.itemconfigure(rect, fill=new_color)

Maintenant, nous avons juste besoin d'avoir cette fonction exécuter trois fois à l'un des intervalles d'une seconde:

root.after(1000, blink, rect, canv)
root.after(2000, blink, rect, canv)
root.after(3000, blink, rect, canv)

Lorsque vous démarrez votre boucle principale, après une seconde, la couleur va changer, après une seconde, il va changer à nouveau, et après une troisième seconde, il va changer à nouveau.

Qui fonctionne pour votre besoin spécifique, mais ce n'est pas une très bonne solution générale. Plus générale de la solution est d'appeler blink une fois, puis ont blink appel lui-même à nouveau après une certaine période de temps. blink doit alors être responsable de savoir quand s'arrêter de clignoter. Vous pouvez définir un indicateur ou d'un comptoir, de la sorte, pour garder une trace de combien de fois vous ai cligné des yeux. Par exemple:

def blink(rect, canvas):
    ...
    # call this function again in a second to
    # blink forever. If you don't want to blink
    # forever, use some sort of flag or computation
    # to decide whether to call blink again
    canvas.after(1000, blink, rect, canvas)

Comme un dernier petit conseil, je vous recommande de définir votre programme en tant que classe, puis de créer une instance de cette classe. Ce qu'il fait en sorte que vous n'avez pas besoin des fonctions globales, et vous n'avez pas besoin de passer autant d'arguments. Il n'a pas vraiment d'importance pour un 20 ligne de programme, mais il commence à compter lorsque vous voulez écrire quelque chose de substantiel.

Par exemple:

from tkinter import *

class MyApp(Tk):
    def __init__(self):
        Tk.__init__(self)
        fr = Frame(self)
        fr.pack()
        self.canvas  = Canvas(fr, height = 100, width = 100)
        self.canvas.pack()
        self.rect = self.canvas.create_rectangle(25, 25, 75, 75, fill = "white")
        self.do_blink = False
        start_button = Button(self, text="start blinking", 
                              command=self.start_blinking)
        stop_button = Button(self, text="stop blinking", 
                              command=self.stop_blinking)
        start_button.pack()
        stop_button.pack()

    def start_blinking(self):
        self.do_blink = True
        self.blink()

    def stop_blinking(self):
        self.do_blink = False

    def blink(self):
        if self.do_blink:
            current_color = self.canvas.itemcget(self.rect, "fill")
            new_color = "red" if current_color == "white" else "white"
            self.canvas.itemconfigure(self.rect, fill=new_color)
            self.after(1000, self.blink)


if __name__ == "__main__":
    root = MyApp()
    root.mainloop()

OriginalL'auteur Bryan Oakley