blocks|key|260698|text|最好的方法是启动计时器线程一次。在您的计时器线程中，您将编写以下代码|type|unstyled|depth|inlineStyleRanges|entityRanges|data|260699|class+MyThread(Thread):
++++def+__init__(self,+event):
++++++++Thread.__init__(self)
++++++++self.stopped+=+event

++++def+run(self):
++++++++while+not+self.stopped.wait(0.5):
++++++++++++print("my+thread")
++++++++++++#+call+a+function|code-block|syntax|javascript|260700|在启动计时器的代码中，然后可以set停止事件以停止计时器。|offset|length|style|CODE|260701|stopFlag+=+Event()
thread+=+MyThread(stopFlag)
thread.start()
#+this+will+stop+the+timer
stopFlag.set()|260702|entityMap^0|0|0|F|3|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

The best way is to start the timer thread once. Inside your timer thread you'd code the following

<pre><code>class MyThread(Thread):
 def __init__(self, event):
 Thread.__init__(self)
 self.stopped = event

 def run(self):
 while not self.stopped.wait(0.5):
 print("my thread")
 # call a function
</code></pre>

In the code that started the timer, you can then <code>set</code> the stopped event to stop the timer.

<pre><code>stopFlag = Event()
thread = MyThread(stopFlag)
thread.start()
# this will stop the timer
stopFlag.set()
</code></pre>

blocks|key|477433|text|来自Equivalent+of+setInterval+in+python|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|477434|import+threading

def+setInterval(interval):
++++def+decorator(function):
++++++++def+wrapper(*args,+**kwargs):
++++++++++++stopped+=+threading.Event()

++++++++++++def+loop():+#+executed+in+another+thread
++++++++++++++++while+not+stopped.wait(interval):+#+until+stopped
++++++++++++++++++++function(*args,+**kwargs)

++++++++++++t+=+threading.Thread(target=loop)
++++++++++++t.daemon+=+True+#+stop+if+the+program+exits
++++++++++++t.start()
++++++++++++return+stopped
++++++++return+wrapper
++++return+decorator|code-block|syntax|javascript|477435|用法：|477436|@setInterval(.5)
def+function():
++++"..."

stop+=+function()+#+start+timer,+the+first+call+is+in+.5+seconds
stop.set()+#+stop+the+loop
stop+=+function()+#+start+new+timer
#+...
stop.set()+|477437|或者这是the+same+functionality+but+as+a+standalone+function+instead+of+a+decorator|477438|cancel_future_calls+=+call_repeatedly(60,+print,+"Hello,+World")
#+...
cancel_future_calls()+|477439|Here's+how+to+do+it+without+using+threads。|477440|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/q/5179467/4279|1|https://stackoverflow.com/a/22498708/4279|2|https://stackoverflow.com/a/14040516/4279^0|2|Z|0|0|0|0|0|4|22|1|0|0|0|15|2|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@$A|15|B|16|1|17]]|C|$]]|$1|D|3|E|5|F|7|18|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|19|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|1A|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|1B|8|@]|9|@$A|1C|B|1D|1|1E]]|C|$]]|$1|O|3|P|5|F|7|1F|8|@]|9|@]|C|$G|H]]|$1|Q|3|R|5|6|7|1G|8|@]|9|@$A|1H|B|1I|1|1J]]|C|$]]|$1|S|3|-4|5|6|7|1K|8|@]|9|@]|C|$]]]|T|$U|$5|V|W|X|C|$Y|Z]]|10|$5|V|W|X|C|$Y|11]]|12|$5|V|W|X|C|$Y|13]]]]

From <a href="https://stackoverflow.com/q/5179467/4279">Equivalent of setInterval in python</a>:

<pre><code>import threading

def setInterval(interval):
 def decorator(function):
 def wrapper(*args, **kwargs):
 stopped = threading.Event()

 def loop(): # executed in another thread
 while not stopped.wait(interval): # until stopped
 function(*args, **kwargs)

 t = threading.Thread(target=loop)
 t.daemon = True # stop if the program exits
 t.start()
 return stopped
 return wrapper
 return decorator
</code></pre>

Usage:

<pre><code>@setInterval(.5)
def function():
 "..."

stop = function() # start timer, the first call is in .5 seconds
stop.set() # stop the loop
stop = function() # start new timer
# ...
stop.set() 
</code></pre>

