Oh i get it alright, however in my code I have to push the W button like this:
import pyautogui import time pyautogui.keyDown('w') time.sleep(2) pyautogui.keyUp('w') while the example you gave: def fn(): global run_me while run_me: ... do some work ... and then elsewhere you go: global run_me run_me = True ... create and start the Thread ... ... later ... run_me = False T.join() theoretically deals with my problem, in practice though, my function spend almost all its time holding down the 'w' button, given how many miliseconds i need it. and so it's not responsive enough for this reason. Is there a way to pause/kill the thread? thanks! On Thu, May 25, 2017 at 7:47 PM, Michael C <mysecretrobotfact...@gmail.com> wrote: > message received, i ll take a look tomorrow asap. > > thanks for replying!!! > > On Thu, May 25, 2017 at 3:03 PM, Cameron Simpson <c...@zip.com.au> wrote: > >> On 25May2017 11:52, Michael C <mysecretrobotfact...@gmail.com> wrote: >> >>> Right now all i need is to grab 3 values from 3 variables before killing >>> a >>> thread, like this: >>> >>> def stuff(): >>> do stuff, >>> get values, (x,y,d) >>> >>> # main code >>> startthread(stuff(), blah) >>> # if else need to sleep or kill the thread, and because I'll restart the >>> thread later, I'd like to get the values from the thread, say x,y,d in >>> order to restart the thread. >>> loop. >>> >>> Therefore, how do I get a few values from a few variables from the thread >>> and then close it? >>> >>> Threading is very new to me, so I have to be very diligent. >>> >> >> You always need to be diligent with threads :-) >> >> Can you explain why you need to use a thread for this? The first cut of >> your program looks like you could do it with a ordinary function: >> >> def stuff(): >> ... compute x, y, z ... >> return x, y, z >> >> def main(): >> x, y, z = stuff() >> >> OTOH, your later description suggests that you want to kick off a thread >> to work on something, and have your main program let it run, or pause it. >> The implication is that x, y, z represent the thread state allowing you to >> restart it from scratch at the same point where you paused/stopped things. >> >> There are a few different ways to manage that scenario. But first, write >> yourself a small Thread based program to familiarise yourself with threads. >> For example (untested): >> >> from __future__ import print_function >> from time import sleep >> from threading import Thread >> >> def thread_main_body(): >> print("thread started") >> for n in range(20): >> print("thread", n) >> sleep(0.3) >> print("thread done") >> >> def main(): >> print("main") >> T = Thread(target=thread_main_body) >> print("main: Thread created but _not_ started") >> sleep(1) >> T.start() >> print("thread started") >> for n in range(10): >> print("main", n) >> sleep(0.4) >> print("main program waiting for thread") >> T.join() >> print("main program done") >> >> You should see the main thread and your subthread outputs interleaved. >> The sleeps are just to ensure some interleaving and to give good >> interactive feel. It should run for about 8 seconds overall. Make sure >> you're happy you understand what is happening, why, and when. >> >> There are a few things you need to keep in mind with threads (in Python, >> and to a degree in other languages): >> >> 1: You can't kill/stop a Thread. Instead, the usual approach to to share >> some state with some kind of "running" flag, a boolean saying that the >> Thread's function should continue. Then the thread polls that regularly. >> Eg, if the thread function runs a main loop it might look like this: >> >> def fn(): >> global run_me >> while run_me: >> ... do some work ... >> >> and then elsewhere you go: >> >> global run_me >> run_me = True >> ... create and start the Thread ... >> ... later ... >> run_me = False >> T.join() >> >> so effectively you ask the Thread to stop, and it obeys when it notices >> the change to "run_me". Using a global for this is pretty crube, and not >> the general approach, BTW. >> >> 2: Like any other function, the local varaibles to the thread function >> are not available outside. Thus the "global" hack above. So to share state >> you would usually make some kind of object with the state, and pass it in >> to the Thread when you create and start it: >> >> def fn(state): >> while state.run_me: >> ... do stuff, keep important things like results in "state" ... >> state.x = 1 >> state.y = whatever >> >> class State(object): >> pass >> >> def main(): >> state = State() >> state.run_me = True >> T = Thread(target=fn, args=(state,)) >> T.start() >> for n in range(10): >> print("main", n, "x =", state.x, "y =", state.y) >> sleep(0.3) >> state.run_me = False >> T.join() >> >> As I remarked, there are a few ways to approach your scenario. The above >> should get you started on one approach. Pausing can be done in a few ways, >> either by starting and stopping individual threads, one after another, or >> by starting one thread and using a mutex of some kind to cause it to >> suspend activity when needed. Yet another approach is corroutines, but I'd >> recommend getting threading understood first to avoid confusion. >> >> Come back woith some functioning code and more questions. >> >> Cheers, >> Cameron Simpson <c...@zip.com.au> >> > > _______________________________________________ Tutor maillist - Tutor@python.org To unsubscribe or change subscription options: https://mail.python.org/mailman/listinfo/tutor