How to make a function return after 5 seconds passed in Python?

Question

I want to write a function which will return after 5 seconds no matter what:

def myfunction():
    while passed_time < 5_seconds:
        do1()
        do2()
        do3()
        .
        .
    return

I mean, this function run for 5 seconds only, after 5 seconds, it should end, and continue with other function:

myfunction()
otherfunction()   ----> This should start 5 seconds after myfunction() is executed.

Best Regards

Answer 1

You can do:

def myfunction():
    start = time.time()
    while time.time() < start + 5:
        do1()
        do2()
        do3()

Note that this will stop after at least 5 seconds - if do1, do2, and do3 each take 3 seconds, then this function will take 9 seconds.

---

If you want to cut off myFunction between these calls, you can do:

def myfunction():
    todo = itertools.cycle([do1, do2, do3])
    start = time.time()
    while time.time() < start + 5:
        todo.next()()

This case would take 6s

Answer 2

If there is a chance that the execution time of your functions is longer than the interval between firing these functions, you'd have to start these functions in another thread or process.

Example with threading:

import time
import sys
from threading import Thread


def f1():
    print "yo!!"
    time.sleep(6)


def f2():
    print "boring."
    time.sleep(2)


if __name__ == "__main__":
    threads = []
    try:
        for f in [f1, f2]:
            t = Thread(target=f)
            t.start()
            threads.append(t)
            time.sleep(5)
    except KeyboardInterrupt:
        sys.exit(0)
    finally:
        [t.join() for t in threads]

I understood the question in the way that you do not necessarily need to kill/end one function after exactly 5 seconds. Your main goal is to fire up the functions with a 5 second interval. If you need to 'kill' the functions after a certain time, this won't be trivial using threads: Is there any way to kill a Thread in Python?

Answer 3

You can also do:

import time 
start=time.time()   

stuff={1:do1,2:do2,3:do3,...}
i=1

while time.time() <= start+5:
    stuff[i]()
    i+=1

Answer 4

From the way you've defined your problem, I think this is a good situation for using a generator based co-routine. That is, change myFunction to a generator that yields every time it has finished with a step of its processing (e.g. do1 or do2) and run it from a loop that checks the time.

Here's a simple implementation that repeatedly runs a single somework function, but you could easily call different functions, or even do work directly in the myFunction generator:

import time

def somework():
    print "Doing some work!"
    time.sleep(2)

def myFunction():
    try:
        print "Started myFunction()"
        yield somework()
        yield somework()
        yield somework()
        yield somework()
        yield somework()
        print "Done with myFunction()"
    except GeneratorExit:
        print "Exiting myFunction() early!"

def main():
    start = time.time()
    gen = myFunction()
    for _ in gen:
        if time.time() > start+5:
            gen.close();

There are some benefits to using this structure:

1. First off, myFunction gets to choose where it yields to the outer loop, so it won't get killed at an unexpected time. If it's manipulating some external data structure, you can ensure it always yields with everything in a consistent state.
2. Second, myFunction can yield intermediate values, if that is useful. The example code above yields None (since that's the return value from somework but you can change that easily. The main loop puts the latest yielded value in the _ variable (which is not used), but you can rename that variable and use its value in the timeout block if you want.
3. Finally, by catching the GeneratorExit exception, myFunction can run any cleanup code that it needs before it shuts down.