Une façon efficace de faire en sorte qu'une fonction ne s'exécute qu'une fois dans une boucle.

Question

En ce moment, je fais des choses comme les suivantes, ce qui devient fastidieux :

run_once = 0
while 1:
    if run_once == 0:
        myFunction()
        run_once = 1:

Je suppose qu'il y a une manière plus acceptée de gérer ce genre de choses ?

Ce que je recherche, c'est qu'une fonction soit exécutée une fois, à la demande. Par exemple, en appuyant sur un certain bouton. Il s'agit d'une application interactive qui comporte de nombreux interrupteurs contrôlés par l'utilisateur. Avoir une variable junk pour chaque interrupteur, juste pour savoir s'il a été exécuté ou non, semblait inefficace.

Answer 1

J'utiliserais un décorateur sur la fonction pour gérer le suivi du nombre d'exécutions.

def run_once(f):
    def wrapper(*args, **kwargs):
        if not wrapper.has_run:
            wrapper.has_run = True
            return f(*args, **kwargs)
    wrapper.has_run = False
    return wrapper

@run_once
def my_function(foo, bar):
    return foo+bar

Maintenant my_function ne sera exécuté qu'une seule fois. Les autres appels à cette fonction renverront None . Il suffit d'ajouter un else à la clause if si vous voulez qu'il renvoie autre chose. Dans votre exemple, il n'a pas besoin de renvoyer quoi que ce soit.

Si vous ne contrôlez pas la création de la fonction, ou si la fonction doit être utilisée normalement dans d'autres contextes, vous pouvez simplement appliquer le décorateur manuellement aussi.

action = run_once(my_function)
while 1:
    if predicate:
        action()

Cela laissera my_function disponibles pour d'autres usages.

Enfin, si vous n'avez besoin de l'exécuter qu'une fois, deux fois, alors vous pouvez simplement faire

action = run_once(my_function)
action() # run once the first time

action.has_run = False
action() # run once the second time

Answer 2

Une autre option consiste à définir le func_code objet de code pour que votre fonction soit un objet de code pour une fonction qui ne fait rien. Cela doit être fait à la fin du corps de votre fonction.

Par exemple :

def run_once():  
   # Code for something you only want to execute once
   run_once.func_code = (lambda:None).func_code

Aquí run_once.func_code = (lambda:None).func_code remplace le code exécutable de votre fonction par le code de lambda:None, de sorte que tous les appels ultérieurs à run_once() ne fera rien.

Cette technique est moins souple que l'approche par décorateur suggérée dans le document intitulé réponse acceptée mais elle peut être plus concise si vous n'avez qu'une seule fonction à exécuter une fois.

Answer 3

Exécuter la fonction avant la boucle. Exemple :

myFunction()
while True:
    # all the other code being executed in your loop

C'est la solution évidente. S'il y a plus qu'il n'y paraît, la solution peut être un peu plus compliquée.

Answer 4

Je suppose qu'il s'agit d'une action qui ne doit être exécutée qu'une seule fois, si certaines conditions sont remplies. Puisque vous n'exécuterez pas toujours l'action, vous ne pouvez pas la faire sans condition en dehors de la boucle. C'est un peu comme si vous récupériez paresseusement certaines données (et les mettiez en cache) si vous recevez une demande, mais ne les récupériez pas autrement.

def do_something():
    [x() for x in expensive_operations]
    global action
    action = lambda : None

action = do_something
while True:
    # some sort of complex logic...
    if foo:
        action()

Answer 5

Il existe de nombreuses façons de faire ce que vous voulez ; cependant, notez qu'il est tout à fait possible que - comme décrit dans la question - vous n'ayez pas à appeler la fonction à l'intérieur de la boucle.

Si vous insistez pour que l'appel de la fonction se fasse à l'intérieur de la boucle, vous pouvez également le faire :

needs_to_run= expensive_function
while 1:
    …
    if needs_to_run: needs_to_run(); needs_to_run= None
    …