Currently, there is no (documented) way to easily extract arguments in an argparse Namespace as a dictionary. This way, it would me easy to interface a function taking a lot of kwargs like this:

>>> args = parser.parse_args()
>>> my_function(**dict(args))

There's "_get_kwargs()" but it's a private undocumented method. I guess that making it public would be problematic because of the namespace pollution that would occur. That's why I'm proposing to make it iterable.

If it isn't rejected, I'd gladly work on the required patch.

+1 for making the object readily convertible to a dictionary.  That would also serve to make it more introspectable without losing the simplicity of the current design.

I went ahead and created a patch (with test and doc) making argparse.Namespace iterable.

Nice idea indeed, thanks for the patch.

For the doc section, I’d prefer to de-emplasize the specific use case of **kwargs, in favor of mentioning dict conversion in a general way:

  Converting the namespace to a dict
  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  
  Namespace objects are iterable so you can easily convert them to a
  :class:`dict`::

     args = parser.parse_args()
     argdict = dict(args)

  This makes it easy to introspect the namespace or to pass the
  command-line arguments to a function taking a bunch of keyword
  arguments::

     somefunction(**dict(parser.parse_args()))

 
+    def __iter__(self):
+        return iter(self.__dict__.items())
Isn’t “return self.__dict__.items()” sufficient in 3.x?


Alternate idea: don’t implement __iter__, which is sorta too broad, and implement a method that just returns a dict.

Musing: Isn’t Namespace (technically: _AttributeHolder) very much like a named tuple?  Could some code be removed by using named tuples in argparse?  Note that named tuples provide a method to convert themselves to a dict, and are efficient (IIRC).

What's wrong with `vars(args)`? That's the standard way of getting a dict from an object, no?

Note that you're not always guaranteed to get a Namespace back (e.g. if you pass the namespace= argument to parse_args), and I'd generally like to keep Namespace as simple as possible.

I didn't know about vars() (well, I knew it existed, but never was quite sure what it did).

Given that I'm not a Python newbie, I'm guessing I'm not alone in this situation. Maybe that instead of making the Namespace iterable, we should just add an example usage of vars() in argparse's documentation?

Yes, definitely `vars` deserves some description and an example in the documentation. This isn't the first time this question has come up. =)

Here's a documentation-only patch which adds a section about using vars() to convert a namespace to a dict.

If this becomes a documentation issue, can we target Python 3.2.1 instead of Python 3.3?

+1 for this patch.

Documentation fixes are backported from the development branch to stable branches, so yes, this will land in 3.1 too.

There's no argparse in 3.1, so it should only go into 2.7, 3.2 and 3.3. But yes, the patch looks great to me too.

Seems like a great idea. `foo(**dict(args))` is very useful.

I tested `foo(**dict(iter(o.__dict__.items())))` on python 2.7 Mac OSX for my foo and it worked well.

New changeset bbecbcff0ce4 by Andrew Svetlov in branch '3.2':
Issue #11076: document the way to convert argparse.Namespace to a dict.
http://hg.python.org/cpython/rev/bbecbcff0ce4

New changeset ee4e31845977 by Andrew Svetlov in branch '3.3':
Merge issue #11076: document the way to convert argparse.Namespace to a dict.
http://hg.python.org/cpython/rev/ee4e31845977

New changeset 63ff2d421d1a by Andrew Svetlov in branch 'default':
Merge issue #11076: document the way to convert argparse.Namespace to a dict.
http://hg.python.org/cpython/rev/63ff2d421d1a

Sorry, looks like it work already was done. Reverting: c008f070f88a 814403d824a5 ddcf09a348ca

Following up Andrew's last comment, for the record, it looks like this was done as part of issue 8982.