How to pass a default value for argument from one function definition to a higher one

Question

I'm searching for a good way to pass default values for arguments to a calling function. Let me explain this by example:

def greet(name, greeting='Hello', punctuation='!'):
    return greeting+' '+name+punctuation

def greet_with_hi(name, punctuation='!'):
   return greet(name, 'Hi', punctuation)

This is an example without use but here's my question: How can I omit the default value for the puncuation argument of greet_with_hi? A default value for this argument is already defined in greet.

Solutions I can think of:

• let it as it is, cons: changing the default value must be done on every function definition instead of only changing it in one place
• use None as value for default argument and handle None inside greet, cons: special handling
• use a global "constant" like DEFAULT_PUNCTUATION='!' and use this as value for the default argument, cons: seems not to be very pythonic

I haven't seen a common pattern in APIs and other code. How would you handle this pattern?

Answer 1

Why not use None?

def greet(name, greeting='Hello', punctuation='!'):
    return greeting+' '+name+punctuation

def greet_with_hi(name, punctuation=None):
    if punctuation:
        return greet(name, 'Hi', punctuation)
    else:
        return greet(name, 'Hi')

Really any special value would work, but None nicer on the if/else.

If you want "" the null string to be valid punctuation, you have to specify: if punctuation is not None:

Usually, the pattern is the wrapper sets the default for a mandatory parameter in the wrapped function:

def greet(name, greeting, punctuation):
    return greeting+' '+name+punctuation

def greet_with_hi(name, punctuation='!'):
   return greet(name, 'Hi', punctuation)

The idea is the greet() is the general case and the greet_with_hi does some of the work for you.

Answer 2

Without modifying your greet function, you can simply remove the argument from the greet_with_hi function and pass nothing for the parameter. That way, the default defined on greet will be used:

def greet_with_hi(name):
    return greet(name, 'Hi')

If you want to be able to specify a different value for punctuation with greet_with_hi but still want to use the default value as specified on greet otherwise, then you could do it like this:

def greet_with_hi(name, punctuation = None):
    if punctuation is None:
        return greet(name, 'Hi')
    else:
        return greet(name, 'Hi', punctuation)

Unfortunately, there is no value that conveys a “use the default” meaning, so you can only trigger the default from greet by not passing an argument to it.

Alternatively, you could also use tuple unpacking here so you only have to specify the arguments once here. This might make more sense when you have multiple default arguments though—at which point you might want to use named arguments too):

def greet_with_hi(name, punctuation = None):
    additionalArgs = []
    if punctuation is not None:
        additionalArgs.append(punctuation)
    return greet(name, 'Hi', *additionalArgs)

Answer 3

Let's simplify your question a little bit. We have two functions, a and b that is using it.

def a(arg = 0):
    return arg

def b(arg = 0):
    return a(arg)

And you want them to share the default argument value.

You could simply create a global variable and use it in both definitions:

__DEFAULT_VALUE = 0

def a(arg = __DEFAULT_VALUE):
    return arg

def b(arg = __DEFAULT_VALUE):
    return a(arg)

Other solution would be to make b's defalt argument to be None and then check against it.

def a(arg = 0):
    return arg

def b(arg = None):
    if arg is None:
        return a()
    return a(arg)

EDIT: don't code like in the solution below. It's late, I'm sleepy, that's where it came from.

Or you can use a more complex and pythoney approach. First, extract default arguments from the "base" a function, then set b's default value as None and check if it's used. If it is, then use a's default value instead.

import inspect

def a(arg=0):
    return arg

def b(arg=None):
    if arg is None:
        signature = inspect.getargspec(a)
        unpacked_signature = dict(zip(signature.args[-len(signature.defaults):], signature.defaults))
        arg = unpacked_signature['arg']

    return a(arg)