Or here's <a href="https://stackoverflow.com/a/22498708/4279">the same functionality but as a standalone function instead of a decorator</a>:

<pre><code>cancel_future_calls = call_repeatedly(60, print, "Hello, World")
# ...
cancel_future_calls() 
</code></pre>

<a href="https://stackoverflow.com/a/14040516/4279">Here's how to do it without using threads</a>.

blocks|key|260744|text|使用计时器线程-|type|unstyled|depth|inlineStyleRanges|entityRanges|data|260745|from+threading+import+Timer,Thread,Event


class+perpetualTimer():

+++def+__init__(self,t,hFunction):
++++++self.t=t
++++++self.hFunction+=+hFunction
++++++self.thread+=+Timer(self.t,self.handle_function)

+++def+handle_function(self):
++++++self.hFunction()
++++++self.thread+=+Timer(self.t,self.handle_function)
++++++self.thread.start()

+++def+start(self):
++++++self.thread.start()

+++def+cancel(self):
++++++self.thread.cancel()

def+printer():
++++print+'ipsem+lorem'

t+=+perpetualTimer(5,printer)
t.start()|code-block|syntax|javascript|260746|这可以由t.cancel()停止|offset|length|style|CODE|260747|entityMap^0|0|0|4|A|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Using timer threads-

<pre><code>from threading import Timer,Thread,Event


class perpetualTimer():

 def __init__(self,t,hFunction):
 self.t=t
 self.hFunction = hFunction
 self.thread = Timer(self.t,self.handle_function)

 def handle_function(self):
 self.hFunction()
 self.thread = Timer(self.t,self.handle_function)
 self.thread.start()

 def start(self):
 self.thread.start()

 def cancel(self):
 self.thread.cancel()

def printer():
 print 'ipsem lorem'

t = perpetualTimer(5,printer)
t.start()
</code></pre>

this can be stopped by <code>t.cancel()</code>

blocks|key|260791|text|from+threading+import+Timer
def+TaskManager():
++++#do+stuff
++++t+=+Timer(+1,+TaskManager+)
++++t.start()

TaskManager()|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|260792|这里有一个小示例，它将有助于更好地理解它是如何运行的。函数taskManager()在最后创建对自身的延迟函数调用。|unstyled|260793|尝试更改"dalay“变量，您将能够看到差异|260794|from+threading+import+Timer,+_sleep

#+------------------------------------------
DATA+=+[]
dalay+=+0.25+#+sec
counter+=+0
allow_run+=+True
FIFO+=+True

def+taskManager():

++++global+counter,+DATA,+delay,+allow_run
++++counter+%2B=+1

++++if+len(DATA)+>+0:
++++++++if+FIFO:
++++++++++++print("["%2Bstr(counter)%2B"]+new+data:+["%2Bstr(DATA.pop(0))%2B"]")
++++++++else:
++++++++++++print("["%2Bstr(counter)%2B"]+new+data:+["%2Bstr(DATA.pop())%2B"]")

++++else:
++++++++print("["%2Bstr(counter)%2B"]+no+data")

++++if+allow_run:
++++++++#delayed+method/function+call+to+it+self
++++++++t+=+Timer(+dalay,+taskManager+)
++++++++t.start()

++++else:
++++++++print("+END+task-manager:+disabled")

#+------------------------------------------
def+main():

++++DATA.append("data+from+main():+0")
++++_sleep(2)
++++DATA.append("data+from+main():+1")
++++_sleep(2)


#+------------------------------------------
print("+START+task-manager:")
taskManager()

_sleep(2)
DATA.append("first+data")

_sleep(2)
DATA.append("second+data")

print("+START+main():")
main()
print("+END+main():")

_sleep(2)
DATA.append("last+data")

allow_run+=+False|260795|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$B|C]]|$1|K|3|-4|5|F|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<pre><code>from threading import Timer
def TaskManager():
 #do stuff
 t = Timer( 1, TaskManager )
 t.start()

TaskManager()
</code></pre>

Here is small sample, it will help beter understanding how it runs.
function taskManager() at the end create delayed function call to it self.

Try to change "dalay" variable and you will able to see difference

<pre><code>from threading import Timer, _sleep

# ------------------------------------------
DATA = []
dalay = 0.25 # sec
counter = 0
allow_run = True
FIFO = True

