使用 tkinter 中的停止按钮中断 while 循环

Question

I wrote a python GUI which should create and update a .csv file by clicking a button called "Start" and should stop the while loop which updates .csv by clicking another button called "Stop" . But whenever I run the GUI and click on start it freezes. Although, I see that the .csv file is continuously updating but I can't stop the .csv from updating new rows. I am just simply running the code using python 2.7 & ubuntu terminal writing python filename.py . Can anyone please check what's wrong in my code?

from Tkinter import *
import datetime
import sys
import time
import csv
import math

A1 = 0

def csv_write(label):
    global A1
    A1 = 0
    A = str(datetime.datetime.now()) + ".csv"
    start = time.time()
    elapsed = 0
    with open(A, 'wt') as filename:
         csv_writer = csv.writer(filename, delimiter=',')
         csv_writer.writerow(('IMU', 'Time', 'A.Sensor.X', 'A.Sensor.Y',   'A.Sensor.Z', 'G.Sensor.X', 'G.Sensor.Y',
                         'G.Sensor.Z', 'M.Sensor.X', 'M.Sensor.Y', 'M.Sensor.Z',
                         'IMU', 'Time', 'A.Sensor.X', 'A.Sensor.Y', 'A.Sensor.Z', 'G.Sensor.X', 'G.Sensor.Y',
                         'G.Sensor.Z', 'M.Sensor.X', 'M.Sensor.Y', 'M.Sensor.Z',
                         'IMU', 'Time', 'A.Sensor.X', 'A.Sensor.Y', 'A.Sensor.Z', 'G.Sensor.X', 'G.Sensor.Y',
                         'G.Sensor.Z', 'M.Sensor.X', 'M.Sensor.Y', 'M.Sensor.Z',
                         'IMU', 'Time', 'A.Sensor.X', 'A.Sensor.Y', 'A.Sensor.Z', 'G.Sensor.X', 'G.Sensor.Y',
                         'G.Sensor.Z', 'M.Sensor.X', 'M.Sensor.Y', 'M.Sensor.Z',
                         'IMU', 'Time', 'A.Sensor.X', 'A.Sensor.Y', 'A.Sensor.Z', 'G.Sensor.X', 'G.Sensor.Y',
                         'G.Sensor.Z', 'M.Sensor.X', 'M.Sensor.Y', 'M.Sensor.Z',
                         'IMU', 'Time', 'A.Sensor.X', 'A.Sensor.Y', 'A.Sensor.Z', 'G.Sensor.X', 'G.Sensor.Y',
                         'G.Sensor.Z', 'M.Sensor.X', 'M.Sensor.Y', 'M.Sensor.Z'))
         while (A1==0):

             elapsed = str(time.time() - start)
             label['text']=elapsed 
             csv_writer.writerow((1, 1, 2, 3,
                             4, 5, 6,
                             7,8, 9,
                             1, 2, 3,
                             4, 5, 6,
                             7, 8,
                             9, 1, 2,
                             3, 4, 5,
                             6, 7, 8,
                             9, 0, 1,
                             2, 3, 4,
                             5, 6, 7,
                             8, 9, 0,
                             1, 2,
                             3, 4, 5,
                             6, 7, 8,
                             9, 0, 1,
                             2, 3,
                             4, 5, 6,
                             7, 8, 9,
                             0, 1, 2,
                             3, 4,
                             5, 6, 7))


def stop():  
    global A1
    A1 = 1

root = Tk()
frame = Frame(root)
frame.pack()
root.title("connect and get sensor data")
root.geometry("500x500")  # You want the size of the app to be 500x500
root.resizable(0, 0)  # Don't allow resizing in the x or y direction
label = Label(root, text="Welcome!", fg="black", font="Verdana 15 bold")
label.pack(side=TOP, padx=5 )
button = Button(root, text='Start', width=25, command=lambda: csv_write(label))
button1 = Button(root, text='Stop', width=25, command=lambda: stop())
button1.pack(side=BOTTOM, pady=10)
button.pack(side=BOTTOM, pady=10)
root.mainloop()

Answer 1

When using a GUI toolkit like tkinter, programs work differently from normal python scripts.

GUI's depend on an event loop to update. So your code must fit into the event loop into the form of callbacks or timeout functions. Such callbacks should not take too long because they are executed from the event loop. If they take long enough mouse and keyboard events will pile up. This will be noticeable as the GUI being unresponsive.

