Way to Treat Python single vals and lists of vals identically?

Question

I'm running into this problem often: I'm creating a function that needs to perform a series of operations on a value, whether that value be a single value or a list of values.

Is there an elegant way to do this:

def convert_val(val):
   do a series of things to each value, whether list or single val
   return answer or list of answers

rather than what I've been doing?:

def convert_val(val):
    if isinstance(val, list):
       ... do a series of things to each list item,
       return a list of answers
    else:
       ... do the same series, just on a single value
       return a single answer

One solution would be to create a sub_convert() that would do the series of actions, and then just call it once or iteratively, depending on the type passed in to convert().

Another would be to create a single convert() that would accept the arguments (value, sub_convert()).

Other suggestions that would be more compact, elegant and preferably all in one function?

(I've done several searches here to see if my issue has already been addressed. My appologies if it has.)

Thanks, JS

Answer 1

You need to fix your design to make all uses of the function actually correct.

Ralph Waldo Emerson. "A foolish consistency is the hobgoblin of little minds, adored by little statesmen and philosophers and divines."

We're not talking about a foolish consistency. You have what might be a design problem based on inconsistent use of this function.

Option 1. Don't call convert_val( x ) where x is a non-list. Do this. convert_val( [x] ). Don't fix your function, fix all the places that use your function. Consistency helps reduce bugs.

Option 2. Change the design of convert_val to use multiple positional arguments. This doesn't generalize well.

def convert_val( *args ):
    whatever it's supposed to do to the arguments.

Then fix all the places you provide a list to be convert_val( *someList ). That's okay, and may be closer to your intent.

Note.

You can find your design errors using the warnings module.

def convert_val( arg ):
    if isinstance( arg, collections.Sequence ):
        return convert_val_list( arg )
    else:
        warnings.warn( "Fix this" )
        return convert_val_list( [arg] )[0]

def convert_val_list( arg ):
    assert isinstance( arg, collections.Sequence )
    the original processing

Once you've fixed all the design problems, you can then do this

convert_val = convert_val_list

And delete the original function.