Python Time Delays

If you want a function to be called after a while and not to stop your script you are inherently dealing with threaded code. If you want to set a function to be called and not to worry about it, you have to either explicitly use multi-threading – like em Mark Byers’s answr, or use a coding framework that has a main loop which takes care of function dispatching for you – like twisted, qt, gtk, pyglet, and so many others. Any of these would require you to rewrite your code so that it works from that framework’s main loop.

It is either that, or writing some main loop from event checking yourself on your code –
All in all, if the only thing you want is single function calls, threading.Timer is the way to do it. If you want to use these timed calls to actually loop the program as is usually done with javascript’s setTimeout, you are better of selecting one of the coding frameworks I listed above and refactoring your code to take advantage of it.

If the non-block feature is not needed, just use time.sleep(5) which will work anywhere and save your life.

Okey, not a perfect solution but i used the following since my job was simple enough:

counter_time = 0
while True:
   time.sleep(0.1)
   counter_time = counter_time + 0.1

Now you have time just use if to do something at spesific time. My code was running inside the while loop so this worked for me. You can do the same or use threading to run this infinite loop together with your own code.

The most simplest way to do this is using a function I made, setTimeout:

import asyncio

#The function to execute
import asyncio

async def setTimeout(fn, time):
    await asyncio.sleep(time)
    fn()

def function():
    print("hi")

asyncio.run(setTimeout(function, 1))

I am currently trying to work on setInterval, like repeated timeouts, but I got an error.

NEW POST:

I figured out a mimic for setTimeout and setInterval from JavaScript, but in Python.

With this class you can:

1. Set a timeout with an interval ID (through variable, not required).
2. Set an interval in the same wise as a timeout.
3. Set an interval with an ID, and then set a timeout that will cancel the interval in a given amount of time.
4. Set a timeout with an ID and cancel the timeout with another setTimeout.

I know it seems complex but I needed all the functionality it had just like in JavaScript. Note that you will need to pre-create a function and use the function name as a parameter (see code).

#If I'm not mistaken, I believe the only modules you need are time and threading. The rest were for something I'm working on.
import time
import math
import pygame
import threading
import ctypes
from sys import exit

#Functions
class Timer:
    def __init__(self):
        self.timers = {}
        self.timer_id = 0
    
    def setInterval(self, fn, time, *args):
        def interval_callback():
            fn(*args)
            if timer_id in self.timers:
                self.timers[timer_id] = threading.Timer(time/1000, interval_callback)
                self.timers[timer_id].start()

        timer_id = self.timer_id
        self.timer_id += 1
        self.timers[timer_id] = threading.Timer(time/1000, interval_callback)
        self.timers[timer_id].start()
        return timer_id

    def clearInterval(self, timer_id):
        if timer_id in self.timers:
            self.timers[timer_id].cancel()
            del self.timers[timer_id]

    def setTimeout(self, fn, delay, *args, **kwargs):
        def timer_callback():
            self.timers.pop(timer_id, None)
            fn(*args, **kwargs)
        
        timer_id = self.timer_id
        self.timer_id += 1
        t = threading.Timer(delay / 1000, timer_callback)
        self.timers[timer_id] = t
        t.start()
        return timer_id
    
    def clearTimeout(self, timer_id):
        t = self.timers.pop(timer_id, None)
        if t is not None:
            t.cancel()
t = Timer()

#Usage Example
lall = t.setInterval(print, 1000, "hi")
t.setTimeout(t.clearInterval, 3000, lall)

Hope this helps.