When to use python function nesting?

Question

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

Answer 1

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.

Answer 2

TL;DR: Use function nesting when you need the characteristics of function nesting

Function Nesting Use Cases (mostly functional idioms, almost certainly incomplete since it's off the top of my head):

• closures
• function factory (programmatic function creation based on parameters)
• creating functions by calling functool.partial
• creating functions by using lambda
• any other reasons you need to create functions during call time

Trade-offs:

• functions are strongly coupled
• the code is always called (unless it's in an if block)
• additional code complexity
• additional runtime cost (potentially, because the inner function get's re-defined with every call to the outer function)
• much harder to extend
• much harder to introspect on the inner function defintion

Answer 3

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.