Efficient way of having a function only execute once in a loop

Question

At the moment  I m doing stuff like the following  which is getting tedious   run once   0 while 1      if run once    0          myFunction           run once   1    I m guessing there is some more accepted way of handling this stuff   What I m looking for is having a function execute once  on demand  For example  at the press of a certain button  It is an interactive app which has a lot of user controlled switches  Having a junk variable for every switch  just for keeping track of whether it has been run or not  seemed kind of inefficient

User · Answer

A simple function you can reuse in many places in your code (based on the other answers here):

def firstrun(keyword, _keys=[]):
    """Returns True only the first time it's called with each keyword."""
    if keyword in _keys:
        return False
    else:
        _keys.append(keyword)
        return True

or equivalently (if you like to rely on other libraries):

from collections import defaultdict
from itertools import count
def firstrun(keyword, _keys=defaultdict(count)):
    """Returns True only the first time it's called with each keyword."""
    return not _keys[keyword].next()

Sample usage:

for i in range(20):
    if firstrun('house'):
        build_house() # runs only once
if firstrun(42): # True
    print 'This will print.'
if firstrun(42): # False
    print 'This will never print.'

User · Answer

I m assuming this is an action that you want to be performed at most one time  if some conditions are met  Since you won t always perform the action  you can t do it unconditionally outside the loop  Something like lazily retrieving some data  and caching it  if you get a request  but not retrieving it otherwise   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

User · Answer

I m not sure that I understood your problem  but I think you can divide loop  On the part of the function and the part without it and save the two loops

User · Answer

I ve taken a more flexible approach inspired by functools partial function   DO ONCE MEMORY       def do once id  func   args    kwargs       if id not in DO ONCE MEMORY          DO ONCE MEMORY append id          return func  args    kwargs      else          return None   With this approach you are able to have more complex and explicit interactions   do once  foobar   print   first try   do once  foo   print   first try   do once  bar   print   second try     first try    second try    The exciting part about this approach it can be used anywhere and does not require factories - it s just a small memory tracker

User · Answer

I would use a decorator on the function to handle keeping track of how many times it runs   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   Now my function will only run once  Other calls to it will return None  Just add an else clause to the if if you want it to return something else  From your example  it doesn t need to return anything ever   If you don t control the creation of the function  or the function needs to be used normally in other contexts  you can just apply the decorator manually as well   action   run once my function  while 1      if predicate          action     This will leave my function available for other uses   Finally  if you need to only run it once twice  then you can just do  action   run once my function  action     run once the first time  action has run   False action     run once the second time

User · Answer

You have all those  junk variables  outside of your mainline while True loop  To make the code easier to read those variables can be brought inside the loop  right next to where they are used  You can also set up a variable naming convention for these program control switches  So for example                                         already done checkpoint logic     try          ran this user request already done     except          this user request           ran this user request already done   1   Note that on the first execution of this code the variable ran this user request already done is not defined until after this user request   is called

User · Answer

Assuming there is some reason why myFunction   can t be called before the loop  from itertools import count for i in count        if i  0          myFunction

User · Answer

Another option is to set the func code code object for your function to be a code object for a function that does nothing  This should be done at the end of your function body   For example   def run once           Code for something you only want to execute once    run once func code    lambda None  func code   Here run once func code    lambda None  func code replaces your function s executable code with the code for lambda None  so all subsequent calls to run once   will do nothing   This technique is less flexible than the decorator approach suggested in the accepted answer  but may be more concise if you only have one function you want to run once

User · Answer

I ve thought of another   slightly unusual  but very effective   way to do this that doesn t require decorator functions or classes  Instead it just uses a mutable keyword argument  which ought to work in most versions of Python  Most of the time these are something to be avoided since normally you wouldn t want a default argument value to change from call-to-call   but that ability can be leveraged in this case and used as a cheap storage mechanism  Here s how that would work   def my function1  has run          if  has run  return     print  my function1 doing stuff        has run append 1   def my function2  has run          if  has run  return     print  my function2 doing some other stuff        has run append 1   for i in range 10       my function1       my function2    print  ----   my function1  has run        Force it to run    Output   my function1 doing stuff my function2 doing some other stuff ---- my function1 doing stuff   This could be simplified a little further by doing what  gnibbler suggested in his answer and using an iterator  which were introduced in Python 2 2    from itertools import count  def my function3  count count         if next  count   return     print  my function3 doing something    for i in range 10       my function3    print  ----   my function3  count count       Force it to run    Output   my function3 doing something ---- my function3 doing something

