[itherseed]

The advantage of the original approach is that later, when you need it, you can just add more methods to a class that are private to them. In your approach, if you need a new function, you add it at the global level, which can totally be fine for one or two functions, but with any more you end up with a bunch of functions all at the same level that is no longer obvious the dependency between them.

[remram]

You can do that with a function too, make it a class with a __call__. If you need it, which you won't for this kind a script.

[heisenzombie]

If you want a function that's private to a function in Python you _could_ also do:

    def foo(context):
    
        def bar(x):
            return x*2
        
        baz = bar(context)

... This is particularly idiomatic for higher order functions, but I think it can be useful for other things if used with restraint.

But if you have functions that only need to be called from one calling function then I why not just inline the code and eschew having a function at all. Long function bodies for the win!

[notfish]

Don’t do this, it makes it a huge pain to test bar().

When you write the initial code to figure out bar, just throw that code in a unit test so you can run it any time. Stop throwing tests away!

[heisenzombie]

Yes, perhaps I wasn’t clear — I’m advocating for just the inlined version, not the nested function in the general case.

The nested function is, I think, fine when it’s so tiny it’s not worth unit testing (like, it-could-have-been-a-lambda small) or when bar is returned by foo (ie foo is higher order), in which case you can test the return value. Apart from that… restraint!