我想在Python中每60秒永久重复执行一个函数（就像Objective C中的NSTimer或JS中的setTimeout）。这段代码将作为守护进程运行，并且实际上类似于使用cron每分钟调用Python脚本，但不需要用户设置。
在关于Python实现cron的问题中，解决方案似乎只是使用sleep()睡眠x秒。我不需要这样高级的功能，因此可能类似下面的内容会起作用。
while True:
# Code executed here
time.sleep(60)
这段代码有没有可预见的问题？
如果你的程序还没有事件循环，请使用sched模块，它实现了一个通用的事件调度器。
import sched, time
def do_something(scheduler):
# schedule the next call first
scheduler.enter(60, 1, do_something, (scheduler,))
print("Doing stuff...")
# then do your stuff
my_scheduler = sched.scheduler(time.time, time.sleep)
my_scheduler.enter(60, 1, do_something, (my_scheduler,))
my_scheduler.run()
如果你已经在使用像 asyncio、trio、tkinter、PyQt5、gobject、kivy 等事件循环库 - 只需使用现有的事件循环库方法调度任务即可。
s.enter（...）移到函数开头以减少漂移。另外，sc的作用是什么？ - Solomon Ucko将你的时间循环锁定到系统时钟，像这样：
import time
starttime = time.monotonic()
while True:
print("tick")
time.sleep(60.0 - ((time.monotonic() - starttime) % 60.0))
x秒运行一次函数的答案。其余的在每次调用后会有x秒的延迟再执行该函数。 - jfsfrom time import time, sleep，因为它涉及到存在的含义 ;) - Willtime.sleep(60 - time.time() % 60)的效果很好。我已经把它用作 time.sleep(1200 - time.time() % 1200)，这正好给我记录了 :00 :20 :40 的日志，完全符合我的要求。 - TemporalWolfwhile keep_doing_it(): sleep(interval - timer() % interval)。
具体而言，每个迭代会因为sleep()和timer()精度以及循环执行需要的时间而稍微提前或推迟开始，但平均而言，迭代总是在间隔边界上发生（即使有些被跳过）。
相比之下，仅使用while keep_doing_it(): sleep(interval)则可能在多次迭代后积累误差。 - jfs如果你想以非阻塞的方式定期执行函数，而不是使用阻塞无限循环，我建议使用线程定时器。这样，你的代码可以继续运行并执行其他任务，同时仍然可以每隔 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！def _run(self) 中，我试图理解为什么您在调用 self.function() 之前先调用了 self.start()。您能详细说明一下吗？我认为通过先调用 start()，self.is_running 总是会是 False，因此我们总是会启动一个新线程。 - Rich Episcopox秒运行一次函数（即t=0，t=1x，t=2x，t=3x，...），而原始帖子中的示例代码在x秒间隔内运行一个函数。此外，如果interval比执行function所需的时间短，则此解决方案可能存在错误。在这种情况下，self._timer将在start函数中被覆盖。 - Rich Episcopo.start()之后调用.function()是为了在t=0时运行该函数。我认为如果function的执行时间比interval长，也不会有问题，但是代码可能存在一些竞争条件。 - MestreLioncron）。 - MestreLion你可能想考虑使用Twisted，它是一个实现反应器模式的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所指出的守护进程、日志记录或异常处理），并且可能是一个更强大的解决方案。
这是 MestreLion 的代码更新，它避免了随时间漂移。
这里的 RepeatedTimer 类每隔 "interval" 秒调用一次给定的函数，与函数执行所需的时间无关。我喜欢这个解决方案，因为它没有外部库依赖，这只是纯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!
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() 更加稳健。 next_time += delay 。我认为更简单的方式是：
import time
def executeSomething():
#code here
time.sleep(60)
while True:
executeSomething()
这种方式会让你的代码执行，等待60秒后再次执行，然后等待，执行，以此类推…… 不需要把事情弄复杂 :D
while True 循环中调用 time.sleep() ，像这样：def executeSomething(): print('还剩10秒') ； while True: executeSomething(); time.sleep(10)。 - Leonard Lepadatu我最终使用了schedule模块。这个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)
gevent.spawn()可以避免阻塞主线程。我通过调用一个处理所有调度器初始化的方法来实现这一点，效果非常好。 - eatmeimadanishschedule.every(MIN_BETWEEN_IMAGES).minutes.at(":00").do(run_function) 其中 MIN_BETWEEN_IMAGES 是分钟数，run_function 是需要运行的函数。 - Nicholas Kinar替代灵活性解决方案是Apscheduler。
pip install apscheduler
from apscheduler.schedulers.background import BlockingScheduler
def print_t():
pass
sched = BlockingScheduler()
sched.add_job(print_t, 'interval', seconds =60) #will do the print_t work for every 60 seconds
sched.start()
PytzUsageWarning 警告，要求用户迁移到新的时区提供程序，因为 pytz 已经被弃用，因为它不兼容 PEP 495。这有点遗憾。 - BubbleMasterimport cronus.beat as beat
beat.set_rate(2) # run twice per second
while beat.true():
# do some time consuming work here
beat.sleep() # total loop duration would be 0.5 sec
time.sleep(60)也可能会比预期的早或晚返回。 - jfs