Lorsque j'utilise la mise à jour() avec tkinter, mon Label écrit une autre ligne au lieu de réécrire le même texte

Lorsque j'appelle la méthode update() en utilisant tkinter, au lieu de réécrire l'étiquette, il écrit simplement l'étiquette en vertu de l'appel précédent. Je voudrais que cette réécrire sur la ligne précédente.

Par Exemple:

root=Tk()
while True:
    w=Label(root, text = (price, time))
    w.pack()
    root.update()
Pourriez-vous fournir un exemple de code qui illustre le problème s'il vous plaît?
C'est tout ce que vous devez observer le problème. mise à jour écrit en dessous de la dernière ligne, au lieu de plus de.

OriginalL'auteur wDroter | 2011-09-27

  1. 8

    Votre problème est simple: lorsque vous faites while True, vous créez une boucle infinie. Le code dans la boucle sera exécutée jusqu'à ce que vous forcer le programme à la sortie. Dans cette boucle vous créer une étiquette. Ainsi, vous pourrez créer un nombre infini d'étiquettes.

    Si vous voulez mettre une étiquette sur une base régulière, profiter de la déjà en cours d'exécution boucle infinie - la boucle d'événements. Vous pouvez utiliser after pour programmer une fonction qui doit être appelée dans l'avenir. Cette fonction peut reprogrammer lui-même, garantissant qu'il va s'exécuter jusqu'à ce que le programme se ferme.

    Voici un exemple simple:

    import Tkinter as tk
import time

class SampleApp(tk.Tk):
    def __init__(self, *args, **kwargs):
        tk.Tk.__init__(self, *args, **kwargs)
        self.clock = tk.Label(self, text="")
        self.clock.pack()

        # start the clock "ticking"
        self.update_clock()

    def update_clock(self):
        now = time.strftime("%H:%M:%S" , time.gmtime())
        self.clock.configure(text=now)
        # call this function again in one second
        self.after(1000, self.update_clock)

if __name__== "__main__":
    app = SampleApp()
    app.mainloop()

    OriginalL'auteur Bryan Oakley

  2. 2

    Pas.

    Je soupçonne, sans l'avoir vu, qu'il existe au moins un couple de confusions dans le code wDroter a écrit. En général, il n'est PAS nécessaire dans bien structuré Tkinter code pour utiliser une mise à jour (). Voici un petit exemple qui illustre les mises à jour du texte d'une Étiquette:

    import Tkinter
import time

def update_the_label():
    updated_text = time.strftime("The GM time now is %H:%M:%S.", time.gmtime())
    w.configure(text = updated_text)

root = Tkinter.Tk()
w = Tkinter.Label(root, text = "Hello, world!")
b = Tkinter.Button(root, text = "Update the label", command = update_the_label)
w.pack()
b.pack()

root.mainloop()

    Exécuter cette. Appuyez sur le bouton. Chaque fois que vous le faites (aussi longtemps que votre pousse diffèrent par au moins une seconde), vous verrez le texte de mise à jour.

    Il est vrai que bien Tkinter code ne sera probablement pas besoin d'appeler update, mais cela ne répond pas à la question. Il est tout à fait correct, bien que peut-être dangereux, pour appeler update dans Tkinter. Le problème avec le code donné un nouveau Label a été créé et emballé dans l'interface de chaque passage dans la boucle. Il existe au moins trois solutions à ce problème: (1) détruire la Label et en créer un nouveau à sa place, (2) modifier le texte dans la Label à quelque valeur que ce soit, il devrait avoir, et (3) lier un StringVar à la Label objet et modifier sa valeur à la place.
    Nous sommes en accord, Noctis Skytower. Ne wDroter fournir un code? Je ne savais pas que l' ("... compte tenu de code"--où? Il ne l'est pas pour moi), et la vôtre seulement après que j'ai Répondu. Je vous salue pour la peine de construire vos deux exemples.

    OriginalL'auteur Cameron Laird

  3. 1

    La BadRoot classe doit démontrer le problème que vous rencontrez. Vous pouvez commenter l'appel à la classe afin de vérifier avec un travail terminé, exemple. Si vous exécutez le code, comme l'a écrit, il mettra à jour l'étiquette dans le GoodRoot classe. La première ligne est commentée montre une syntaxe alternative pour changer le texte de votre étiquette.

    from tkinter import Tk, Label
from time import sleep
from random import random

class BadRoot(Tk):

    def __init__(self, price, time):
        super().__init__()
        self.labels = []
        while True:
            self.labels.append(Label(self, text=(price, time)))
            self.labels[-1].pack()
            self.update()
            sleep(1)

class GoodRoot(Tk):

    def __init__(self, callback):
        super().__init__()
        self.label = Label(self, text=str(callback()))
        self.label.pack()
        while True:
##            self.label['text'] = str(callback())
            self.label.configure(text=str(callback()))
            self.update()
            sleep(1)

if __name__ == '__main__':
##    BadRoot('$1.38', '2:37 PM')
    GoodRoot(random)

    Le problème avec votre code d'origine est qu'une nouvelle étiquette est créée et emballé dans l'interface de chaque passage dans la boucle. Ce que vous voulez faire est de modifier le texte affiché par l'étiquette au lieu de remplacer l'étiquette avec un nouveau. Il y a d'autres manières de le faire, mais cette méthode devrait fonctionner pour vous.

    -1, parce que un programme GUI ne doit jamais appeler le sommeil.
    Saviez-vous que le code d'origine dans la question de mieux? Il n'y a pas de pause pour permettre à quelqu'un d'observer et contempler ce qui se passait. J'aurais pu aussi facilement utilisé un after appel de méthode dans tkinter au lieu de la sleep fonction.
    Non, le code d'origine n'est pas mieux, si je comprends bien ce que vous demandez. Peu importe, au moment de donner des réponses aux personnes qui commencent à apprendre la programmation GUI vous ne devriez pas donner des exemples qui font des erreurs fondamentales. Au moins, pas sans aborder les effets secondaires et inconvénients dans le cadre de la réponse.

    OriginalL'auteur Noctis Skytower