Is nested function a good approach when required by only one function

Question

Let s say that a function A is required only by function B  should A be defined inside B  Simple example  Two methods  one called from another  def method a arg       some data   method b arg   def method b arg       return some data  In Python we can declare def inside another def   So  if method b is required for and called only from method a  should I declare method b inside method a  like this   def method a arg            def method b arg           return some data      some data   method b arg   Or should I avoid doing this

User · Answer

It s actually fine to declare one function inside another one  This is specially useful creating decorators   However  as a rule of thumb  if the function is complex  more than 10 lines  it might be a better idea to declare it on the module level

User · Answer

You don t really gain much by doing this  in fact it slows method a down because it ll define and recompile the other function every time it s called  Given that  it would probably be better to just prefix the function name with underscore to indicate it s a private method -- i e   method b   I suppose you might want to do this if the nested function s definition varied each time for some reason  but that may indicate a flaw in your design  That said  there is a valid reason to do this to allow the nested function to use arguments that were passed to the outer function but not explicitly passed on to them  which sometimes occurs when writing function decorators  for example  It s what is being shown in the accepted answer although a decorator is not being defined or used   Update   Here s proof that nesting them is slower  using Python 3 6 1   although admittedly not by much in this trivial case   setup       class Test object       def separate self  arg           some data   self  method b arg       def  method b self  arg           return arg 1      def nested self  arg            def method b2 self  arg               return arg 1          some data   method b2 self  arg   obj   Test       from timeit import Timer print min Timer stmt  obj separate 42    setup setup  repeat        - gt  0 24479823284461724 print min Timer stmt  obj nested 42    setup setup  repeat          - gt  0 26553459700452575   Note I added some self arguments to your sample functions to make them more like real methods  although method b2 still isn t technically a method of the Test class   Also the nested function is actually called in that version  unlike yours

User · Answer

So in the end it is largely a question about how smart the python implementation is or is not  particularly in the case of the inner function not being a closure but simply an in function needed helper only    In clean understandable design having functions only where they are needed and not exposed elsewhere is good design whether they be embedded in a module  a class as a method  or inside another function or method   When done well they really improve the clarity of the code   And when the inner function is a closure that can also help with clarity quite a bit even if that function is not returned out of the containing function for use elsewhere    So I would say generally do use them but be aware of the possible performance hit when you actually are concerned about performance and only remove them if you do actual profiling that shows they best be removed    Do not do premature optimization of just using  inner functions BAD  throughout all python code you write   Please

User · Answer

A function inside of a function is commonly used for closures     There is a lot of contention over what exactly makes a closure a closure    Here s an example using the built-in sum    It defines start once and uses it from then on   def sum partial start       def sum start iterable           return sum iterable  start      return sum start   In use        gt  gt  gt  sum with 1   sum partial 1   gt  gt  gt  sum with 3   sum partial 3   gt  gt  gt    gt  gt  gt  sum with 1  lt function sum start at 0x7f3726e70b90 gt   gt  gt  gt  sum with 3  lt function sum start at 0x7f3726e70c08 gt   gt  gt  gt  sum with 1  1 2 3   7  gt  gt  gt  sum with 3  1 2 3   9   Built-in python closure  functools partial is an example of a closure   From the python docs  it s roughly equivalent to   def partial func   args    keywords       def newfunc  fargs    fkeywords           newkeywords   keywords copy           newkeywords update fkeywords          return func   args   fargs     newkeywords      newfunc func   func     newfunc args   args     newfunc keywords   keywords     return newfunc    Kudos to  user225312 below for the answer  I find this example easier to figure out  and hopefully will help answer  mango s comment

User · Answer

It s just a principle about exposure APIs   Using python  It s a good idea to avoid exposure API in outer space module or class   function is a good encapsulation place    It could be a good idea  when you ensure    inner function is ONLY used by outer function   insider function has a good name to explain its purpose because the code talks  code cannot directly understand by your colleagues or other code-reader     Even though  Abuse this technique may cause problems and implies a design flaw    Just from my exp  Maybe misunderstand your question

User · Answer

