Adding Recursive Depth to Our Functions
2012-03-05 22:46I suppose it this not uncommon to encounter a general situation such as the following. Say you have some well-defined function that performs a transformation of one value into another. It’s not particularly important how lengthy or complicated this function is, only that it takes one parameter and outputs a result. Here’s a somewhat trivial but astonishingly useful example:
- def is_true(value):
- ''' Checks whether given value can be interpreted as "true",
- using various typical representations of truth. '''
- s = str(value).lower()
- can_be_true = s in ['1', 'y', 'yes', 'true']
- can_be_false = s in ['0', 'n' 'no', 'false']
- if can_be_true != (not can_be_false):
- return bool(value) # fall back in case of inconsistency
- return can_be_true
Depending on what happens in other parts of your program, you may find yourself applying such function to many different inputs. Then at some point, it is possible that you’ll need to handle lists of those inputs in addition to supporting single values. Query string of URLs, for example, often require such treatment because they may contain more than one value for given key, and web frameworks tend to collate those values into lists of strings.
In those situations, you will typically want to deal just with the list case. This leads to writing a conditional in either the caller code:
- if not isinstance(values, list):
- values = [values]
- bools = map(is_true, values)
or directly inside a particular function. I’m not a big fan of similar solutions because everyone do them differently, and writing the same piece several times is increasingly prone to errors. Quite not incidentally, a mistake is present in the very example above – it shouldn’t be at all hard to spot it.
In any case, repeated application calls for extracting the pattern into something tangible and reusable. What I devised is therefore a general “recursivator”, whose simplified version is given below:
- def recursive(func):
- ''' Creates a recursive function out of supplied one.
- Resulting function recurses on lists, applying itself
- to its elements. '''
- def recursive_func(obj, *args, **kwargs):
- if hasattr(obj, '__iter__'):
- return [recursive_func(i, *args, **kwargs)
- for i in obj]
- return obj
- return recursive_func
As for usage, I think it’s equally feasible for both on-a-spot calls:
- bools = recursive(is_true)(values)
as well as decorating functions to make them recursive permanently. For this, though, it would be wise to turn it into class-based decorator, applying the technique I’ve described previously. This way we could easily extend the solution and tie it to our needs.
But what are the specific ways of doing so? I could think of some, like:
- Recursing not only on lists, bit also on mappings (dictionaries) and applying the function to dictionary values. A common use case could be a kind of sanitization function for preparing values to be serialized, e.g. by turning
datetimes into ISO-formatted strings. - Excluding some data types from recursion, preventing, say,
sets from being turned into lists, as obviously sets are also iterable. In more general version, one could supply a predicate function for deciding whether to recurse or not. - Turning
recursiveinto generator for more memory-efficient solution. If we’re lucky to program in Python 3.x, it would be a good excuse to employ the newyield fromconstruct from 3.3.
One way or another, capturing a particular concept of computation into actual API such as recursive looks like a good way for making the code more descriptive and robust. Certainly it adheres to one of the statements from Zen: that explicit is better than implicit.
Adding comments is disabled.
Comments are disabled.
Recent posts