There are several ways to solve this.

The easiest way is to cut up the update process in small pieces, say one row. You keep the index of the current row as a global variable. In a function, you write the indexed row to the file, increase the index. The function is registered as a timeout function (using the after method of tkinter.Tk ). The last thing that the function should do is re-register itself again (using after ) unless A1 == 1 . In the callback for the Start button, you schedule the update function with after .

Two other options are to use multithreading to multiprocessing. However, these are significantly more complicated. I would not recommend them for a novice, nor for such a relatively easy task.

Let's talk about updating in a different thread. This can be complicated because tkinter is not thread-safe; you should not call tkinter from that second thread. Since both threads can see and alter the same global variables, you have to be careful with them. You should guard variables that can be read or updated from both threads with locks (eg mutex). That is, in both threads you should acquire the lock before changing a variable and release it after you have made the change. If the variable is a mutable data structure it would be prudent to use the lock even when reading from it. Additionally, Python3 is much better at dividing processor time between different threads than Python2. So if you use the latter, it might not work as you expect.

The third option is to do the writing in a different process. This means that you have to use inter-process communication, which has to be fitted smoothly into the event loop as well.

Below is an example program I wrote that uses after . It is a simple find and replace utility for ms-windows. The original is hosted on github .

A couple of remarks:

1. I'm defining a class that inherits from tk.Tk as the user interface. This makes it easier to encapsulate data properly; all callback methods automatically have access to the object's attributes. You can do tkinter programs without a class, but it tends to be a little more messy.

2. The __init__ method creates the object (and the neccesary attributes), but I have separated creating the window into the create_window method.

3. The replace_step method is doing one step of the work.

4. The names of callback methods end in _cb . This is just a convention to make them easier to find.

5. The main function handles command-line arguments before starting the GUI.

Here is the code. I hope you find it useful.

#!/usr/bin/env python3
# file: far.py
# vim:fileencoding=utf-8:fdm=marker:ft=python
#
# Copyright © 2018 R.F. Smith <rsmith@xs4all.nl>.
# SPDX-License-Identifier: MIT
# Created: 2018-02-27T23:38:17+0100
# Last modified: 2018-04-17T00:11:57+0200

from tkinter import filedialog
from tkinter import ttk
from tkinter.font import nametofont
import argparse
import os
import shutil
import sys
import tkinter as tk

__version__ = '0.1'


