472,353 Members | 1,591 Online
Bytes | Software Development & Data Engineering Community
+ Post

Home Posts Topics Members FAQ

Join Bytes to post your question to a community of 472,353 software developers and data experts.

nested functions

I often make helper functions nested, like this:

def f():
def helper():
...
...

is it a good practice or not? What about performance of such
constructs?

--
Regards, Gregory.

Jun 14 '06 #1
9 2713
"Gregory Petrosyan" <gr***************@gmail.com> writes:
I often make helper functions nested, like this:

def f():
def helper():
...
...

is it a good practice or not?
You have my blessing. Used well, it makes for more readable code.
What about performance of such constructs?


What about it? Set up some examples maningful for your situation, with
and without such constructs, and use the profiler to find out.

--
\ "People demand freedom of speech to make up for the freedom of |
`\ thought which they avoid." -- Soren Aabye Kierkegaard |
_o__) (1813-1855) |
Ben Finney

Jun 15 '06 #2
Ben Finney wrote:
"Gregory Petrosyan" <gr***************@gmail.com> writes:
I often make helper functions nested, like this:

def f():
def helper():
...
...

is it a good practice or not?


You have my blessing. Used well, it makes for more readable code.


I'm not sure it's in general more readable; I typically use nested
functions for closures only, not helper functions, so I'd read the code
twice to check if it's a closure and if not why might have been defined
locally. I prefer to define helpers at the module level, often making
them 'private' by prepending their name with a single underscore.
What about performance of such constructs?


What about it? Set up some examples maningful for your situation, with
and without such constructs, and use the profiler to find out.


It shouldn't come as a surprise if it turns out to be slower, since the
nested function is redefined every time the outer is called. If you
actually call the outer function a lot, you'd better profile it.

George

Jun 15 '06 #3
George Sakkis wrote:
Ben Finney wrote:
"Gregory Petrosyan" <gr***************@gmail.com> writes:
> I often make helper functions nested, like this:
>
> def f():
> def helper():
> ...
> ...
>
> is it a good practice or not?


You have my blessing. Used well, it makes for more readable code.


I'm not sure it's in general more readable; I typically use nested
functions for closures only, not helper functions, so I'd read the code
twice to check if it's a closure and if not why might have been defined
locally. I prefer to define helpers at the module level, often making
them 'private' by prepending their name with a single underscore.
> What about performance of such constructs?


What about it? Set up some examples maningful for your situation, with
and without such constructs, and use the profiler to find out.


It shouldn't come as a surprise if it turns out to be slower, since the
nested function is redefined every time the outer is called.


That's right. However, if the outer function is only called a few times
and the nested function is called a lot, the locals lookup for the
function name is theoretically faster than the globals lookup. Also,
in methods you can use closures, so you don't have to pass, for example,
self to the inner function.

Georg
Jun 15 '06 #4
Georg Brandl wrote:
That's right. However, if the outer function is only called a few times
and the nested function is called a lot, the locals lookup for the
function name is theoretically faster than the globals lookup. Also,
in methods you can use closures, so you don't have to pass, for example,
self to the inner function.


If you are worried about the overhead of looking up the function name in
the local rather than global scope then you should also worry about the
overhead of accessing self through a closure rather than as a parameter.

As always in these cases, don't worry about it until you know definitely
(by timing) that performance is an issue in that part of your code, and
then time the different options and refuse the temptation to guess as you
will probably get it wrong. The relative times here will depend on a lot of
factors, such as how often you access the closure/parameter, and whether or
not there are other arguments to the function.

I frequently nest functions, but I do it in cases where I want to simplify
a function body and don't see any case for creating yet another generally
accessible method or function.

Some benefits of nested functions: you can use a function name which is
short by self-explanatory within the context of the outer function without
having to worry about it conflicting with other function/variable names.

The extracted functions are kept close to the place where they are used: a
small support function which is a few hundred lines away from where it
is used is more accident prone than one right next to the place it is used.
Also, if you later refactor out the main method the support functions will
disappear as well rather than lying around unused.

You can use closures, not because you have to, but because it simplifies
the calls and therefore keeps expressions simpler and easier to read.

Of course you can also mess things up totally by overdoing it.
Jun 15 '06 #5
George Sakkis wrote:
It shouldn't come as a surprise if it turns out to be slower, since the
nested function is redefined every time the outer is called.


except that it isn't, really: all that happens is that a new function object is created from
prebuilt parts, and assigned to a local variable. it's not slower than, say, a method call.

</F>

Jun 15 '06 #6
Fredrik Lundh wrote:
George Sakkis wrote:
It shouldn't come as a surprise if it turns out to be slower, since
the nested function is redefined every time the outer is called.


except that it isn't, really: all that happens is that a new function
object is created from prebuilt parts, and assigned to a local
variable. it's not slower than, say, a method call.

It looks to be somewhat faster than a method call:

C:\temp>\python24\lib\timeit.py -s "import t" "t.testMethod(t.instance,
42)"
1000 loops, best of 3: 1.58 msec per loop

C:\temp>\python24\lib\timeit.py -s "import t" "t.testMethod2(t.instance,
42)"
100 loops, best of 3: 1.61 msec per loop

C:\temp>\python24\lib\timeit.py -s "import t" "t.testNested(t.instance,
42)"
1000 loops, best of 3: 1.06 msec per loop

C:\temp>\python24\lib\timeit.py -s "import t" "t.testNested2(t.instance,
42)"
1000 loops, best of 3: 1.08 msec per loop

C:\temp>\python24\lib\timeit.py -s "import t" "t.testNested3(t.instance,
42)"
1000 loops, best of 3: 1.13 msec per loop

C:\temp>\python24\lib\timeit.py -s "import t" "t.testNested4(t.instance,
42)"
1000 loops, best of 3: 1.23 msec per loop
--------- t.py -------------
class C:
def m1(self):
return 42

def m2(self, x):
return x

instance = C()

def testMethod(instance,x):
n = 0
while n < 100000:
n += instance.m1()

def testMethod2(instance, x):
n = 0
while n < 100000:
n += instance.m2(x)

def testNested(instance, x):
def m1():
return 42
n = 0
while n < 100000:
n += m1()

def testNested2(instance, x):
def m2():
return x
n = 0
while n < 100000:
n += m2()

def testNested3(instance, x):
def m2(y):
return y
n = 0
while n < 100000:
n += m2(x)

def testNested4(instance, x):
def m2(y):
return x
n = 0
while n < 100000:
n += m2(x)

----------------------------

The differences between the nested function calls show how difficult it can
be guessing what will be faster: #3&#4 show that all, else being equal,
accessing the closure is much slower than accessing a parameter, but #2
shows that not passing any parameters to the nested function more than
compensates for the single slow closure access.
Jun 15 '06 #7
Duncan Booth wrote:
Fredrik Lundh wrote:
George Sakkis wrote:
It shouldn't come as a surprise if it turns out to be slower, since
the nested function is redefined every time the outer is called.


except that it isn't, really: all that happens is that a new function
object is created from prebuilt parts, and assigned to a local
variable. it's not slower than, say, a method call.

It looks to be somewhat faster than a method call:

C:\temp>\python24\lib\timeit.py -s "import t" "t.testMethod(t.instance,
42)"
1000 loops, best of 3: 1.58 msec per loop

C:\temp>\python24\lib\timeit.py -s "import t" "t.testMethod2(t.instance,
42)"
100 loops, best of 3: 1.61 msec per loop

C:\temp>\python24\lib\timeit.py -s "import t" "t.testNested(t.instance,
42)"
1000 loops, best of 3: 1.06 msec per loop

C:\temp>\python24\lib\timeit.py -s "import t" "t.testNested2(t.instance,
42)"
1000 loops, best of 3: 1.08 msec per loop

C:\temp>\python24\lib\timeit.py -s "import t" "t.testNested3(t.instance,
42)"
1000 loops, best of 3: 1.13 msec per loop

C:\temp>\python24\lib\timeit.py -s "import t" "t.testNested4(t.instance,
42)"
1000 loops, best of 3: 1.23 msec per loop
--------- t.py -------------
class C:
def m1(self):
return 42

def m2(self, x):
return x

instance = C()

def testMethod(instance,x):
n = 0
while n < 100000:
n += instance.m1()

def testMethod2(instance, x):
n = 0
while n < 100000:
n += instance.m2(x)

def testNested(instance, x):
def m1():
return 42
n = 0
while n < 100000:
n += m1()

def testNested2(instance, x):
def m2():
return x
n = 0
while n < 100000:
n += m2()

def testNested3(instance, x):
def m2(y):
return y
n = 0
while n < 100000:
n += m2(x)

def testNested4(instance, x):
def m2(y):
return x
n = 0
while n < 100000:
n += m2(x)

----------------------------

The differences between the nested function calls show how difficult it can
be guessing what will be faster: #3&#4 show that all, else being equal,
accessing the closure is much slower than accessing a parameter, but #2
shows that not passing any parameters to the nested function more than
compensates for the single slow closure access.


It would also be interesting to add unnested versions of m1(), m2()
(functions, not methods) to the comparison.

George

Jun 15 '06 #8
Thanks everybody for your help!

Jun 15 '06 #9
Fredrik Lundh wrote:
George Sakkis wrote:
It shouldn't come as a surprise if it turns out to be slower, since the
nested function is redefined every time the outer is called.


except that it isn't, really: all that happens is that a new function object is created from
prebuilt parts, and assigned to a local variable. it's not slower than, say, a method call.


Interesting. So func_code for a nested function is created when the
module is compiled, and stuck in a new function object when the
definition is executed. Like George, I always assumed that the body of
the nested function was compiled when the outer function was executed,
but that doesn't really make any sense - the *code* for the inner
function is static, just the environment changes (globals(), closure).

dis.dis reveals all:

In [10]: def g():
....: def h():
....: print 'foo'
....: return h
....:

In [11]: dis.dis(g)
2 0 LOAD_CONST 1 (<code object h at 00E8D960,
file "<ipython console>", line 2>)
3 MAKE_FUNCTION 0
6 STORE_FAST 0 (h)

4 9 LOAD_FAST 0 (h)
12 RETURN_VALUE

Thanks Fredrik!
Kent
Jun 15 '06 #10

This thread has been closed and replies have been disabled. Please start a new discussion.

Similar topics

3
by: Nils Grimsmo | last post by:
hi, i'm having some trouble nesting functions. consider the following: def h(): x = 1 def g(): print x # ok, x is taken from h g()
6
by: Andy Baker | last post by:
Hi there, I'm learning Python at the moment and trying to grok the thinking behind it's scoping and nesting rules. I was googling for nested...
6
by: A | last post by:
Hi, How do you make use of nested functions in C++? I realize in C++ that everything must be declared first in a header file before...
2
by: Forgone Conclusion | last post by:
Hi, I have a View that groups and sums up totals. This View is then nested within in another View and used (it needs to be done like this)....
7
by: block111 | last post by:
Hello, code like this: int f1(int x){ int f2(int y){ return y*y; } if(x > 0) return f2(x);
10
by: nimmi_srivastav | last post by:
Below you will see an example of a nested conditional expression that this colleague of mine loves. He claims that it is more efficient that a...
4
by: Wolfgang Draxinger | last post by:
If you know languages like Python or D you know, that nested functions can be really handy. Though some compilers (looking at GCC) provide the...
2
by: Johannes Bauer | last post by:
Nick Keighley schrieb: Why is there actually a *need* for nested functions? If functionality of subfunctions which are only locally visible is...
9
by: Gabriel Rossetti | last post by:
Hello, I can't get getattr() to return nested functions, I tried this : .... def titi(): .... pass .... f = getattr(toto,...
1
by: Kemmylinns12 | last post by:
Blockchain technology has emerged as a transformative force in the business world, offering unprecedented opportunities for innovation and...
0
by: Naresh1 | last post by:
What is WebLogic Admin Training? WebLogic Admin Training is a specialized program designed to equip individuals with the skills and knowledge...
0
by: antdb | last post by:
Ⅰ. Advantage of AntDB: hyper-convergence + streaming processing engine In the overall architecture, a new "hyper-convergence" concept was...
0
by: Matthew3360 | last post by:
Hi there. I have been struggling to find out how to use a variable as my location in my header redirect function. Here is my code. ...
0
by: Arjunsri | last post by:
I have a Redshift database that I need to use as an import data source. I have configured the DSN connection using the server, port, database, and...
0
hi
by: WisdomUfot | last post by:
It's an interesting question you've got about how Gmail hides the HTTP referrer when a link in an email is clicked. While I don't have the specific...
0
by: Matthew3360 | last post by:
Hi, I have been trying to connect to a local host using php curl. But I am finding it hard to do this. I am doing the curl get request from my web...
0
Oralloy
by: Oralloy | last post by:
Hello Folks, I am trying to hook up a CPU which I designed using SystemC to I/O pins on an FPGA. My problem (spelled failure) is with the...
0
BLUEPANDA
by: BLUEPANDA | last post by:
At BluePanda Dev, we're passionate about building high-quality software and sharing our knowledge with the community. That's why we've created a SaaS...

By using Bytes.com and it's services, you agree to our Privacy Policy and Terms of Use.

To disable or enable advertisements and analytics tracking please visit the manage ads & tracking page.