每x秒重复执行一个函数的最佳方法是什么？

我想永远每60秒重复执行一次Python中的函数（就像Objective C中的NSTimer一样）。这段代码将作为守护程序运行，实际上就像使用cron每一分钟调用python脚本一样，但是不需要用户设置。

在有关使用Python实现的cron的问题中，该解决方案似乎实际上只是将sleep（）停留了x秒。我不需要这种高级功能，所以也许这样的事情会起作用

while True:
    # Code executed here
    time.sleep(60)

此代码是否存在任何可预见的问题？

如果您的程序还没有事件循环，请使用sched模块，该模块实现了通用事件调度程序。

import sched, time
s = sched.scheduler(time.time, time.sleep)
def do_something(sc): 
    print("Doing stuff...")
    # do your stuff
    s.enter(60, 1, do_something, (sc,))

s.enter(60, 1, do_something, (s,))
s.run()

如果你已经在使用一个事件循环库一样asyncio，trio，tkinter，PyQt5，gobject，kivy，和许多其他人-只是用您现有的事件循环库的方法安排任务，来代替。

只需将您的时间循环锁定到系统时钟即可。简单。

import time
starttime=time.time()
while True:
  print "tick"
  time.sleep(60.0 - ((time.time() - starttime) % 60.0))

您可能需要考虑Twisted，它是实现Reactor Pattern的Python网络库。

from twisted.internet import task, reactor

timeout = 60.0 # Sixty seconds

def doWork():
    #do work here
    pass

l = task.LoopingCall(doWork)
l.start(timeout) # call every sixty seconds

reactor.run()

虽然“ while True：sleep（60）”可能会起作用Twisted可能已经实现了您最终将需要的许多功能（bobince指出的守护进程，日志记录或异常处理），并且可能是一种更强大的解决方案

如果您希望采用非阻塞方式定期执行函数，而不是阻塞无限循环，我会使用线程计时器。这样，您的代码可以继续运行并执行其他任务，并且仍然每n秒调用一次函数。我经常使用这种技术来打印长时间的，CPU /磁盘/网络密集型任务的进度信息。

这是我在类似问题中发布的代码，其中包含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！

我认为更简单的方法是：

import time

def executeSomething():
    #code here
    time.sleep(60)

while True:
    executeSomething()

这样，您的代码将被执行，然后等待60秒，然后再次执行，然后等待执行，等等。。。

import time, traceback

def every(delay, task):
  next_time = time.time() + delay
  while True:
    time.sleep(max(0, next_time - time.time()))
    try:
      task()
    except Exception:
      traceback.print_exc()
      # in production code you might want to have this instead of course:
      # logger.exception("Problem while executing repetitive task.")
    # skip tasks if we are behind schedule:
    next_time += (time.time() - next_time) // delay * delay + delay

def foo():
  print("foo", time.time())

every(5, foo)

如果要执行此操作而又不阻塞其余代码，则可以使用它使它在自己的线程中运行：

import threading
threading.Thread(target=lambda: every(5, foo)).start()

该解决方案结合了其他解决方案中很少发现的几个功能：

• 异常处理：尽可能在此级别上正确处理异常，即在不中断程序的情况下记录日志以进行调试。
• 没有链接：在许多答案中发现的常见链式实现（用于安排下一个事件的安排）在以下方面是脆弱的：如果在安排机制内出现任何问题（threading.Timer或其他任何原因）出了问题，它将终止链。即使问题的原因已经解决，也不会再执行任何操作。与之sleep()相比，简单的循环和简单的等待要健壮得多。
• 无漂移：永无止境我的解决方案准确跟踪了预期运行时间。取决于执行时间，没有漂移（与许多其他解决方案一样）。
• 跳过：如果一次执行花费了太多时间（例如，每五秒钟执行X次，但是X花费6秒执行一次），我的解决方案将跳过任务。这是标准的cron行为（并且有充分的理由）。然后，许多其他解决方案只需连续执行几次任务即可，而不会出现任何延迟。对于大多数情况（例如清理任务），这是不希望的。如果是希望，简单地使用next_time += delay来代替。

这是对MestreLion的代码的更新，可以避免随着时间的推移而变坏。

