Is it possible to forward-declare a function in Python

Question

Is it possible to forward-declare a function in Python   I want to sort a list using my own cmp function before it is declared     print   n  join  str bla  for bla in sorted mylist  cmp   cmp configs      I ve organized my code to put the definition of cmp configs method after the invocation   It fails with this error   NameError  name  cmp configs  is not defined   Is there any way to  declare  cmp configs method before it s used   It would make my code look cleaner   I assume that some people will be tempted to tell me that I should just reorganize my code so that I don t have this problem   However  there are cases when this is probably unavoidable  for instance when implementing some forms of recursion   If you don t like this example  assume that I have a case in which it s really necessary to forward declare a function   Consider this case where forward-declaring a function would be necessary in Python   def spam        if end condition            return end result       else          return eggs    def eggs        if end condition            return end result       else          return spam     Where end condition and end result have been previously defined   Is the only solution to reorganize the code and always put definitions before invocations

User · Answer

TL DR  Python does not need forward declarations   Simply put your function calls inside function def definitions  and you ll be fine  def foo count       print  quot foo  quot  str count       if count gt 0           bar count-1   def bar count       print  quot bar  quot  str count       if count gt 0           foo count-1   foo 3  print  quot Finished  quot    recursive function definitions  perfectly successfully gives  foo 3 bar 2 foo 1 bar 0 Finished   However  bug 13   def bug count       print  quot bug never runs  quot  str count    print  quot Does not print this  quot    breaks at the top-level invocation of a function that hasn t been defined yet  and gives  Traceback  most recent call last     File  quot   test1 py quot   line 1  in  lt module gt      bug 13  NameError  name  bug  is not defined  Python is an interpreted language  like Lisp  It has no type checking  only run-time function invocations  which succeed if the function name has been bound and fail if it s unbound  Critically  a function def definition does not execute any of the funcalls inside its lines  it simply declares what the function body is going to consist of   Again  it doesn t even do type checking   So we can do this  def uncalled        wild eyed undefined function       print  quot I m not invoked  quot    print  quot Only run this one line  quot    and it runs perfectly fine      with output Only run this one line   The key is the difference between definitions and invocations  The interpreter executes everything that comes in at the top level  which means it tries to invoke it   If it s not inside a definition  Your code is running into trouble because you attempted to invoke a function  at the top level in this case  before it was bound  The solution is to put your non-top-level function invocations inside a function definition  then call that function sometime much later  The business about  quot if    main    quot  is an idiom based on this principle  but you have to understand why  instead of simply blindly following it  There are certainly much more advanced topics concerning lambda functions and rebinding function names dynamically  but these are not what the OP was asking for   In addition  they can be solved using these same principles    1  defs define a function  they do not invoke their lines   2  you get in trouble when you invoke a function symbol that s unbound

User · Answer

What you can do is to wrap the invocation into a function of its own   So that  foo    def foo        print  Hi     will break  but  def bar        foo    def foo        print  Hi    bar     will be working properly   General rule in Python is not that function should be defined higher in the code  as in Pascal   but that it should be defined before its usage   Hope that helps

User · Answer

Sometimes an algorithm is easiest to understand top-down  starting with the overall structure and drilling down into the details   You can do so without forward declarations   def main      make omelet     eat    def make omelet      break eggs     whisk     fry    def break eggs      for egg in carton      break egg          main

User · Answer

just reorganize my code so that I don t have this problem    Correct   Easy to do   Always works   You can always provide the function prior to it s reference    However  there are cases when this is probably unavoidable  for instance when implementing some forms of recursion   Can t see how that s even remotely possible   Please provide an example of a place where you cannot define the function prior to it s use

User · Answer

Yes  we can check this   Input  print lyrics    def print lyrics         print  I m a lumberjack  and I m okay        print  I sleep all night and I work all day     def repeat lyrics        print lyrics       print lyrics   repeat lyrics     Output  I m a lumberjack  and I m okay  I sleep all night and I work all day  I m a lumberjack  and I m okay  I sleep all night and I work all day  I m a lumberjack  and I m okay  I sleep all night and I work all day    As BJ Homer mentioned over above comments  A general rule in Python is not that function should be defined higher in the code  as in Pascal   but that it should be defined before its usage   Hope that helps

User · Answer

There is no such thing in python like forward declaration  You just have to make sure that your function is declared before it is needed  Note that the body of a function isn t interpreted until the function is executed   Consider the following example   def a       b     won t be resolved until a is invoked   def b        print  hello   a     here b is already defined so this line won t fail    You can think that a body of a function is just another script that will be interpreted once you call the function

User · Answer

declare a fake function  prototype  with no body def foo    pass  def bar          use the prototype however you see fit     print foo     world       define the actual function  overwriting the prototype  def foo        return  Hello    bar     Output   Hello  world

User · Answer

