How to break out of a while True: loop with a button

OK This is what I thought I was being asked to do with regards to coding this without using threads, but this does not work either.

import tkinter as tk
import time

root = tk.Tk()
switch = False

def blink(switch):
    while switch == True:
        print('BLINK...BLINK...')
        time.sleep(0.5)
    while switch == False:
        break

def switchon():
    switch = True
    blink(switch)

def switchoff():
    switch = False
    blink(switch)

def kill():
    root.destroy()

onbutton = tk.Button(root, text = "Blink ON", command = switchon)
onbutton.pack()
offbutton =  tk.Button(root, text = "Blink OFF", command = switchoff)
offbutton.pack()
killbutton = tk.Button(root, text = "EXIT", command = kill)
killbutton.pack()

root.mainloop()

Sean,

The "use threads" suggestion was a "future improvement" because it "might improve the performance". I tried to say that "improving performance" at this stage is NOT a good idea for two reasons. 1) I don't think it actually improves performance and 2) is detracts from the issue of trying to get things to work.

I am not very familiar with the language you're using. But the way you've written the blink function is never going to work.

You are calling the blink function, with either a true or a false argument. In the first case (true) the while switch==true will ALLWAYS be true and remain true, so the loop can never end. In the second case (false), when you call the function the while loop will simply never execute and the second while loop will issue a useless "break" function.

IF you get threads to work, and IF they work in python the way they work in C, then....

[code]

def blink:

    while True:

         if (switch) print ('blink')

         time.sleep (0.5)

[/code]

Now YOU have to figure out how to make this a thread. (I googled this for you and it is too complicated for me to understand in 5 minutes).  This function will continue to run, even when switch is false, but then it won't do the blink. 

You may have to do some python magic to make the "switch" variable a global variable.

Now when your program starts you do create_thread (blink) (however that is written in python). When the "start blinking" button is pressed you simply set switch=True, and when stop blinking button is pressed you simply do switch=False;

When "quit" is pressed you'd better somehow "kill" the thread that does the blinking.

Another way to implement this is to simply CREATE the thread doing the blinking when the start button is pressed and to stop the thread when either the stop or quit button is pressed.

That code doesn't work very well for a responsive interface, you would need to be holding the button down throughout the sleep cycle in order for it to be tested when the if statement comes back around (for how long depends on when in the sleep cycle you started pressing the button. The worst case scenario would be pressing it for 0.5s which is a lot longer than anybody would like out of an on screen button. Also the light would only blink if the button was being held down). Not to mention that keeping the loop going when its not needed to blink the button is wholly inefficient and im sure you can agree that is just plain bad practice.

The code I provided above is a direct drag and drop replacement for the original that doesnt use threading, im not going to say its the most efficient but it is working code that I tested before I posted and easy to read (for the sake of argument the performance increase of threading comes from not locking up a linux process and allowing it to be free'd up to do something else during the python threads sleep time, like draw the button to the screen efficiently, handle its file system, draw the desktop, send/recieve network data. All things that would benefit, when I talk about these things Im looking from an overall system advantage not just a narrow view of a single python script)

That code doesn't work very well for a responsive interface, you would need to be holding the button down throughout the sleep cycle in order for it to be tested when the if statement comes back around (for how long depends on when in the sleep cycle you started pressing the button. The worst case scenario would be pressing it for 0.5s which is a lot longer than anybody would like out of an on screen button. Also the light would only blink if the button was being held down). Not to mention that keeping the loop going when its not needed to blink the button is wholly inefficient and im sure you can agree that is just plain bad practice.

The code I provided above is a direct drag and drop replacement for the original that doesnt use threading, im not going to say its the most efficient but it is working code that I tested before I posted and easy to read (for the sake of argument the performance increase of threading comes from not locking up a linux process and allowing it to be free'd up to do something else during the python threads sleep time, like draw the button to the screen efficiently, handle its file system, draw the desktop, send/recieve network data. All things that would benefit, when I talk about these things Im looking from an overall system advantage not just a narrow view of a single python script)

I tried to use the code that you supplied but I was unable to get it to work. Like before the interface locks up once the while loop was entered.