Python: Alternando funciones cada x minutos

Question

dicen que si tengo cuatro funciones de la siguiente manera:

def foo(): 
    subprocess.Popen('start /B someprogramA.exe', shell=True) 

def bar(): 
    subprocess.Popen('start /B someprogramB.exe', shell=True) 

def foo_kill(): 
    subprocess.Popen('taskkill /IM someprogramA.exe') 

def bar_kill(): 
    subprocess.Popen('taskkill /IM someprogramB.exe') 

Como puedo foo y bar funciones alternativas para ejecutarse cada, digamos 30 minutos? Significado: 1st 30mins - ejecuta foo, 2nd 30mins - ejecuta bar, 3rd 30mins - ejecuta foo, y así sucesivamente. Cada nueva ejecución debería 'matar' al hilo/func anterior.

Tengo un temporizador de cuenta atrás, pero no estoy seguro de cómo 'alternar' las funciones.

class Timer(threading.Thread): 
    def __init__(self, minutes): 
     self.runTime = minutes 
     threading.Thread.__init__(self) 


class CountDownTimer(Timer): 
    def run(self): 
     counter = self.runTime 
     for sec in range(self.runTime): 
      #do something   
      time.sleep(60) #editted from 1800 to 60 - sleeps for a minute 
      counter -= 1 

timeout=30 
c=CountDownTimer(timeout) 
c.start() 

EDITAR: Mi solución con entradas de Nicholas Knight ...

import threading 
import subprocess 
import time 

timeout=2 #alternate delay gap in minutes 

def foo(): 
    subprocess.Popen('start /B notepad.exe', shell=True) 

def bar(): 
    subprocess.Popen('start /B calc.exe', shell=True) 

def foo_kill(): 
    subprocess.Popen('taskkill /IM notepad.exe') 

def bar_kill(): 
    subprocess.Popen('taskkill /IM calc.exe') 


class Alternator(threading.Thread): 
    def __init__(self, timeout): 
     self.delay_mins = timeout 
     self.functions = [(foo, foo_kill), (bar, bar_kill)] 
     threading.Thread.__init__(self) 

    def run(self): 
     while True: 
      for f, kf in self.functions: 
       f() 
       time.sleep(self.delay_mins*60) 
       kf() 

a=Alternator(timeout) 
a.start() 

funciona bien.

Answer 1

Estás complicar esto.

while True: 
    foo() 
    time.sleep(1800) 
    foo_kill() 
    bar() 
    time.sleep(1800) 
    bar_kill() 

O si desea agregar fácilmente más tarde funciones:

functions = [(foo, foo_kill), (bar, bar_kill), ] # Just append more as needed 
while True: 
    for f, kf in functions: 
     f() 
     time.sleep(1800) 
     kf() 

Answer 2

Use una variable para registrar qué función ejecutó la última vez. Cuando el temporizador se dispara, ejecute la otra función y actualice la variable.

Answer 3

Recuerde que las funciones son objetos de primera clase en Python. ¡Eso significa que puedes almacenarlos en variables y contenedores! Una forma de hacerlo sería:

funcs = [(foo, foo_kill), (bar, bar_kill)] 

def run(self): 
    counter = self.runTime 
    for sec in range(self.runTime): 
     runner, killer = funcs[counter % 2] # the index alternates between 0 and 1 
     runner() # do something 
     time.sleep(1800) 
     killer() # kill something 
     counter -= 1 

Answer 4

import itertools, time 

# make sure the function are in the order you want to run them in 
# and grouped by the ones that you want to run together 
funcs = ((bar_kill, foo), (foo_kill, foo)) 

for func_killer, func in itertools.cycle(funcs) 
    func_killer() 
    func() 
    time.sleep(30 * 60) # pause for 30 minutes 

función puede ser almacenada en las listas de pitones, y se puede repetir utilizando un bucle for.

itertools es un módulo para manipular iterable como listas. Aquí usamos cycle para hacer un ciclo infinito que procesará las funciones en la lista funcs una y otra vez.