It s perfectly OK doing it that way  but unless you need to use a closure or return the function I d probably put in the module level  I imagine in the second code example you mean       some data   method b     not some data   method b   otherwise  some data will be the function   Having it at the module level will allow other functions to use method b   and if you re using something like Sphinx  and autodoc  for documentation  it will allow you to document method b as well   You also may want to consider just putting the functionality in two methods in a class if you re doing something that can be representable by an object   This contains logic well too if that s all you re looking for

User · Answer

I found this question because I wanted to pose a question why there is a performance impact if one uses nested functions  I ran tests for the following functions using Python 3 2 5 on a  Windows Notebook with a Quad Core 2 5 GHz Intel i5-2530M processor  def square0 x       return x x  def square1 x       def dummy y           return y y     return x x  def square2 x       def dummy1 y           return y y     def dummy2 y           return y y     return x x  def square5 x       def dummy1 y           return y y     def dummy2 y           return y y     def dummy3 y           return y y     def dummy4 y           return y y     def dummy5 y           return y y     return x x   I measured the following 20 times  also for square1  square2  and square5   s 0 for i in range 10  6       s  square0 i    and got the following results   gt  gt  gt   m   mean  s   standard deviation  m0   mean of first testcase  m-3s m 3s  is a 0 997 confidence interval if normal distributed  square  m     s       m m0   m-3s  m 3s   square0 0 387 0 01515 1 000  0 342 0 433  square1 0 460 0 01422 1 188  0 417 0 503  square2 0 552 0 01803 1 425  0 498 0 606  square5 0 766 0 01654 1 979  0 717 0 816   gt  gt  gt     square0 has no nested function  square1 has one nested function  square2 has two nested functions and square5 has five nested functions   The nested functions are only declared but not called     So if you have defined 5 nested funtions in a function that you don t call then the execution time of the function is twice of the function without a nested function  I think should be cautious when using nested functions   The Python file for the whole test that generates this output can be found at ideone

User · Answer

You can use it to avoid defining global variables  This gives you an alternative for other designs  3 designs presenting a solution to a problem   A  Using functions without globals  def calculate salary employee  list with all employees       x    calculate tax list with all employees         some other calculations done to x     pass      y     something       return y  def  calculate tax list with all employees       return 1 23456   return something   B  Using functions with globals   list with all employees   None  def calculate salary employee  list with all employees        global  list with all employees      list with all employees   list with all employees      x    calculate tax          some other calculations done to x     pass      y     something      return y  def  calculate tax        return 1 23456   return something based on the  list with all employees var   C  Using functions inside another function  def calculate salary employee  list with all employees        def  calculate tax            return 1 23456   return something based on the list with a--Lemployees var      x    calculate tax          some other calculations done to x     pass     y     something       return y   Solution C  allows to use variables in the scope of the outer function without having the need to declare them in the inner function  Might be useful in some situations

User · Answer

Function In function python  def Greater a b       if a gt b          return a     return b  def Greater new a b c d       return Greater Greater a b  Greater c d    print  Greater Number is  -  Greater new 212 33 11 999

User · Answer

Generally  no  do not define functions inside functions   Unless you have a really good reason  Which you don t    Why not    It prevents easy hooks for unit testing  You are unit testing  aren t you  It doesn t actually obfuscate it completely anyway  it s safer to assume nothing in python ever is  Use standard Python automagic code style guidelines to encapsulate methods instead  You will be needlessly recreating a function object for the identical code every single time you run the outer function  If your function is really that simple  you should be using a lambda expression instead    What is a really good reason to define functions inside functions   When what you actually want is a dingdang closure

User · Answer

Do something like   def some function        return some other function   def some other function        return 42    if you were to run some function   it would then run some other function   and returns 42   EDIT  I originally stated that you shouldn t define a function inside of another but it was pointed out that it is practical to do this sometimes

User · Answer

gt  gt  gt  def sum x  y           def do it                    return x   y         return do it       gt  gt  gt  a   sum 1  3   gt  gt  gt  a  lt function do it at 0xb772b304 gt   gt  gt  gt  a   4   Is this what you were looking for  It s called a closure

[python] Is nested function a good approach when required by only one function?

Examples related to python

Examples related to coding-style

Examples related to nested-function