在此，RepeatedTimer类按照OP的请求每隔“间隔”秒调用给定函数；时间表不取决于函数执行所需的时间。我喜欢此解决方案，因为它没有外部库依赖项；这只是纯python。

import threading 
import time

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.next_call = time.time()
    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.next_call += self.interval
      self._timer = threading.Timer(self.next_call - time.time(), self._run)
      self._timer.start()
      self.is_running = True

  def stop(self):
    self._timer.cancel()
    self.is_running = False

用法示例（从MestreLion的答案中复制）：

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!

不久前，我也遇到了类似的问题。可能是http://cronus.readthedocs.org可能有帮助？

对于v0.2，以下代码段有效

import cronus.beat as beat

beat.set_rate(2) # 2 Hz
while beat.true():
    # do some time consuming work here
    beat.sleep() # total loop duration would be 0.5 sec

那和cron之间的主要区别是，异常将永久杀死守护程序。您可能需要包装异常捕获器和记录器。

一个可能的答案：

import time
t=time.time()

while True:
    if time.time()-t>10:
        #run your task here
        t=time.time()

我最终使用了调度模块。该API很不错。

import schedule
import time

def job():
    print("I'm working...")

schedule.every(10).minutes.do(job)
schedule.every().hour.do(job)
schedule.every().day.at("10:30").do(job)
schedule.every(5).to(10).minutes.do(job)
schedule.every().monday.do(job)
schedule.every().wednesday.at("13:15").do(job)
schedule.every().minute.at(":17").do(job)

while True:
    schedule.run_pending()
    time.sleep(1)

我使用Tkinter after（）方法，它不会“窃取游戏”（就像前面介绍的sched模块一样），即它允许其他事情并行运行：

import Tkinter

def do_something1():
  global n1
  n1 += 1
  if n1 == 6: # (Optional condition)
    print "* do_something1() is done *"; return
  # Do your stuff here
  # ...
  print "do_something1() "+str(n1)
  tk.after(1000, do_something1)

def do_something2(): 
  global n2
  n2 += 1
  if n2 == 6: # (Optional condition)
    print "* do_something2() is done *"; return
  # Do your stuff here
  # ...
  print "do_something2() "+str(n2)
  tk.after(500, do_something2)

tk = Tkinter.Tk(); 
n1 = 0; n2 = 0
do_something1()
do_something2()
tk.mainloop()

do_something1()并do_something2()可以以任意速度间隔并行运行。在这里，第二个函数的执行速度是第二个函数的两倍。还要注意，我使用一个简单的计数器作为终止这两个函数的条件。您可以使用任何喜欢的其他条件，也可以不使用任何条件，直到在程序终止之前要运行什么功能（例如时钟）。

这是MestreLion的代码的改编版本。除了原始功能外，此代码：

1）添加用于在特定时间触发计时器的first_interval（调用者需要计算first_interval并传入）

2）解决原始代码中的竞争条件。在原始代码中，如果控制线程未能取消正在运行的计时器（“停止计时器，并取消执行计时器的操作。这仅在计时器仍处于等待阶段时才有效。”引自https：// docs.python.org/2/library/threading.html），计时器将无休止地运行。

class RepeatedTimer(object):
def __init__(self, first_interval, interval, func, *args, **kwargs):
    self.timer      = None
    self.first_interval = first_interval
    self.interval   = interval
    self.func   = func
    self.args       = args
    self.kwargs     = kwargs
    self.running = False
    self.is_started = False

def first_start(self):
    try:
        # no race-condition here because only control thread will call this method
        # if already started will not start again
        if not self.is_started:
            self.is_started = True
            self.timer = Timer(self.first_interval, self.run)
            self.running = True
            self.timer.start()
    except Exception as e:
        log_print(syslog.LOG_ERR, "timer first_start failed %s %s"%(e.message, traceback.format_exc()))
        raise

def run(self):
    # if not stopped start again
    if self.running:
        self.timer = Timer(self.interval, self.run)
        self.timer.start()
    self.func(*self.args, **self.kwargs)

def stop(self):
    # cancel current timer in case failed it's still OK
    # if already stopped doesn't matter to stop again
    if self.timer:
        self.timer.cancel()
    self.running = False