User · Answer

Here s an answer that doesn t involve reassignment of functions  yet still prevents the need for that ugly  is first  check     missing   is supported by Python 2 5 and above   def do once varname1        print  performing varname1      return  only done once for varname1  def do once varname2        print  performing varname2      return  only done once for varname2   class cdict dict       def   missing   self key           val self  do once   key            self key  val         return val  cache dict cdict do once varname1 do once varname1 do once varname2 do once varname2   if   name       main         print cache dict  varname1     causes 2 prints     print cache dict  varname2     causes 2 prints     print cache dict  varname1     just 1 print     print cache dict  varname2     just 1 print   Output   performing varname1 only done once for varname1 performing varname2 only done once for varname2 only done once for varname1 only done once for varname2

User · Answer

You can also use one of the standard library functools lru cache or functools cache decorators in front of the function  from functools import lru cache  lru cache def expensive function    return None https   docs python org 3 library functools html

User · Answer

One object-oriented approach and make your function a class  aka as a  functor   whose instances automatically keep track of whether they ve been run or not when each instance is created    Since your updated question indicates you may need many of them  I ve updated my answer to deal with that by using a class factory pattern  This is a bit unusual  and it may have been down-voted for that reason  although we ll never know for sure because they never left a comment   It could also be done with a metaclass  but it s not much simpler   def RunOnceFactory        class RunOnceBase object     abstract base class          shared state        shared state of all instances  borg pattern          has run   False         def   init   self   args    kwargs               self   dict     self  shared state             if not self has run                  self stuff done once  args    kwargs                  self has run   True     return RunOnceBase  if   name         main         class MyFunction1 RunOnceFactory             def stuff done once self   args    kwargs               print  MyFunction1 stuff done once   called        class MyFunction2 RunOnceFactory             def stuff done once self   args    kwargs               print  MyFunction2 stuff done once   called        for   in range 10           MyFunction1      will only call its stuff done once   method once         MyFunction2      ditto   Output   MyFunction1 stuff done once   called MyFunction2 stuff done once   called   Note  You could make a function class able to do stuff again by adding a reset   method to its subclass that reset the shared has run attribute  It s also possible to pass regular and keyword arguments to the stuff done once   method when the functor is created and the method is called  if desired   And  yes  it would be applicable given the information you added to your question

User · Answer

If the condition check needs to happen only once you are in the loop  having a flag signaling that you have already run the function helps  In this case you used a counter  a boolean variable would work just as fine   signal   False count   0  def callme          print  I am being called    while count  lt  2        if signal    False             callme            signal   True      count   1

User · Answer

Here s an explicit way to code this up  where the state of which functions have been called is kept locally  so global state is avoided   I don t much like the non-explicit forms suggested in other answers  it s too surprising to see f   and for this not to mean that f   gets called   This works by using dict pop which looks up a key in a dict  removes the key from the dict  and takes a default value to use in case the key isn t found   def do nothing  args   kwargs       pass    A list of all the functions you want to run just once  actions         my function      other function   actions   dict  action  action  for action in actions   while True      if some condition          actions pop my function  do nothing        if some other condition          actions pop other function  do nothing

User · Answer

If I understand the updated question correctly  something like this should work  def function1        print  function1 called   def function2        print  function2 called   def function3        print  function3 called   called functions   set   while True      n   raw input  choose a function  1 2 or 3        func     1   function1               2   function2               3   function3  get n       if func in called functions          print  That function has already been called      else          called functions add func          func

User · Answer

Depending on the situation  an alternative to the decorator could be the following   from itertools import chain  repeat  func iter   chain  myFunction    repeat lambda  args    kwds  None   while True      next func iter      The idea is based on iterators  which yield the function once  or using repeat muFunction  n  n-times   and then endlessly the lambda doing nothing   The main advantage is that you don t need a decorator which sometimes complicates things  here everything happens in a single  to my mind  readable line  The disadvantage is that you have an ugly next in your code   Performance wise there seems to be not much of a difference  on my machine both approaches have an overhead of around 130 ns

User · Answer

Run the function before the loop  Example   myFunction   while True        all the other code being executed in your loop   This is the obvious solution  If there s more than meets the eye  the solution may be a bit more complicated

User · Answer

There are many ways to do what you want  however  do note that it is quite possible that    as described in the question    you don t have to call the function inside the loop   If you insist in having the function call inside the loop  you can also do   needs to run  expensive function while 1              if needs to run  needs to run    needs to run  None

[python] Efficient way of having a function only execute once in a loop

Examples related to python