# python – What is the best way to repeatedly execute a function every x seconds?

## The Question :

336 people think this question is useful

I want to repeatedly execute a function in Python every 60 seconds forever (just like an NSTimer in Objective C). This code will run as a daemon and is effectively like calling the python script every minute using a cron, but without requiring that to be set up by the user.

In this question about a cron implemented in Python, the solution appears to effectively just sleep() for x seconds. I don’t need such advanced functionality so perhaps something like this would work

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



Are there any foreseeable problems with this code?

• A pedantic point, but may be critical, your code above code doesn’t execute every 60 seconds it puts a 60 second gap between executions. It only happens every 60 seconds if your executed code takes no time at all.
• also time.sleep(60) may return both earlier and later
• I am still wondering: Are there any foreseeable problems with this code?
• The “foreseeable problem” is you cannot expect 60 iterations per hour by just using time.sleep(60). So if you’re appending one item per iteration and keeping a list of set length… the average of that list will not represent a consistent “period” of time; so functions such as “moving average” can be referencing data points that are too old, which will distort your indication.
• @Banana Yes, you can expect any problems caused because your script is not executed EXACTLY every 60 seconds. For instance. I started doing something like this to split video streams and upload’em, and I ended up getting strems 5-10~ seconds longer because the media queue is buffering while I process data inside the loop. It depends on your data. If the function is some kind of simple watchdog thats warns you, for instance, when your disk is full, you should have no problems at all with this.If you’re checking a nuclear power plant warning alerts you may end up with a city completly blown up x

263 people think this answer is useful

If your program doesn’t have a event loop already, use the sched module, which implements a general purpose event scheduler.

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

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



If you’re already using an event loop library like asyncio, trio, tkinter, PyQt5, gobject, kivy, and many others – just schedule the task using your existing event loop library’s methods, instead.

215 people think this answer is useful

Lock your time loop to the system clock like this:

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



74 people think this answer is useful

If you want a non-blocking way to execute your function periodically, instead of a blocking infinite loop I’d use a threaded timer. This way your code can keep running and perform other tasks and still have your function called every n seconds. I use this technique a lot for printing progress info on long, CPU/Disk/Network intensive tasks.

Here’s the code I’ve posted in a similar question, with start() and stop() control:

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



Usage:

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!



Features:

• Standard library only, no external dependencies
• start() and stop() are safe to call multiple times even if the timer has already started/stopped
• function to be called can have positional and named arguments
• You can change interval anytime, it will be effective after next run. Same for args, kwargs and even function!

72 people think this answer is useful

You might want to consider Twisted which is a Python networking library that implements the Reactor Pattern.

from twisted.internet import task, reactor

timeout = 60.0 # Sixty seconds

def doWork():
#do work here
pass

l.start(timeout) # call every sixty seconds

reactor.run()



While “while True: sleep(60)” will probably work Twisted probably already implements many of the features that you will eventually need (daemonization, logging or exception handling as pointed out by bobince) and will probably be a more robust solution

36 people think this answer is useful

The easier way I believe to be:

import time

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

while True:
executeSomething()



This way your code is executed, then it waits 60 seconds then it executes again, waits, execute, etc… No need to complicate things 😀

26 people think this answer is useful
import time, traceback

next_time = time.time() + delay
while True:
time.sleep(max(0, next_time - time.time()))
try:
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)



If you want to do this without blocking your remaining code, you can use this to let it run in its own thread:

import threading



This solution combines several features rarely found combined in the other solutions:

• Exception handling: As far as possible on this level, exceptions are handled properly, i. e. get logged for debugging purposes without aborting our program.
• No chaining: The common chain-like implementation (for scheduling the next event) you find in many answers is brittle in the aspect that if anything goes wrong within the scheduling mechanism (threading.Timer or whatever), this will terminate the chain. No further executions will happen then, even if the reason of the problem is already fixed. A simple loop and waiting with a simple sleep() is much more robust in comparison.
• No drift: My solution keeps an exact track of the times it is supposed to run at. There is no drift depending on the execution time (as in many other solutions).
• Skipping: My solution will skip tasks if one execution took too much time (e. g. do X every five seconds, but X took 6 seconds). This is the standard cron behavior (and for a good reason). Many other solutions then simply execute the task several times in a row without any delay. For most cases (e. g. cleanup tasks) this is not wished. If it is wished, simply use next_time += delay instead.