class FarUI(tk.Tk):

    def __init__(self, rootdir='', findname='', replacement=''):
        tk.Tk.__init__(self, None)
        self.running = False
        self.finditer = None
        self.create_window()
        self.tree['text'] = rootdir
        self.find.insert(0, findname)
        self.replace['text'] = replacement

    def create_window(self):
        """Create the GUI"""
        # Set the font.
        default_font = nametofont("TkDefaultFont")
        default_font.configure(size=12)
        self.option_add("*Font", default_font)
        # General commands and bindings
        self.bind_all('q', self.quit_cb)
        self.wm_title('Find and Replace v' + __version__)
        self.columnconfigure(4, weight=1)
        self.rowconfigure(4, weight=1)
        # First row
        ftxt = ttk.Label(self, text='Find:')
        ftxt.grid(row=0, column=0, sticky='w')
        fe = ttk.Entry(self, justify='left')
        fe.grid(row=0, column=1, columnspan=4, sticky='ew')
        self.find = fe
        # Second row
        treetxt = ttk.Label(self, text='In tree:')
        treetxt.grid(row=1, column=0, sticky='w')
        te = ttk.Label(self, justify='left')
        te.grid(row=1, column=1, columnspan=4, sticky='ew')
        tb = ttk.Button(self, text="browse...", command=self.tree_cb)
        tb.grid(row=1, column=5, columnspan=2, sticky='ew')
        self.tree = te
        # Third row
        reptxt = ttk.Label(self, text='Replace with:')
        reptxt.grid(row=2, column=0, sticky='w')
        re = ttk.Label(self, justify='left')
        re.grid(row=2, column=1, columnspan=4, sticky='ew')
        rb = ttk.Button(self, text="browse...", command=self.replace_cb)
        rb.grid(row=2, column=5, columnspan=2, sticky='ew')
        self.replace = re
        # Fourth row
        run = ttk.Button(self, text="run", command=self.start_replace_cb)
        run.grid(row=3, column=0, sticky='ew')
        stop = ttk.Button(self, text="stop", command=self.stop_replace_cb, state=tk.DISABLED)
        stop.grid(row=3, column=1, sticky='w')
        self.runbutton = run
        self.stopbutton = stop
        qb = ttk.Button(self, text="quit", command=self.destroy)
        qb.grid(row=3, column=2, sticky='w')
        ttk.Label(self, justify='left', text='Progress: ').grid(row=3, column=3, sticky='w')
        progress = ttk.Label(self, justify='left', text='None')
        progress.grid(row=3, column=4, columnspan=2, sticky='ew')
        self.progress = progress
        # Fifth row
        message = tk.Text(self, height=4)
        message.grid(row=4, column=0, columnspan=6, sticky='nsew')
        s = ttk.Scrollbar(self, command=message.yview)
        s.grid(row=4, column=6, sticky='nse')
        message['yscrollcommand'] = s.set
        self.message = message

    def quit_cb(self, event):
        """
        Callback to handle quitting.

        This is necessary since the quit method does not take arguments.
        """
        self.running = False
        self.quit()

    def tree_cb(self):
        rootdir = filedialog.askdirectory(
            parent=self, title='Directory where to start looking', mustexist=True
        )
        self.tree['text'] = rootdir

    def replace_cb(self):
        replacement = filedialog.askopenfilename(parent=self, title='Replacement file')
        self.replace['text'] = replacement

    def start_replace_cb(self):
        rootdir = self.tree['text']
        filename = self.find.get()
        replacement = self.replace['text']
        if self.running or not rootdir or not filename or not replacement:
            self.message.delete('1.0', tk.END)
            self.message.insert(tk.END, 'Missing data!')
            return
        self.running = True
        self.message.delete('1.0', tk.END)
        self.message.insert(tk.END, 'Starting replacement\n')
        self.runbutton['state'] = tk.DISABLED
        self.stopbutton['state'] = tk.NORMAL
        self.finditer = os.walk(rootdir)
        self.after(1, self.replace_step)

    def replace_step(self):
        if not self.running:
            return
        try:
            path, _, files = self.finditer.send(None)
            rootlen = len(self.tree['text']) + 1
            # Skip known revision control systems directories.
            for skip in ('.git', '.hg', '.svn', '.cvs', '.rcs'):
                if skip in path:
                    self.progress['text'] = 'skipping ' + path[rootlen:]
                    return
            if len(path) > rootlen and path[rootlen] != '.':
                self.progress['text'] = 'processing ' + path[rootlen:]
                filename = self.find.get()
                if filename in files:
                    original = path + os.sep + filename
                    replacement = self.replace['text']
                    repfile = os.path.basename(replacement)
                    dest = path + os.sep + repfile
                    self.message.insert(tk.END, "Removing '{}'\n".format(original))
                    os.remove(original)
                    self.message.insert(tk.END, "Copying '{}' to '{}'\n".format(replacement, dest))
                    shutil.copy2(replacement, dest)
            self.after(1, self.replace_step)
        except StopIteration:
            self.stop()
            self.message.insert(tk.END, 'Finished replacement.\n')

    def stop(self):
        self.running = False
        self.finditer = None
        self.runbutton['state'] = tk.NORMAL
        self.stopbutton['state'] = tk.DISABLED
        self.progress['text'] = 'None'

    def stop_replace_cb(self):
        self.stop()
        self.message.insert(tk.END, 'Replacement stopped by user.\n')


def main():
    """Main entry point for far.py"""
    # Parse the arguments.
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument(
        '-d', '--rootdir', type=str, default=os.getcwd(), help='Directory to start looking in.'
    )
    parser.add_argument('-f', '--findname', type=str, default='', help='Name of the file to find.')
    parser.add_argument(
        '-r', '--replacement', type=str, default='', help='Path of the replacement file.'
    )
    parser.add_argument('-v', '--version', action='version', version=__version__)
    args = parser.parse_args(sys.argv[1:])
    if not args.rootdir.startswith(os.sep):
        args.rootdir = os.getcwd() + os.sep + args.rootdir
    # Create the UI.
    root = FarUI(args.rootdir, args.findname, args.replacement)
    root.mainloop()