def taskManager():

 global counter, DATA, delay, allow_run
 counter += 1

 if len(DATA) &gt; 0:
 if FIFO:
 print("["+str(counter)+"] new data: ["+str(DATA.pop(0))+"]")
 else:
 print("["+str(counter)+"] new data: ["+str(DATA.pop())+"]")

 else:
 print("["+str(counter)+"] no data")

 if allow_run:
 #delayed method/function call to it self
 t = Timer( dalay, taskManager )
 t.start()

 else:
 print(" END task-manager: disabled")

# ------------------------------------------
def main():

 DATA.append("data from main(): 0")
 _sleep(2)
 DATA.append("data from main(): 1")
 _sleep(2)


# ------------------------------------------
print(" START task-manager:")
taskManager()

_sleep(2)
DATA.append("first data")

_sleep(2)
DATA.append("second data")

print(" START main():")
main()
print(" END main():")

_sleep(2)
DATA.append("last data")

allow_run = False
</code></pre>

blocks|key|260822|text|为了根据OP请求使用计时器提供正确答案，我将对swapnil+jariwala's+answer进行改进|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|260823|from+threading+import+Timer


class+InfiniteTimer():
++++"""A+Timer+class+that+does+not+stop,+unless+you+want+it+to."""

++++def+__init__(self,+seconds,+target):
++++++++self._should_continue+=+False
++++++++self.is_running+=+False
++++++++self.seconds+=+seconds
++++++++self.target+=+target
++++++++self.thread+=+None

++++def+_handle_target(self):
++++++++self.is_running+=+True
++++++++self.target()
++++++++self.is_running+=+False
++++++++self._start_timer()

++++def+_start_timer(self):
++++++++if+self._should_continue:+#+Code+could+have+been+running+when+cancel+was+called.
++++++++++++self.thread+=+Timer(self.seconds,+self._handle_target)
++++++++++++self.thread.start()

++++def+start(self):
++++++++if+not+self._should_continue+and+not+self.is_running:
++++++++++++self._should_continue+=+True
++++++++++++self._start_timer()
++++++++else:
++++++++++++print("Timer+already+started+or+running,+please+wait+if+you're+restarting.")

++++def+cancel(self):
++++++++if+self.thread+is+not+None:
++++++++++++self._should_continue+=+False+#+Just+in+case+thread+is+running+and+cancel+fails.
++++++++++++self.thread.cancel()
++++++++else:
++++++++++++print("Timer+never+started+or+failed+to+initialize.")


def+tick():
++++print('ipsem+lorem')

#+Example+Usage
t+=+InfiniteTimer(0.5,+tick)
t.start()|code-block|syntax|javascript|260824|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/12435211/python-threading-timer-repeat-function-every-n-seconds/24488061#24488061^0|N|P|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

In the interest of providing a correct answer using Timer as the OP requested, I'll improve upon <a href="https://stackoverflow.com/questions/12435211/python-threading-timer-repeat-function-every-n-seconds/24488061#24488061">swapnil jariwala's answer</a>:

<pre><code>from threading import Timer


class InfiniteTimer():
 """A Timer class that does not stop, unless you want it to."""

 def __init__(self, seconds, target):
 self._should_continue = False
 self.is_running = False
 self.seconds = seconds
 self.target = target
 self.thread = None

 def _handle_target(self):
 self.is_running = True
 self.target()
 self.is_running = False
 self._start_timer()

 def _start_timer(self):
 if self._should_continue: # Code could have been running when cancel was called.
 self.thread = Timer(self.seconds, self._handle_target)
 self.thread.start()

 def start(self):
 if not self._should_continue and not self.is_running:
 self._should_continue = True
 self._start_timer()
 else:
 print("Timer already started or running, please wait if you're restarting.")

 def cancel(self):
 if self.thread is not None:
 self._should_continue = False # Just in case thread is running and cancel fails.
 self.thread.cancel()
 else:
 print("Timer never started or failed to initialize.")


def tick():
 print('ipsem lorem')

# Example Usage
t = InfiniteTimer(0.5, tick)
t.start()
</code></pre>

blocks|key|260872|text|为了一个项目，我不得不这么做。我最后做的就是为这个函数启动一个单独的线程|type|unstyled|depth|inlineStyleRanges|entityRanges|data|260873|t+=+threading.Thread(target+=heartbeat,+args=(worker,))
t.start()|code-block|syntax|javascript|260874|*心跳是我的函数，worker是我的参数之一*|260875|在我的心跳函数中：|260876|def+heartbeat(worker):

