Python: encapsulation in frequently called function

Question

I have this Python 3 pseudo-code:

def f1():
    a, b, c, d, e, f = some_other_fn()
    if (condition):
        f2(a, b, c, d, e, f)

def f2(a, b, c, d, e, f):
    complex_set_of_operations_with(a, b, c, d, e, f)

for i in range(1000):
    f(1)

Now, I am kind of annoyed at the long signature and repetition in f2() and would like to encapsulate that into f1():

def f1():
    def f2():
        complex_set_of_operations_with(a, b, c, d, e, f)

    a, b, c, d, e, f = some_other_fn()
    if (condition):
        f2()

for i in range(1000):
    f(1)

Now, my question is: if I run f1() a thousand times, does the interpreter have to parse f2() a thousand times or is it smart enough to create a reusable reference?

why not def f2(*args): complex_set_of_operations_with(*args) — Chris_Rands
– Chris_Rands, Commented Feb 2, 2018 at 15:29
Do you call f2 recursively, or in more than one place in f1? If not, you could just drop f2 entirely and inline it's code into f1. — tobias_k
– tobias_k, Commented Feb 2, 2018 at 15:35
@Chris_Rands: I have to use a, b, c, d, e, and f individually different places within f2() and I find it more readable to have them declared explicitly. — user3758232
– user3758232, Commented Feb 2, 2018 at 16:51
@tobias_k I call it only in f1 that is also why I want to encapsulate it. I could inline it, but I like to keep the operational code separate from the conditions that trigger it. It's mostly a style and readability question—and admittedly, with some academic curiosity added. — user3758232
– user3758232, Commented Feb 2, 2018 at 16:53

plamut · Accepted Answer · 2018-02-02 15:52:39Z

5

Let's have a look (using Python 3.5 that I happen to have at hand). We will use the dis module to disassemble the function and inspect its bytecode:

>>> def f1():
...     def f2():
...         complex_set_of_operations_with(a, b, c, d, e, f)
...     a, b, c, d, e, f = some_other_fn()
...     if (condition):
...         f2()
... 
>>> import dis
>>> dis.dis(f1)
  2           0 LOAD_CLOSURE             0 (a)
              3 LOAD_CLOSURE             1 (b)
              6 LOAD_CLOSURE             2 (c)
              9 LOAD_CLOSURE             3 (d)
             12 LOAD_CLOSURE             4 (e)
             15 LOAD_CLOSURE             5 (f)
             18 BUILD_TUPLE              6
             21 LOAD_CONST               1 (<code object f2 at 0x7f5d58589e40, file "<stdin>", line 2>)
             24 LOAD_CONST               2 ('f1.<locals>.f2')
             27 MAKE_CLOSURE             0
             30 STORE_FAST               0 (f2)
             ...  # the rest is omitted for brevity

In runtime, the Python interpreter interprets these primitive bytecode instructions one by one. These instructions are explained in the documentation.

As the last four instructions from the example above suggest, Python indeed builds the internal function every time (and stores it under the name f2), but it appears to do so efficiently by loading a pre-compiled constant code object of f2 (the 21 LOAD_CONST) line, i.e. it does not compile the f2's body over and over again.

answered Feb 2, 2018 at 15:52

plamut

3,20610 gold badges32 silver badges44 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

user3758232 Over a year ago

Excellent insight. Thanks. I am also using 3.5 by the way, so this fits like a glove.

Nickpick · Accepted Answer · 2018-02-02 15:29:28Z

-2

Python evaluation is lazy. It will only be evaluated when it's actually needed.

https://swizec.com/blog/python-and-lazy-evaluation/swizec/5148

Lazy evaluation python

answered Feb 2, 2018 at 15:29

Nickpick

6,67720 gold badges72 silver badges137 bronze badges

1 Comment

tobias_k Over a year ago

Does this answer the question? OP was not asking whether f2 will be evaluated before f1 is being run, but whether it's evaluated again each time f1 runs. Also, both the blog post and the linked answer are about generators, which is something entirely different.

Collectives™ on Stack Overflow

Python: encapsulation in frequently called function

2 Answers 2

1 Comment

1 Comment

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

1 Comment

Your Answer

Sign up or log in

Post as a guest

Linked

Related