每 n 秒运行特定代码[重复]

问题描述：

有没有办法，例如，Hello World!每 n 秒打印一次？例如，程序将执行我拥有的任何代码，然后一旦过了 5 秒（使用time.sleep()），它就会执行该代码。不过，我会使用它来更新文件，而不是打印 Hello World。

例如：

startrepeat("print('Hello World')", .01) # Repeats print('Hello World') ever .01 seconds

for i in range(5):
    print(i)

>> Hello World!
>> 0
>> 1
>> 2
>> Hello World!
>> 3
>> Hello World!
>> 4

解决方案 1：

import threading

def printit():
  threading.Timer(5.0, printit).start()
  print "Hello, World!"

printit()

# continue with the rest of your code

https://docs.python.org/3/library/threading.html#timer-objects

解决方案 2：

我对这个问题的拙见，是对Alex Martelli 的回答的概括，使用 start() 和 stop() 控制：

from threading import Timer

class RepeatedTimer(object):
    def __init__(self, interval, function, *args, **kwargs):
        self._timer     = None
        self.interval   = interval
        self.function   = function
        self.args       = args
        self.kwargs     = kwargs
        self.is_running = False
        self.start()
    
    def _run(self):
        self.is_running = False
        self.start()
        self.function(*self.args, **self.kwargs)
    
    def start(self):
        if not self.is_running:
            self._timer = Timer(self.interval, self._run)
            self._timer.start()
            self.is_running = True
    
    def stop(self):
        self._timer.cancel()
        self.is_running = False

用法：

from time import sleep

def hello(name):
    print "Hello %s!" % name

print "starting..."
rt = RepeatedTimer(1, hello, "World") # it auto-starts, no need of rt.start()
try:
    sleep(5) # your long-running job goes here...
finally:
    rt.stop() # better in a try/finally block to make sure the program ends!

特征：

• 仅限标准库，无外部依赖

• start()`stop()`即使计时器已启动/停止，也可以安全地多次调用

• 被调用的函数可以有位置参数和命名参数

• 您可以随时更改interval，它将在下次运行后生效。args和kwargs也一样function！

解决方案 3：

避免精神分裂症发作并使用高级 Python 调度程序：

代码非常简单：

from apscheduler.scheduler import Scheduler

sched = Scheduler()
sched.start()

def some_job():
    print "Every 10 seconds"

sched.add_interval_job(some_job, seconds = 10)

....
sched.shutdown()

解决方案 4：

def update():
    import time
    while True:
        print 'Hello World!'
        time.sleep(5)

这将作为函数运行。这while True:将使它永远运行。如果需要，您可以随时将其从函数中取出。

解决方案 5：

这是一个与APScheduler 3.00+兼容的简单示例：

# note that there are many other schedulers available
from apscheduler.schedulers.background import BackgroundScheduler

sched = BackgroundScheduler()

def some_job():
    print('Every 10 seconds')

# seconds can be replaced with minutes, hours, or days
sched.add_job(some_job, 'interval', seconds=10)
sched.start()

...

sched.shutdown()

或者，您可以使用以下方法。与许多替代方案不同，此计时器将每n秒准确执行一次所需的代码（无论代码执行所需的时间是多少）。因此，如果您不能承受任何偏差，这是一个很好的选择。

import time
from threading import Event, Thread

class RepeatedTimer:

    """Repeat `function` every `interval` seconds."""

    def __init__(self, interval, function, *args, **kwargs):
        self.interval = interval
        self.function = function
        self.args = args
        self.kwargs = kwargs
        self.start = time.time()
        self.event = Event()
        self.thread = Thread(target=self._target)
        self.thread.start()

    def _target(self):
        while not self.event.wait(self._time):
            self.function(*self.args, **self.kwargs)

    @property
    def _time(self):
        return self.interval - ((time.time() - self.start) % self.interval)

    def stop(self):
        self.event.set()
        self.thread.join()


# start timer
timer = RepeatedTimer(10, print, 'Hello world')

# stop timer
timer.stop()

解决方案 6：

这是一个不会每秒创建新线程的版本n：

from threading import Event, Thread

def call_repeatedly(interval, func, *args):
    stopped = Event()
    def loop():
        while not stopped.wait(interval): # the first call is in `interval` secs
            func(*args)
    Thread(target=loop).start()    
    return stopped.set

该事件用于停止重复：

cancel_future_calls = call_repeatedly(5, print, "Hello, World")
# do something else here...
cancel_future_calls() # stop future calls

请参阅改进 setInterval python 的当前实现

解决方案 7：

您可以启动一个单独的线程，其唯一任务是计数 5 秒，更新文件，然后重复。您不会希望这个单独的线程干扰您的主线程。