Please explain reasoning behind code snippet from argparse module

Question

I was looking at the source code for the built-in argparse._AppendAction, which implements the "append" action, and puzzled over the way it is implemented:

    def __call__(self, parser, namespace, values, option_string=None):
        items = _copy.copy(_ensure_value(namespace, self.dest, []))
        items.append(values)
        setattr(namespace, self.dest, items)

To break it down:

_ensure_value is like dict.setdefault for attributes. That is, if namespace has an attribute with the name self.dest then it is returned, if not it is set to [] and returned.
_copy.copy(x) returns just a shallow copy. When x is a list it is exactly like list(x) (but slower).
Then the item is appended to the copy of the list gotten from namespace.
Finally the self.dest attribute of namespace is overwritten with the copy, which should cause the old list to be garbage collected.

Why do it in such a roundabout and inefficient way, throwing away a whole list for each append? Why doesn't this suffice?

    def __call__(self, parser, namespace, values, option_string=None):
        items = _ensure_value(namespace, self.dest, [])
        items.append(values)

mgilson · Accepted Answer · 2013-01-15 14:49:42Z

6

I'm not an expert in the implementation, so (disclaimer) this is really just a guess. With this implementation, the user can pass a list as a default=... in a call to add_argument without it being mutated within argparse. Perhaps this type of safety was desired by the developers for one reason or another.

The inefficiency you mention really isn't a big deal. It's for parsing commandline arguments, so this function is likely only called 10's of times per program under heavy usage.

I've tested this and indeed, If I use the following script (where argparse_temp is simply argparse.py copied to the current directory so I can play with it):

import argparse_temp as argparse

lst = [1,2,3]
parser = argparse.ArgumentParser()
parser.add_argument('-l',default=lst,action='append')
print parser.parse_args()
print lst

This prints (when called as: python test1.py -l 4):

Namespace(l=[1, 2, 3, '4'])
[1, 2, 3]

with argparse as is, but:

Namespace(l=[1, 2, 3, '4'])
[1, 2, 3, '4']

with your proposed change.

If you print the action that is returned by add_argument, you get:

_AppendAction(option_strings=['-l'], dest='l', nargs=None, const=None, default=[1, 2, 3, '4'], type=None, choices=None, help=None, metavar=None)

Which is it conceivable that argparse depends on that action elsewhere in the implementation. (Notice that default has been mutated here as well).

edited Jan 15, 2013 at 14:49

answered Jan 15, 2013 at 14:04

mgilson

312k70 gold badges656 silver badges722 bronze badges

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

2 Comments

Lauritz V. Thaulow Over a year ago

This sounds like the right answer. I guess it should be possible to avoid modifying the default argument while also improving efficiency, but I can't think of an elegant way of doing it, and as you say, this shouldn't be a bottleneck.

mgilson Over a year ago

@lazyr -- And as a side note, copy.copy is used instead of slicing, probably so that the user isn't forced to pass a list. Anything with an append method would work.

Collectives™ on Stack Overflow

Please explain reasoning behind code snippet from argparse module

1 Answer 1

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related