nested function in python

class some_class(parent_class):
def doOp(self, x, y):
def add(x, y):
return x + y
return add(x, y)

shareimprove this question

edited Jan 17 '11 at 9:41

asked Oct 19 '09 at 14:40 Hosam Aly 19.7k28109158

def make_adder(x):
def add(y):
return x + y
return add

plus5 = make_adder(5)
print(plus5(12))  # prints 17

x

shareimprove this answer

answered Oct 19 '09 at 16:05 Adam Rosenfield 232k62355476

import sys

def Foo():
def e(s):
sys.stderr.write('ERROR: ')
sys.stderr.write(s)
sys.stderr.write('\n')
e('I regret to inform you')
e('that a shameful thing has happened.')
e('Thus, I must issue this desultory message')
e('across numerous lines.')
Foo()

shareimprove this answer

edited May 12 '14 at 18:36

answered Oct 19 '09 at 15:03 Ross Rogers 8,4891356108

def helper(feature, resultBuffer):
resultBuffer.print(feature)
resultBuffer.printLine()
resultBuffer.flush()

def save(item, resultBuffer):

helper(item.description, resultBuffer)
helper(item.size, resultBuffer)
helper(item.type, resultBuffer)

def save(item, resultBuffer):

def helper(feature):
resultBuffer.print(feature)
resultBuffer.printLine()
resultBuffer.flush()

helper(item.description)
helper(item.size)
helper(item.type)

shareimprove this answer

edited Dec 21 '12 at 11:11

answered Nov 15 '12 at 12:32 Kuba 1,0041121

class some_class(parent_class):
def doOp(self, op, x, y):
def add(x, y):
return x + y
def sub(x,y):
return x - y
return locals()[op](x,y)

some_class().doOp('add', 1,2)

class some_class(object):
def _add(self, x, y):
return x + y
def doOp(self, x, y):
return self._add(x,y)

shareimprove this answer

edited Oct 19 '09 at 15:55

answered Oct 19 '09 at 14:55 Jochen Ritzel 55.5k8106145

When
to use python function nesting?

up vote2down votefavorite

I am writing a program that creates backup of directories. Which of the following approach is better for code organization? Create separate class for Backup and Zip logic - class BackupUtil: def backup(self): None class ZipUtil: def archive_dir(self): None Or use function nesting like this - class BackupUtil: def backup(self): def archive_dir(): None None python code-quality code-organization shareimprove this question asked Mar 18 '14 at 8:37 Kshitiz Sharma 3072411

add a comment

3 Answers

up vote5down vote

In general, when the inner function is small and you want to make it clear that it's only useful to the enclosing function. Alternatively, when you need to return a function. The latter scenario is trivial since generally the inner function relies on variables in the enclosing functions's scope, so declaring it anywhere else isn't an option. You might be able to use a lambda in that case, but anything longer than one expression would need a full function declaration. Without the implementations it's hard to say which one you should choose in this case. I would hasten to add that you don't have to put everything in a class either. shareimprove this answer answered Mar 18 '14 at 11:42 Doval 12.8k22946

add a comment

up vote0down vote

Keeping the two separate would be useful for quite a few reasons: 1) You will have more flexibility working with either class (especially Class inheritance) 2) You can transform the two classes into modules that you can use in your other codes independently from each other 3) You will avoid unnecessarily creating a larger class when you maybe only need to use one of the two features 4) Keeping the functions separate also increases code readability when you later call these functions Hope that helps clarify somethings. shareimprove this answer answered Mar 18 '14 at 11:07 sshashank124 1012

add a comment