这似乎比公认的解决方案简单得多-是否有我没有考虑的缺点？来到这里寻找一些简单的复制面食，感到失望。

import threading, time

def print_every_n_seconds(n=2):
    while True:
        print(time.ctime())
        time.sleep(n)

thread = threading.Thread(target=print_every_n_seconds, daemon=True)
thread.start()

异步输出。

#Tue Oct 16 17:29:40 2018
#Tue Oct 16 17:29:42 2018
#Tue Oct 16 17:29:44 2018

从某种意义上说，它确实存在偏差，如果正在运行的任务花费大量时间，则间隔变为2秒+任务时间，因此，如果您需要精确的计划，那么这不适合您。

请注意，该daemon=True标志表示该线程不会阻止应用程序关闭。例如，有一个问题，pytest在运行测试等待该主题停止运行后，会无限期挂起。

我用它来每小时导致60个事件，而大多数事件在整分钟后的相同秒数内发生：

import math
import time
import random

TICK = 60 # one minute tick size
TICK_TIMING = 59 # execute on 59th second of the tick
TICK_MINIMUM = 30 # minimum catch up tick size when lagging

def set_timing():

    now = time.time()
    elapsed = now - info['begin']
    minutes = math.floor(elapsed/TICK)
    tick_elapsed = now - info['completion_time']
    if (info['tick']+1) > minutes:
        wait = max(0,(TICK_TIMING-(time.time() % TICK)))
        print ('standard wait: %.2f' % wait)
        time.sleep(wait)
    elif tick_elapsed < TICK_MINIMUM:
        wait = TICK_MINIMUM-tick_elapsed
        print ('minimum wait: %.2f' % wait)
        time.sleep(wait)
    else:
        print ('skip set_timing(); no wait')
    drift = ((time.time() - info['begin']) - info['tick']*TICK -
        TICK_TIMING + info['begin']%TICK)
    print ('drift: %.6f' % drift)

info['tick'] = 0
info['begin'] = time.time()
info['completion_time'] = info['begin'] - TICK

while 1:

    set_timing()

    print('hello world')

    #random real world event
    time.sleep(random.random()*TICK_MINIMUM)

    info['tick'] += 1
    info['completion_time'] = time.time()

根据实际情况，您可能会发现一些问题：

60,60,62,58,60,60,120,30,30,60,60,60,60,60...etc.

但在60分钟结束时，您将有60个滴答声；并且大多数会以您希望的分钟数正确偏移。

在我的系统上，我得到的典型漂移小于<1/20秒，直到需要校正为止。

这种方法的优点是可以解决时钟漂移问题。如果您正在做一些事情，例如每滴答声追加一项，而您希望每小时追加60项，则可能会引起问题。不能考虑漂移会导致诸如移动平均线之类的次要指示，以至于认为数据太过深了而导致输出错误。

例如，显示当前本地时间

import datetime
import glib
import logger

def get_local_time():
    current_time = datetime.datetime.now().strftime("%H:%M")
    logger.info("get_local_time(): %s",current_time)
    return str(current_time)

def display_local_time():
    logger.info("Current time is: %s", get_local_time())
    return True

# call every minute
glib.timeout_add(60*1000, display_local_time)

    ''' tracking number of times it prints'''
import threading

global timeInterval
count=0
def printit():
  threading.Timer(timeInterval, printit).start()
  print( "Hello, World!")
  global count
  count=count+1
  print(count)
printit

if __name__ == "__main__":
    timeInterval= int(input('Enter Time in Seconds:'))
    printit()

这是不使用任何额外库的另一种解决方案。

def delay_until(condition_fn, interval_in_sec, timeout_in_sec):
    """Delay using a boolean callable function.

    `condition_fn` is invoked every `interval_in_sec` until `timeout_in_sec`.
    It can break early if condition is met.

    Args:
        condition_fn     - a callable boolean function
        interval_in_sec  - wait time between calling `condition_fn`
        timeout_in_sec   - maximum time to run

    Returns: None
    """
    start = last_call = time.time()
    while time.time() - start < timeout_in_sec:
        if (time.time() - last_call) > interval_in_sec:
            if condition_fn() is True:
                break
            last_call = time.time()