26 people think this answer is useful

Here’s an update to the code from MestreLion that avoids drifiting over time.

The RepeatedTimer class here calls the given function every “interval” seconds as requested by the OP; the schedule doesn’t depend on how long the function takes to execute. I like this solution since it doesn’t have external library dependencies; this is just pure 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



Sample usage (copied from MestreLion’s answer):

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!



5 people think this answer is useful

The main difference between that and cron is that an exception will kill the daemon for good. You might want to wrap with an exception catcher and logger.

5 people think this answer is useful

I faced a similar problem some time back. May be http://cronus.readthedocs.org might help?

For v0.2, the following snippet works

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



5 people think this answer is useful

I ended up using the schedule module. The API is nice.

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)



3 people think this answer is useful

import time
t=time.time()

while True:
if time.time()-t>10:
t=time.time()



1 people think this answer is useful

I use Tkinter after() method, which doesn’t “steal the game” (like the sched module that was presented earlier), i.e. it allows other things to run in parallel:

import Tkinter

def do_something1():
global n1
n1 += 1
if n1 == 6: # (Optional condition)
print "* do_something1() is done *"; return
# ...
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
# ...
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() and do_something2() can run in parallel and in whatever interval speed. Here, the 2nd one will be executed twice as fast.Note also that I have used a simple counter as a condition to terminate either function. You can use whatever other contition you like or none if you what a function to run until the program terminates (e.g. a clock).

1 people think this answer is useful

Here’s an adapted version to the code from MestreLion. In addition to the original function, this code:

1) add first_interval used to fire the timer at a specific time(caller need to calculate the first_interval and pass in)

2) solve a race-condition in original code. In the original code, if control thread failed to cancel the running timer(“Stop the timer, and cancel the execution of the timer’s action. This will only work if the timer is still in its waiting stage.” quoted from https://docs.python.org/2/library/threading.html), the timer will run endlessly.

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



0 people think this answer is useful

I use this to cause 60 events per hour with most events occurring at the same number of seconds after the whole minute:

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()



Depending upon actual conditions you might get ticks of length:

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



but at the end of 60 minutes you’ll have 60 ticks; and most of them will occur at the correct offset to the minute you prefer.

On my system I get typical drift of < 1/20th of a second until need for correction arises.

The advantage of this method is resolution of clock drift; which can cause issues if you’re doing things like appending one item per tick and you expect 60 items appended per hour. Failure to account for drift can cause secondary indications like moving averages to consider data too deep into the past resulting in faulty output.

0 people think this answer is useful

e.g., Display current local time

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



0 people think this answer is useful
    ''' tracking number of times it prints'''

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

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



0 people think this answer is useful

Here is another solution without using any extra libaries.

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()



0 people think this answer is useful

This seems much simpler than accepted solution – does it have shortcomings I’m not considering? Came here looking for some dead-simple copy pasta.

import threading, time

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



Which asynchronously outputs.

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



This does have drift. If the task being run takes appreciable amount of time, then the interval becomes 2 seconds + task time, so if you need precise scheduling then this is not for you.**

Note the daemon=True flag means this thread won’t block the app from shutting down. For example, had issue where pytest would hang indefinitely after running tests waiting for this thead to cease.

0 people think this answer is useful

Alternative flexibility solution is 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()



Also, apscheduler provides so many schedulers as follow.

• BlockingScheduler: use when the scheduler is the only thing running in your process

• BackgroundScheduler: use when you’re not using any of the frameworks below, and want the scheduler to run in the background inside your application

• AsyncIOScheduler: use if your application uses the asyncio module

• GeventScheduler: use if your application uses gevent