++++while+True:
++++++++time.sleep(5)
++++++++#all+of+my+code|260877|因此，当我启动线程时，该函数将重复等待5秒，运行我的所有代码，并无限期地运行。如果你想终止进程，只需终止线程即可。|260878|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|U|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

I had to do this for a project. What I ended up doing was start a separate thread for the function

<pre><code>t = threading.Thread(target =heartbeat, args=(worker,))
t.start()
</code></pre>

****heartbeat is my function, worker is one of my arguments****

inside of my heartbeat function:

<pre><code>def heartbeat(worker):

 while True:
 time.sleep(5)
 #all of my code
</code></pre>

So when I start the thread the function will repeatedly wait 5 seconds, run all of my code, and do that indefinitely. If you want to kill the process just kill the thread.

blocks|key|477636|text|我已经实现了一个作为计时器工作的类。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|477637|我把链接留在这里，以防有人需要它：https://github.com/ivanhalencp/python/tree/master/xTimer|offset|length|477638|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/ivanhalencp/python/tree/master/xTimer^0|0|H|1K|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

I have implemented a class that works as a timer.

I leave the link here in case anyone needs it:
<a href="https://github.com/ivanhalencp/python/tree/master/xTimer" rel="nofollow noreferrer">https://github.com/ivanhalencp/python/tree/master/xTimer</a>

blocks|key|260976|text|我喜欢right2clicky的答案，特别是它不需要在每次计时器滴答的时候拆除一个线程并创建一个新的线程。此外，创建一个定期调用的计时器回调的类也很容易覆盖。这是我的正常用例：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|260977|class+MyClass(RepeatTimer):
++++def+__init__(self,+period):
++++++++super().__init__(period,+self.on_timer)

++++def+on_timer(self):
++++++++print("Tick")


if+__name__+==+"__main__":
++++mc+=+MyClass(1)
++++mc.start()
++++time.sleep(5)
++++mc.cancel()|code-block|syntax|javascript|260978|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I like right2clicky's answer, especially in that it doesn't require a Thread to be torn down and a new one created every time the Timer ticks. In addition, it's an easy override to create a class with a timer callback that gets called periodically. That's my normal use case:

<pre><code>class MyClass(RepeatTimer):
 def __init__(self, period):
 super().__init__(period, self.on_timer)

 def on_timer(self):
 print("Tick")


if __name__ == "__main__":
 mc = MyClass(1)
 mc.start()
 time.sleep(5)
 mc.cancel()
</code></pre>

blocks|key|477832|text|这是一个使用函数而不是类的替代实现。灵感来自上面的@Andrew+Wilkins。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|477833|因为等待比睡眠更准确(它将函数运行时考虑在内)：|477834|import+threading

PING_ON+=+threading.Event()

def+ping():
++while+not+PING_ON.wait(1):
++++print("my+thread+%25s"+%25+str(threading.current_thread().ident))

t+=+threading.Thread(target=ping)
t.start()

sleep(5)
PING_ON.set()|code-block|syntax|javascript|477835|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

This is an alternate implementation using function instead of class. Inspired by @Andrew Wilkins above.

Because wait is more accurate than sleep ( it takes function runtime into account ):

<pre><code>import threading

PING_ON = threading.Event()

def ping():
 while not PING_ON.wait(1):
 print("my thread %s" % str(threading.current_thread().ident))

t = threading.Thread(target=ping)
t.start()

sleep(5)
PING_ON.set()
</code></pre>

blocks|key|261061|text|我提出了另一个使用SingleTon类的解决方案。请告诉我这里是否有内存泄漏。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|261062|import+time,threading

class+Singleton:
++__instance+=+None
++sleepTime+=+1
++executeThread+=+False

++def+__init__(self):
+++++if+Singleton.__instance+!=+None:
++++++++raise+Exception("This+class+is+a+singleton!")
+++++else:
++++++++Singleton.__instance+=+self

++@staticmethod
++def+getInstance():
+++++if+Singleton.__instance+==+None:
++++++++Singleton()
+++++return+Singleton.__instance


++def+startThread(self):
+++++self.executeThread+=+True
+++++self.threadNew+=+threading.Thread(target=self.foo_target)
+++++self.threadNew.start()
+++++print('doing+other+things...')


++def+stopThread(self):
+++++print("Killing+Thread+")
+++++self.executeThread+=+False
+++++self.threadNew.join()
+++++print(self.threadNew)