I apologize for reviving this thread  but there was a strategy not discussed here which may be applicable   Using reflection it is possible to do something akin to forward declaration  For instance lets say you have a section of code that looks like this     We want to call a function called  foo   but it hasn t been defined yet  function name    foo    Calling at this point would produce an error    Here is the definition def foo        bar      Note that at this point the function is defined       Time for some reflection    globals   function name      So in this way we have determined what function we want to call before it is actually defined  effectively a forward declaration  In python the statement globals   function name    is the same as foo   if function name    foo  for the reasons discussed above  since python must lookup each function before calling it  If one were to use the timeit module to see how these two statements compare  they have the exact same computational cost   Of course the example here is very useless  but if one were to have a complex structure which needed to execute a function  but must be declared before  or structurally it makes little sense to have it afterwards   one can just store a string and try to call the function later

User · Answer

No  I don t believe there is any way to forward-declare a function in Python   Imagine you are the Python interpreter  When you get to the line   print   n  join  str bla  for bla in sorted mylist  cmp   cmp configs      either you know what cmp configs is or you don t  In order to proceed  you have to know cmp configs  It doesn t matter if there is recursion

User · Answer

You can t forward-declare a function in Python  If you have logic executing before you ve defined functions  you ve probably got a problem anyways  Put your action in an if   name         main    at the end of your script  by executing a function you name  main  if it s non-trivial  and your code will be more modular and you ll be able to use it as a module if you ever need to   Also  replace that list comprehension with a generator express  i e   print   n  join str bla  for bla in sorted mylist  cmp cmp configs     Also  don t use cmp  which is deprecated  Use key and provide a less-than function

User · Answer

One way is to create a handler function  Define the handler early on  and put the handler below all the methods you need to call    Then when you invoke the handler method to call your functions  they will always be available   The handler could take an argument nameOfMethodToCall   Then uses a bunch of if statements to call the right method   This would solve your issue   def foo        print  foo        take input     nextAction input  What would you like to do next         return nextAction  def bar        print  bar       nextAction input  What would you like to do next         return nextAction  def handler action       if action   foo            nextAction   foo       elif action   bar            nextAction   bar       else          print  You entered invalid input  defaulting to bar           nextAction    bar      return nextAction  nextAction input  What would you like to do next      while 1      nextAction   handler nextAction

User · Answer

Now wait a minute   When your module reaches the print statement in your example  before cmp configs has been defined  what exactly is it that you expect it to do   If your posting of a question using print is really trying to represent something like this   fn   lambda mylist   n  join  str bla                           for bla in sorted mylist  cmp   cmp configs      then there is no requirement to define cmp configs before executing this statement  just define it later in the code and all will be well   Now if you are trying to reference cmp configs as a default value of an argument to the lambda  then this is a different story   fn   lambda mylist cmp configs cmp configs           n  join  str bla  for bla in sorted mylist  cmp   cmp configs      Now you need a cmp configs variable defined before you reach this line      EDIT - this next part turns out not to be correct  since the default argument value will get assigned when the function is compiled  and that value will be used even if you change the value of cmp configs later    Fortunately  Python being so type-accommodating as it is  does not care what you define as cmp configs  so you could just preface with this statement   cmp configs   None   And the compiler will be happy   Just be sure to declare the real cmp configs before you ever invoke fn

User · Answer

Import the file itself  Assuming the file is called test py   import test  if   name       main         test func   else      def func            print  Func worked

User · Answer

If the call to cmp configs is inside its own function definition  you should be fine  I ll give an example   def a      b      b   hasn t been defined yet  but that s fine because at this point  we re not          actually calling it  We re just defining what should happen when a   is called   a      This call fails  because b   hasn t been defined yet          and thus trying to run a   fails   def b      print  hi   a      This call succeeds because everything has been defined    In general  putting your code inside functions  such as main    will resolve your problem  just call main   at the end of the file

User · Answer

If you kick-start your script through the following   if   name       main        main     then you probably do not have to worry about things like  forward declaration    You see  the interpreter would go loading up all your functions and then start your main   function   Of course  make sure you have all the imports correct too  -   Come to think of it  I ve never heard such a thing as  forward declaration  in python    but then again  I might be wrong  -

User · Answer

Python does not support forward declarations  but common workaround for this is use of the the following condition at the end of your script code  if   name         main     main    With this it will read entire file first and then evaluate condition and call main   function which will be able to call any forward declared function as it already read the entire file first  This condition leverages special variable   name   which returns   main   value whenever we run Python code from current file  when code was imported as a module  then   name   returns module name

User · Answer

If you don t want to define a function before it s used  and defining it afterwards is impossible  what about defining it in some other module   Technically you still define it first  but it s clean   You could create a recursion like the following   def foo        bar    def bar        foo     Python s functions are anonymous just like values are anonymous  yet they can be bound to a name   In the above code  foo   does not call a function with the name foo  it calls a function that happens to be bound to the name foo at the point the call is made  It is possible to redefine foo somewhere else  and bar would then call the new function   Your problem cannot be solved because it s like asking to get a variable which has not been declared

[python] Is it possible to forward-declare a function in Python?

Examples related to python

Examples related to forward-declaration