Question

I’m writing a function in Python that I’m planning to run for 10 000 or more times for each script execution. The function currently contains 3 sub-functions but will probably contain 20 or more when the script is complete. I’m just wondering; Will declaring those functions over and over (since the parent function will be run thousands of times) have a recurring performance cost, or is that optimised and not an issue?

Would separating all those sub-functions into a class help with performance?

(I intend to test this and post the results here if nobody knows the answer on the top of their heads.)

Answer 1

The performance impact of a function definition is negligible and comparable to defining a local variable.

The body of the function is compiled only once, all that you end up with during execution of the code-block is loading the compiled block (LOAD_CONST), and the result of the MAKE FUNCTION byte code is then stored in a local variable:

>>> import dis
>>> def foo():
...     def bar():
...         pass
...     print 'boo!'
... 
>>> dis.dis(foo)
  2           0 LOAD_CONST               1 (<code object bar at 0x106c447b0, file "<stdin>", line 2>)
              3 MAKE_FUNCTION            0
              6 STORE_FAST               0 (bar)

  4           9 LOAD_CONST               2 ('boo!')
             12 PRINT_ITEM          
             13 PRINT_NEWLINE       
             14 LOAD_CONST               0 (None)
             17 RETURN_VALUE        

Now, if you call that function containing nested functions thousands of times, you do notice a performance impact for that MAKE_FUNCTION operation:

>>> import timeit
>>> def nonlocal(): pass
... 
>>> def callnonlocal(): nonlocal()
... 
>>> def calllocal():
...     def localf(): pass
...     localf()
... 
>>> timeit.timeit('callnonlocal()', 'from __main__ import callnonlocal')
0.39106082916259766
>>> timeit.timeit('calllocal()', 'from __main__ import calllocal')
0.4878239631652832

Do note that that difference will get smaller the more actual code you put into your functions though. The above examples are very contrived and focus solely on the impact of MAKE_FUNCTION byte code on execution times.

Better optimize for readability and maintainability first.