title: Are nested functions faster than global functions in Python?
body: <p>I prefer using nested functions instead of methods or global functions in Python whenever possible. So I decided to test their performance because it seams that when you define a function in another function there will be an overhead for the definition of the inner function in each call of the outer function.  </p>
  
  <p>At best I was hoping for the global function to be just slightly faster, but surprisingly the nested function was faster. Does anyone have any idea why?  </p>
  
  <p>This is my code:</p>
  
  <pre><code>from time import clock
  
  def a(n):
      return n + 1
  
  def b1(loopcount):
      return sum([a(n) for n in range(loopcount)])
  
  def b2(loopcount):
      def a(n):
          return n + 1
      return sum([a(n) for n in range(loopcount)])
  
  powers = [5, 6, 7]
  b1times = []
  b2times = []
  print "   ", "".join(["{:^10d}".format(n) for n in powers])    
  for i in range(5):
      for power in powers:
          t = clock()
          b1(10**power)
          b1times.append(clock() - t)
      for power in powers:
          t = clock()
          b2(10**power)
          b2times.append(clock() - t)
      print "b1:", "".join(["{:^10.5f}".format(n) for n in b1times])
      print "b2:", "".join(["{:^10.5f}".format(n) for n in b2times])
      print ""
      b1times = []
      b2times = [] 
  </code></pre>
  
  <p>And this is the result on my computer:  </p>
  
  <pre><code>        5         6         7
  b1:  0.08200   0.82773   8.47946
  b2:  0.06914   0.79637   8.18571
  
  b1:  0.07332   0.82139   8.68262
  b2:  0.06547   0.82088   8.19606
  
  b1:  0.07963   0.82625   9.65037
  b2:  0.06617   0.82027   8.21412
  
  b1:  0.07630   0.82112   8.49082
  b2:  0.06541   0.80686   8.20532
  
  b1:  0.12328   0.87034   8.42964
  b2:  0.07059   0.79717   8.24620
  </code></pre>
  
  <p><strong>UPDATE:</strong> using  @Janne Karila's comment  </p>
  
  <p>Now that I'm calling b1 and b2 more, b1 becomes faster. So as @Kos and @Pavel Anossov said in their answers a few factors affect the speed here and you can't make a general statement.<br>
  Thanks everyone!</p>
  
  <pre><code>from time import *
  
  def a1(n):
      return n + 1
  
  def b1(n):
      return a1(n)
  
  def b2(n):
      def a2():
          return n + 1
      return a2()
  
  powers = [4, 5, 6]
  b1times = []
  b2times = []
  print "   ", "".join(["{:^10d}".format(n) for n in powers])    
  for i in range(5):
      for power in powers:
          t = clock()
          sum([b1(n) for n in range(10**power)])
          b1times.append(clock() - t)
      for power in powers:
          t = clock()
          sum([b2(n) for n in range(10**power)])
          b2times.append(clock() - t)
      print "b1:", "".join(["{:^10.5f}".format(n) for n in b1times])
      print "b2:", "".join(["{:^10.5f}".format(n) for n in b2times])
      print ""
      b1times = []
      b2times = [] 
  </code></pre>