++def+foo(self):
+++++print("Hello+in+"+%2B+str(self.sleepTime)+%2B+"+seconds")


++def+foo_target(self):
+++++while+self.executeThread:
++++++++self.foo()
++++++++print(self.threadNew)
++++++++time.sleep(self.sleepTime)

++++++++if+not+self.executeThread:
+++++++++++break


sClass+=+Singleton()
sClass.startThread()
time.sleep(5)
sClass.getInstance().stopThread()

sClass.getInstance().sleepTime+=+2
sClass.startThread()|code-block|syntax|javascript|261063|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I have come up with another solution with SingleTon class. Please tell me if any memory leakage is here.
<pre><code>import time,threading

class Singleton:
 __instance = None
 sleepTime = 1
 executeThread = False

 def __init__(self):
 if Singleton.__instance != None:
 raise Exception(&quot;This class is a singleton!&quot;)
 else:
 Singleton.__instance = self

 @staticmethod
 def getInstance():
 if Singleton.__instance == None:
 Singleton()
 return Singleton.__instance


 def startThread(self):
 self.executeThread = True
 self.threadNew = threading.Thread(target=self.foo_target)
 self.threadNew.start()
 print('doing other things...')


 def stopThread(self):
 print(&quot;Killing Thread &quot;)
 self.executeThread = False
 self.threadNew.join()
 print(self.threadNew)


 def foo(self):
 print(&quot;Hello in &quot; + str(self.sleepTime) + &quot; seconds&quot;)


 def foo_target(self):
 while self.executeThread:
 self.foo()
 print(self.threadNew)
 time.sleep(self.sleepTime)

 if not self.executeThread:
 break


sClass = Singleton()
sClass.startThread()
time.sleep(5)
sClass.getInstance().stopThread()

sClass.getInstance().sleepTime = 2
sClass.startThread()
</code></pre>

blocks|key|477948|text|这是连续运行计时器的示例代码。只需在耗尽时创建一个新的计时器并调用相同的函数。这不是最好的方法，但也可以这样做。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|477949|import+threading
import+time


class+ContinousTimer():
++++def+__init__(self):
++++++++self.timer+=+None

++++def+run(self,+msg='abc'):
++++++++print(msg)

++++++++self.timer+=+threading.Timer(interval=2,+function=self.run,+args=(msg,+))
++++++++self.timer.start()


if+__name__+==+"__main__":
++++t+=+ContinousTimer()
++++try:
++++++++t.run(msg="Hello")
++++++++while+True:
++++++++++++time.sleep(0.1)
++++except+KeyboardInterrupt:
++++++++#+Cancel+Timer
++++++++t.timer.cancel()|code-block|syntax|javascript|477950|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This is the sample code for running the timer continuously. Just create a new timer upon exhaustion and call the same function. Not the best way to do it but can be done like this as well.
<pre><code>import threading
import time


class ContinousTimer():
 def __init__(self):
 self.timer = None

 def run(self, msg='abc'):
 print(msg)

 self.timer = threading.Timer(interval=2, function=self.run, args=(msg, ))
 self.timer.start()


if __name__ == &quot;__main__&quot;:
 t = ContinousTimer()
 try:
 t.run(msg=&quot;Hello&quot;)
 while True:
 time.sleep(0.1)
 except KeyboardInterrupt:
 # Cancel Timer
 t.timer.cancel()
</code></pre>

I want to fire off a function every 0.5 seconds and be able to start and stop and reset the timer. I'm not too knowledgeable of how Python threads work and am having difficulties with the python timer.

However, I keep getting <code>RuntimeError: threads can only be started once</code> when I execute <code>threading.timer.start()</code> twice. Is there a work around for this? I tried applying <code>threading.timer.cancel()</code> before each start.

Pseudo code:

<pre><code>t=threading.timer(0.5,function)
while True:
 t.cancel()
 t.start()
</code></pre>

Python threading.timer - repeat function every 'n' seconds

Python

我希望每隔0.5秒启动一个函数，并能够启动、停止和重置计时器。我不太了解Python线程是如何工作的，并且在使用python计时器时遇到了困难。然而，当我执行两次threading.timer.start()时，我仍然得到RuntimeError: threads can only be started once。有没...

问Python threading.timer -每'n‘秒重复一次函数
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python threading.timer -每'n‘秒重复一次函数EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python threading.timer -每'n‘秒重复一次函数
EN