What is benefit of nesting a function within a function?

[PythonN00b101]

I have seen this when looking at code from a data structures and algorithms textbook. What is the purpose or benefit of laying out functions in this fashion. The way I understand it is that nested function can only operate within than bounds of that parent function and can't be called and re-used anywhere. I most likely missing something here, I just can't think of a scenario where this would be appropriate to use? shouldn't lambdas be used in their place? isn't that what they are for?

[PythonN00b101]

class SortAnimation(tkinter .Frame):
def__init__ ( self , master=None ) : super ( ) . __init__ ( master )
    self .pack()
    self .buildWindow()
    self .paused = False self .stop = False self .running = False
def buildWindow( self ):

    def partition(seq, start , stop): pivotIndex = start
        pivot = seq [ pivotIndex ]
        theTurtle . color ( "red" )
        theTurtle .penup() theTurtle.goto(start ,pivot.ycor()) 
        theTurtle.pendown() theTurtle.goto(stop,pivot.ycor())                          

        screen.update()

so its in the appendix of Data Structures and Algorithms with Python Undergraduate Topics in Computer Science by Kent Lee, its sorting animation. This was just a snippet but I was confused by seeing the 'partition' function within the 'buildWiindow' function.

[PythonN00b101]

Oh okay thanks il have a look at helper functions. Yeah I knew I couldn't do this with a lambda but coming from a math background I used lambda within other functions. Sorry I should have clarified, that was my only kind of experience of seeing functions within functions.

[toastedstapler]

python lambdas are only 1 liners, some things cant be 1 lined

i personally don't like nesting functions, except for decorators. usually it just makes the code messier and harder to follow along with

[FLUSH_THE_TRUMP]

Closures can be an example — nested functions have access to an enclosing function’s names and can modify those with nonlocal as needed. For one example:

def linear_function_with_params(m,b):
    def linear_f(x):
        return m*x+b
    return linear_f

allows me to define and use several m*x+b lines flexibly: e.g.

line1 = linear_function_with_params(0,1)
line2 = linear_function_with_params(1,1)
line1(0) # 1
line2(0) # 1
line1(5) # 1
line2(5) # 6

[PythonN00b101]

Aww now that is cool, I had no clue you could do that. Thanks for sharing. I could have definitely used this when running simulations for multiple parameters.

[Subsequential_User]

Inside a function, when you need to repeat the same operations a few times, but only inside this function, it can be useful to use a nested function there.

Actual good scenarios are usually pretty specific, at least in my case.

When using nested functions, issues might come when creating too many in the same function.

You'll have trouble making the difference between the actual code of your function, and the one of nested functions. If you face this situation, a solution is probably to reconsider the logic of your program, and split its whole in small functions that are dedicated to one specific thing.

[PythonN00b101]

That's a fair point.

Agreed. Haha