Periodische Ausführungsverarbeitung bei Verwendung von tkinter [Python3]

Überblick

Die folgenden zwei Methoden werden für die periodische Ausführungsverarbeitung in tkinter gezeigt.

• Bei Verwendung des Einfädelmoduls
• Bei Verwendung des Zeitplanmoduls

Für eine einfache Verarbeitung ist es nicht erforderlich, das Threading-Modul oder das Zeitplanmodul zu verwenden, aber für eine schwere Verarbeitung wird der Betrieb von tk selbst (Drücken einer Taste / Bewegen des Bildschirms usw.) schwer. Selbst wenn es problematisch ist, kann es daher besser sein, es durch das obige Verfahren zu implementieren.

Bei Verwendung des Gewindemoduls

Unten ist der Beispielcode. Es ist ein Programm, das den Wert von "self.label" um 1 erhöht. Wenn Sie dies tun möchten, können Sie es regelmäßig in Millisekunden-Einheiten ausführen. Da es sich um Python handelt, ist die Zeitgenauigkeit nicht so gut, aber wenn Sie sich nicht so viele Sorgen um die Zeitgenauigkeit machen müssen, reicht dies aus.

import tkinter as tk
import threading

class GUI(tk.Frame):
    def __init__(self,master = None):
        super().__init__(master)
        self.master = master
        master.geometry("300x300")
        master.title("Test")
        
        self.count = 0 #Puffer der im Etikett definierten Werte
        
        self.test = tk.Frame(self.master)#Es ist nicht notwendig, aber ich habe einen anderen Rahmen erstellt, um den Bildschirm zu verwalten.
        self.test.pack()
        self.label = tk.Label(self.test)
        self.label.pack()
        self.label["text"] = str(self.count) #Etikettenwert initialisieren
        
        self.timeEvent()#Timer-Aktivierung
        
    #Funktion zum Starten des Timers
    def timeEvent(self):
        th = threading.Thread(target=self.update)#Thread-Instanziierung
        th.start()#Fadenstart
        self.after(1000, self.timeEvent)#Rufen Sie nun die Funktion rekursiv auf
        
    #Thread-Verarbeitungseinheit
    def update(self):
        self.count += 1
        print(self.count) #Debug-Nachricht
        self.label["text"] = str(self.count) #Etikettenwert aktualisieren

if __name__ == "__main__":
    gui = tk.Tk()
    app = GUI(master = gui)
    app.mainloop()

Wenn Sie mehr Zeitgenauigkeit wünschen, ist der Vorgang etwas kompliziert, Sie können jedoch wie folgt schreiben. Ich denke, es wird zeitlich doppelt so genau sein, aber es wird etwas weniger lesbar sein.

import tkinter as tk
import threading
import time

class GUI(tk.Frame):
    def __init__(self,master = None):
        super().__init__(master)
        self.master = master
        master.geometry("300x300")
        master.title("Test")
        
        self.count = 0
        
        self.test = tk.Frame(self.master)
        self.test.pack()
        self.label = tk.Label(self.test)
        self.label.pack()
        self.label["text"] = str(self.count)
        self.buftime = time.time()#Timer-Initialisierung
        self.timeEvent()
    
    
    def timeEvent(self):
        tmp = time.time()
        if(tmp - self.buftime) >= 1: #Wenn 1 Sek. Verstrichen ist
            th = threading.Thread(target=self.update)
            th.start()
            print(tmp - self.buftime)
            self.buftime = tmp
        self.after(1, self.timeEvent)
          
    def update(self):
        self.count += 1
        self.label["text"] = str(self.count)     





if __name__ == "__main__":
    gui = tk.Tk()
    app = GUI(master = gui)
    app.mainloop()

Bei Verwendung des Zeitplanmoduls

Sie können dasselbe mit dem Modul "Zeitplan" tun. Dies muss jedoch mit pip installiert werden. Darüber hinaus scheint eine periodische Ausführung in Millisekundeneinheiten nicht innerhalb des untersuchten Bereichs erfolgen zu können.

Wenn es in Sekunden ist, denke ich, dass dies besser lesbar ist, daher ist es möglicherweise besser, es entsprechend dem Zweck auszuwählen.

pip install schedule

import tkinter as tk
import schedule

class GUI(tk.Frame):
    def __init__(self,master = None):
        super().__init__(master)
        self.master = master
        master.geometry("300x300")
        master.title("Test")
        
        self.count = 0
        
        self.test = tk.Frame(self.master)
        self.test.pack()
        self.label = tk.Label(self.test)
        self.label.pack()
        self.label["text"] = str(self.count)
        
        schedule.every(1).seconds.do(self.update)#Aufgabe zum Zeitplan hinzufügen
        self.sc()
        
    def sc(self): #Überprüfen Sie den Aufgabenstatus regelmäßig mit dem Zeitplanmodul
        schedule.run_pending()
        self.after(1, self.sc) #Rekursiv ausführen
    
    def update(self):
        self.count += 1
        print(self.count)
        self.label["text"] = str(self.count)        

if __name__ == "__main__":
    gui = tk.Tk()
    app = GUI(master = gui)
    app.mainloop()

(Ergänzung) Informationen zur Thread-Verarbeitung in Python

Das "Threading" -Modul von Python wird nur einmal pro Instanzdeklaration ausgeführt. Dies ist eine Spezifikation des Threading-Moduls. Ein Beispiel ist unten gezeigt.

error.py

import threading

th = threading.Thread(target=self.update)
th.start()
th.start() #← Fehler hier "Laufzeitfehler": threads can only be started once」