When is it good to use nested functions in Python?

Question

I'm not referring to closures, where the outer function returns the inner function, or to memoization, specifically. There have been a few instances where I've wanted to write a recursive function, perhaps with memoization, and it seemed much simpler to initialize a dictionary or some other data structures in the outer function, and then have a recursive helper function writing to and accessing the dict and the arguments of the outer function. Here's what I mean --

def foo(arr, l):
   cache = {}
   result = []

   def recursive_foo_helper(i, j, k):
      # some code that depends on arr, l, i, j, k, cache, and result

   for (x, y) in arr:
      if recursive_foo_helper(x, y, k):
         return result
   return None

instead of having the helper function declared separately with some super long signature like,

recursive_foo_helper(arr, l, i, j, k, cache={}, result=[])

I have read that doing this is pretty standard for memoization, but I was curious if there's a consensus on whether it's OK to do just for recursive helper functions.

If you are not calling the function any other places I can't see why this would be a bad thing. — OptimusCrime
– OptimusCrime, Commented Jun 10, 2013 at 22:36

Jonathan Vanasco · Accepted Answer · 2013-06-10 22:47:23Z

13

There are a lot of good reasons. Personally, I often use nested functions to keep the namespace clean. It's especially useful within object methods :

class Foo(object):
    def bar(self):
        def baz(val):
            return val
        return [ baz(i) for i in range(1,101) ]

If I declare baz outside of bar, I either need to make it a method of Foo, or expose it to the entire package.

answered Jun 10, 2013 at 22:47

Jonathan Vanasco

15.8k11 gold badges53 silver badges74 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

horro · Accepted Answer · 2021-10-07 13:32:02Z

8

I use a nested function to find matches from a list:

def get_exact(data, key, match):
    def is_match(item):
        if (key in item) and (item[key].lower() == match.lower()):
            return item
        return False
    return [i for i in data if is_match(i)]

No other calls in the project have a need to use is_match(item), so why declare it separately?

However, I will say that, for my example, declaring is_match() outside of get_exact() does run around ~0.04 seconds faster in 10,000 iterations.

def is_match(item, key, match):
    if (key in item) and (item[key].lower() == match.lower()):
        return item
    return False

def get_exact(data, key, match):
    return [i for i in data if is_match(i, key, match)]

edited Oct 7, 2021 at 13:32

horro

1,3193 gold badges20 silver badges39 bronze badges

answered Jun 10, 2013 at 22:32

bnlucas

1,7841 gold badge13 silver badges18 bronze badges

Comments

mad-hay · Accepted Answer · 2013-06-10 23:12:09Z

4

I usually use closures, however the other way you suggest (what I sometimes call a Wrapper) is also pretty useful and in my personal experience it works fine. I've never had someone tell me to avoid that style. If your code works and is readable (which I think it is) then go for it!

answered Jun 10, 2013 at 23:12

mad-hay

816 bronze badges

Comments

John La Rooy · Accepted Answer · 2013-06-10 22:36:38Z

1

I'd say using a closure as you suggest is cleaner, but really needs the nonlocal keyword from Python3 if you want to rebind references. For mutable objects it's obviously ok to modify them.

In the meantime, it's common to see the defaultarg hacks/idioms in Python2

One (maybe the only) disadvantage of the nested function is that it's difficult to unittest.

To make sure the cache can't grow unbounded, you also need a way to remove items (eg least recently used)

answered Jun 10, 2013 at 22:36

John La Rooy

306k54 gold badges378 silver badges513 bronze badges

Comments

Valentin Fabianski · Accepted Answer · 2022-10-06 09:51:19Z

1

One disadvantage of nested functions is when it comes to testing.

def compute_sequence(sequence):
    """Compute blabla on sequence"""

    def compute_element(element):
        """Compute blabla on element"""
        return element * 2

    sequence = sequence + 1  # global treatment
    return [compute_element(element) for element in sequence]

Questions: How do you test compute_element ? How do you access its docstring ?

Opinion: If you check "import this" you'll see:

The Zen of Python, by Tim Peters [...] Flat is better than nested. [...]

Even if I massively used nested functions today I feel unconfortable using them Peace out

answered Oct 6, 2022 at 9:51

Valentin Fabianski

8061 gold badge6 silver badges12 bronze badges

Comments

SamuelC00 · Accepted Answer · 2022-07-07 22:46:25Z

I think nested functions are great for recursion. Consider the following function for searching if a BST contains a node with the data target:

def contains_target(self, target) -> bool:
        def _contains_target(node, target):
            if node is not None:
                found = False
                found = _contains_target(node.left, target)
                if found:
                    return True
                found = _contains_target(node.right, target)
                if found:
                    return True
                found = target == node.data
                return found
            else:
                return False

        # Begin at the root
        return _contains_target(self.root, target)

I found this to be preferable as you can have an initialized argument for one or all of the parameters when the embedded helper function is first ran. In this case, the first node considered was the root node of the tree.

Collectives™ on Stack Overflow

When is it good to use nested functions in Python?

6 Answers 6

Comments

Comments

Comments

Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

6 Answers 6

Comments

Comments

Comments

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related