当我处理也可以从命令行解析的模块的默认参数时，如何避免冗余？

Question

I'm trying to find a good way to avoid redundancy (that could possibly inject a risk for divergence) to my python module that can be executed from the command line.

Consider a python module like this:

#!/usr/bin/env python2.7
from argparse import ArgumentParser

DEFAULT_A_ARG='alpha'

def funky(a=DEFAULT_A_ARG, b=False):
    pass

if __name__ == '__main__':
    parser = ArgumentParser()
    parser.add_argument('-a', default=DEFAULT_A_ARG)
    parser.add_argument('-b', action='store_true', default=False)
    args = parser.parse_args()
    funky(a=args.a, b=args.b)

So, someone using this module could either import it into their own code or call it from the command line. I don't like that there is a redundancy in specifying the default value for the 'a' argument between the function definition and the command line parser. Aside from the aesthetic annoyance, I tend to fret that, in larger modules that might be edited via version control by many devs, one of the defaults could be changed but not the other.

Is there a good way to eliminate the redundancy of specifying the default in two different places?

Answer 1

Alternatively, if you are using ArgumentDefaultsHelpFormatter to display the default values trough the usage message, you could do something like this:

#!/usr/bin/env python2.7
from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter

parser = ArgumentParser(prog='my_program',
                        formatter_class=ArgumentDefaultsHelpFormatter)
parser.add_argument('-a', default='alpha', help='your favorite greek letter')
parser.add_argument('-b', action='store_true', help='print numbers in binary format')

def funky(a=parser.get_default('a'), b=parser.get_default('b')):
    pass

if __name__ == '__main__':
    args = parser.parse_args()
    funky(**args.__dict__)

On terminal:

$ my_program.py --help
usage: my_program [-h] [-a A] [-b]

optional arguments:
  -h, --help  show this help message and exit
  -a A        your favorite Greek letter (default: alpha)
  -b          print number in binary format (default: False)

You define it once and get it in three different places, without constants or poluting the function's body...

---

EDIT

I didn't know that much about recovering function metadata. So, reading the docs was pretty helpful in order to answer this question. If you can, take a look at the inspect module of the Standard Library...

Here, another possibility, assigning the parameter defaults inside the function definition:

#!/usr/bin/env python2.7
from argparse import ArgumentParser

def funky(x, a='alpha', b=False):
    pass

if __name__ == '__main__':
    import argparse
    import inspect

    funky_spec = inspect.getargspec(funky)
    defaults = funky_spec.defaults
    defaults = dict(zip(funky_spec.args[-len(defaults):], defaults))
    # effect: ['x', 'a', 'b'] + ('alpha', False) -> {'a': 'alpha', 'b': False}

    parser = argparse.ArgumentParser()
    parser.add_argument('x', help='input number')
    parser.add_argument('-a', default=defaults['a'])
    parser.add_argument('-b', action='store_true', default=defaults['b'])
    args = parser.parse_args()

    funky(x=args.x, a=args.a, b=args.b)

In Python 3, the "inspect" block would be a little bit more legible:

[...]

    funky_params = inspect.signature(funky).parameters.values()
    defaults = {p.name: p.default for p in funky_params if p.default is not p.empty}

[...]

Answer 2

First, define funky to use None as default arguments instead:

def funky(a=None, b=None):
    if a is None:
        a = DEFAULT_A_ARG
    if b is None:
        b = False

Then, let None be the default value for each command-line argument as well:

if __name__ == '__main__':
    parser = ArgumentParser()
    # You probably don't have to specify a default of None explicitly
    parser.add_argument('-a', default=None)
    parser.add_argument('-b', action='store_true', default=None)
    args = parser.parse_args()
    funky(a=args.a, b=args.b)

If the actual default values were to change, you only need to change them in one place (inside the body of funky ) rather than two places (in the definition of -a / -b and in the argument list to funky ).