Comment connecter une barre de progression pour une fonction?

À comprendre le " gel " vous devez comprendre mainloop(). L'appel de cette méthode, on commence la tkinter boucle d'événements. Le thread principal est responsable de cette boucle. Par conséquent, lorsque votre travail intensif de la fonction s'exécute dans le thread principal, il est également interférer avec le mainloop. Pour éviter cela, vous pouvez utiliser un secondaire Thread à l'exécution de votre fonction. Il est recommandé que les threads secondaires ne sont pas donné accès à tkinter objets. Allen B. Taylor, auteur de mtTkinter, les états:

Les problèmes proviennent du fait que la _tkinter module tente d'
contrôle de gain du thread principal via une interrogation technique lors de l'
traitement des appels provenant d'autres threads.
Si elle réussit, tout est bien. Si elle échoue (c'est à dire, après un délai d'attente), la
l'application reçoit une exception avec le message: "RuntimeError:
thread principal n'est pas dans la boucle principale".

Vous pouvez avoir le thread secondaire placer des informations dans un File. Alors avoir une fonction qui vérifie le File d'attente chaque x millisecondes, dans le mainloop, via le après() méthode.

D'abord, décidez ce que vous voulez que la valeur de la Progressbar's maximum option.

C'est la Barre de progression maximale de la valeur de l'indicateur (le nombre d'unités requises pour remplir la Barre de progression).
Par exemple, vous pouvez définir maximum=4 et puis la valeur de l'indicateur dans la File d'attente après chacun de vos quatre fonctions. Le thread principal peut ensuite récupérer ces valeurs (à partir de la File d'attente) pour définir le progrès par l'intermédiaire d'un tkinter.IntVar().
(Notez que si vous utilisez progbar.step(), la Barre de progression se remet à 0 (vide) à la fin, au lieu de 4 (complètement rempli).)

Voici un rapide coup d'oeil à la façon dont vous pouvez utiliser un tkinter.IntVar() avec une Progressbar:

int_var = tkinter.IntVar()
pb_instance = ttk.Progressbar(root, maximum=4)
pb_instance['variable'] = int_var
pb_instance.pack()
# completely fill the Progressbar
int_var.set(4)
# get the progress value
x = int_var.get()

Voici un exemple basé sur votre propre (rebaptisé le "principal" de la fonction "arbitraire"):

import time
import threading
try: import tkinter
except ImportError:
import Tkinter as tkinter
import ttk
import Queue as queue
else:
from tkinter import ttk
import queue
class GUI_Core(object):
def __init__(self):
self.root = tkinter.Tk()
self.int_var = tkinter.IntVar()
progbar = ttk.Progressbar(self.root, maximum=4)
# associate self.int_var with the progress value
progbar['variable'] = self.int_var
progbar.pack()
self.label = ttk.Label(self.root, text='0/4')
self.label.pack()
self.b_start = ttk.Button(self.root, text='Start')
self.b_start['command'] = self.start_thread
self.b_start.pack()
def start_thread(self):
self.b_start['state'] = 'disable'
self.int_var.set(0) # empty the Progressbar
self.label['text'] = '0/4'
# create then start a secondary thread to run arbitrary()
self.secondary_thread = threading.Thread(target=arbitrary)
self.secondary_thread.start()
# check the Queue in 50ms
self.root.after(50, self.check_que)
def check_que(self):
while True:
try: x = que.get_nowait()
except queue.Empty:
self.root.after(25, self.check_que)
break
else: # continue from the try suite
self.label['text'] = '{}/4'.format(x)
self.int_var.set(x)
if x == 4:
self.b_start['state'] = 'normal'
break
def func_a():
time.sleep(1) # simulate some work
def func_b():
time.sleep(0.3)
def func_c():
time.sleep(0.9)
def func_d():
time.sleep(0.6)
def arbitrary():
func_a()
que.put(1)
func_b()
que.put(2)
func_c()
que.put(3)
func_d()
que.put(4)
que = queue.Queue()
gui = GUI_Core() # see GUI_Core's __init__ method
gui.root.mainloop()

Si tout ce que vous voulez, c'est quelque chose qui indique à l'utilisateur qu'il y a de l'activité

vous pouvez définir la Progressbar est mode option pour 'indeterminate'.

L'indicateur rebondit en arrière et en avant dans ce mode (la vitesse a trait à l'option maximum).

Ensuite, vous pouvez appeler la Progressbar est start() méthode directement avant de démarrer le thread secondaire;

et puis d'appeler stop() après secondary_thread.is_alive() retourne Faux.

Voici un exemple:

import time
import threading
try: import tkinter
except ImportError:
import Tkinter as tkinter
import ttk
else: from tkinter import ttk
class GUI_Core(object):
def __init__(self):
self.root = tkinter.Tk()
self.progbar = ttk.Progressbar(self.root)
self.progbar.config(maximum=4, mode='indeterminate')
self.progbar.pack()
self.b_start = ttk.Button(self.root, text='Start')
self.b_start['command'] = self.start_thread
self.b_start.pack()
def start_thread(self):
self.b_start['state'] = 'disable'
self.progbar.start()
self.secondary_thread = threading.Thread(target=arbitrary)
self.secondary_thread.start()
self.root.after(50, self.check_thread)
def check_thread(self):
if self.secondary_thread.is_alive():
self.root.after(50, self.check_thread)
else:
self.progbar.stop()
self.b_start['state'] = 'normal'
def func_a():
time.sleep(1) # simulate some work
def func_b():
time.sleep(0.3)
def func_c():
time.sleep(0.9)
def func_d():
time.sleep(0.6)
def arbitrary():
func_a()
func_b()
func_c()
func_d()
gui = GUI_Core()
gui.root.mainloop()

→ Progressbar de référence