if __name__ == '__main__':
    # Detach from the terminal on POSIX systems.
    if os.name == 'posix':
        if os.fork():
            sys.exit()
    # Run the program.
    main()

Answer 2

It works for me when using Thread and global variable. Not that complicated, just a few lines. Your code was modified with those. Hope it helps:-

    from tkinter import *
    import datetime
    import sys
    import time
    import csv
    import math
    from threading import Thread


    def start_thread(label):
        global A1
        A1 = 0

        # Create and launch a thread 
        t = Thread(target = csv_write, args = (label, ))
        t.start()

    def csv_write(label):
        global A1
        A1 = 0
        A = str(datetime.datetime.now()) + ".csv"
        start = time.time()
        elapsed = 0
        with open(A, 'wt') as filename:
             csv_writer = csv.writer(filename, delimiter=',')
             csv_writer.writerow(('IMU', 'Time', 'A.Sensor.X', 'A.Sensor.Y',   'A.Sensor.Z', 'G.Sensor.X', 'G.Sensor.Y',
                             'G.Sensor.Z', 'M.Sensor.X', 'M.Sensor.Y', 'M.Sensor.Z',
                             'IMU', 'Time', 'A.Sensor.X', 'A.Sensor.Y', 'A.Sensor.Z', 'G.Sensor.X', 'G.Sensor.Y',
                             'G.Sensor.Z', 'M.Sensor.X', 'M.Sensor.Y', 'M.Sensor.Z',
                             'IMU', 'Time', 'A.Sensor.X', 'A.Sensor.Y', 'A.Sensor.Z', 'G.Sensor.X', 'G.Sensor.Y',
                             'G.Sensor.Z', 'M.Sensor.X', 'M.Sensor.Y', 'M.Sensor.Z',
                             'IMU', 'Time', 'A.Sensor.X', 'A.Sensor.Y', 'A.Sensor.Z', 'G.Sensor.X', 'G.Sensor.Y',
                             'G.Sensor.Z', 'M.Sensor.X', 'M.Sensor.Y', 'M.Sensor.Z',
                             'IMU', 'Time', 'A.Sensor.X', 'A.Sensor.Y', 'A.Sensor.Z', 'G.Sensor.X', 'G.Sensor.Y',
                             'G.Sensor.Z', 'M.Sensor.X', 'M.Sensor.Y', 'M.Sensor.Z',
                             'IMU', 'Time', 'A.Sensor.X', 'A.Sensor.Y', 'A.Sensor.Z', 'G.Sensor.X', 'G.Sensor.Y',
                             'G.Sensor.Z', 'M.Sensor.X', 'M.Sensor.Y', 'M.Sensor.Z'))
             while (A1==0):  
                 elapsed = str(time.time() - start)
                 label['text']=elapsed 
                 csv_writer.writerow((1, 1, 2, 3,
                                 4, 5, 6,
                                 7,8, 9,
                                 1, 2, 3,
                                 4, 5, 6,
                                 7, 8,
                                 9, 1, 2,
                                 3, 4, 5,
                                 6, 7, 8,
                                 9, 0, 1,
                                 2, 3, 4,
                                 5, 6, 7,
                                 8, 9, 0,
                                 1, 2,
                                 3, 4, 5,
                                 6, 7, 8,
                                 9, 0, 1,
                                 2, 3,
                                 4, 5, 6,
                                 7, 8, 9,
                                 0, 1, 2,
                                 3, 4,
                                 5, 6, 7))


    def stop():  
        global A1
        A1 = 1

    root = Tk()
    frame = Frame(root)
    frame.pack()
    root.title("connect and get sensor data")
    root.geometry("500x500")  # You want the size of the app to be 500x500
    root.resizable(0, 0)  # Don't allow resizing in the x or y direction
    label = Label(root, text="Welcome!", fg="black", font="Verdana 15 bold")
    label.pack(side=TOP, padx=5 )
    button = Button(root, text='Start', width=25, command=lambda: start_thread(label))
    button1 = Button(root, text='Stop', width=25, command=lambda: stop())
    button1.pack(side=BOTTOM, pady=10)
    button.pack(side=BOTTOM, pady=10)
    root.mainloop()