Python: Comment faire pour casser le traitement de tableau (en utilisant plusieurs fonctions en file d'attente) en blocs chronométrés (600ms)

Question

Je me demandais quelle serait la meilleure approche pour diviser le traitement de la matrice en utilisant plusieurs fonctions en file d'attente en petits morceaux? Donc, disons que j'ai un tableau multidimensionnel, et que je veux exécuter une ou plusieurs fonctions dessus, mais seulement en petits morceaux chronométrés, disons 500ms chaque fois que je déclenche le traitement.

Quelle serait la meilleure approche?

Une façon je peux penser utilise le code psuedo

#get time 
#loop_marker: 
#if current function_to_run is None 
# pop function to run off queue store 
# 
#run function_to_run once 
#increment start_index (in array) for next time or set function_to_run to None if finished array 
#check time_diff 
#if time_diff < limit - time_diff (i.e. if we can run this function again before hitting the limit) 
# goto loop_marker 
#else 
# yield 

Il est évident que ce n'est pas très Pythonic. Donc des idées? Des moyens plus propres?

Je ne peux pas installer quoi que ce soit sur la machine de son traitement à part de Python 2.5

Answer 1

Vous pouvez configurer une file d'attente de fonctions pour exécuter comme un générateur qui produirait chaque cycle, ont alors une petite boucle qui ressemblait à ceci :

time_elapsed = 0 
for func in function_queue_generator: 
    if time_elapsed > time_limit: 
     yield 
     time_elapsed = 0 
    func() 

un tel générateur pourrait être mis en œuvre comme si, peut-être:

def run_func_on_args(input_arg_sets, func): 
    for argset in input_arg_sets: 
     yield lambda: func(argset) 

Il y a plusieurs façons possibles que vous pouvez créer un tel générateur; ce qui précède est juste un exemple simple. Vous pouvez créer des générateurs pour exécuter des fonctions sur des tableaux multidimensionnels, et cetera.