How to parse an arbitrary option string into a python dictionary

Question

I am trying to find the most Pythonic way to take a string containing command line options:

"-t 500 -x -c 3 -d"

And turn it into a dictionary

{"-t":"500", "-x":True, "-c":"3", "-d": True}

UPDATE: The string should also be able to contain --long options, and words with dashes in the middle:

"-t 500 -x -c 3 -d --long-option 456 -testing weird-behaviour"

Before suggesting that I look into OptionParse module, keep in mind I don't know what the valid options are or anything like that, I am just trying to put the string into a dictionary to allow modifying it based on a different dictionary of options.

The approach I am considering is using split() to get the items into a list and then walking the list and looking for items that begin with a dash "-" and use them as the key, and then somehow getting to the next item on the list for the value. The problem I have is with options that don't have values. I thought of doing something like:

for i in range(0, len(opt_list)):
        if opt_list[i][0] == "-":
            if len(opt_list) > i+1 and not opt_list[i+1][0] == "-":
                opt_dict[opt_list[i]] = opt_list[i+1] 
            else:
                opt_dict[opt_list[i]] = True

But it seems like I am programming in C not Python when I do that...

Answer 1

To handle spaces inside quotes correctly you could use shlex.split():

import shlex

cmdln_args = ('-t 500 -x -c 3 -d --long-option 456 '
              '-testing "weird -behaviour" -m "--inside"')

args = shlex.split(cmdln_args)
options = {k: True if v.startswith('-') else v
           for k,v in zip(args, args[1:]+["--"]) if k.startswith('-')}

from pprint import pprint
pprint(options)

Output

{'--inside': True,
 '--long-option': '456',
 '-c': '3',
 '-d': True,
 '-m': True,
 '-t': '500',
 '-testing': 'weird -behaviour',
 '-x': True}

Answer 2

You could use regular expressions like so:

import re

args = "-t 500 -x -c 3 -d --long-option 456 -testing weird-behaviour"
matches = re.findall(r'(--?[\w-]+)(.*?)(?= -|$)', args)

result = {}
for match in matches:
    result[match[0]] = True if not match[1] else match[1].strip()

print result

and the result is equal to

{
'-d': True, 
'-c': '3', 
'-t': '500', 
'--long-option': '456', 
'-x': True, 
'-testing': 'weird-behaviour'
}

---

Regular Expression breakdown:

(--?[\w-]+)(.*?)(?= -|$)

• (--?[\w-]+) matches any character or word (dashes allowed in the word) that starts with a "-" or a "--".
• (.*?) matches any character 0 or more times in a non-greedy or minimal fashion by using the question mark.
• (?= -|$) is a positive lookahead. It checks that what we are looking for is followed by a " -" or the end of the string but it does not include it in the match.

Note the use of parenthesis in this regular expression. These are used to create groups so when we call findall it will split them into tuples.

Answer 3

Argument Parsing for Humans - https://github.com/kennethreitz/args

Answer 4

I can't speak to the most Pythonic way, but here's a 1-liner:

opt_list = "-t 500 -x -c 3 -d"

dict((e if len(e) >1 else (e[0],True) for e in (elem.split() 
      for elem in ('-'+d for d in opt_list.split('-') if d))))

>>>{'-t': '500', '-x': True, '-c': '3', '-d': True}

[Edit: As Matthias pointed out, this won't work for values with a '-' in them]

...however, in general, I don't think the OP's answer can be solved unambiguously when you allow a '-' in option values.

consider these simple options:

"-a -b"

Is this:

• {'-a': '-b'},
• {'a-':True, '-b':True}

???

Answer 5

>>> results = "-t 500 -x -c 3 -d".split()
>>> rd = {}
>>> while i < len(results):
...    if results[i].startswith("-"):
...       rd[results[i]]=True
...       try:
...          if not results[i+1].startswith("-"):
...             rd[results[i]] = results[i+1]
...       except IndexError: pass
...    i+=1
...
>>> rd
{'-t': '500', '-x': True, '-c': '3', '-d': True}

but pretty simillar to what you have..

Answer 6

A harder problem that it initial appears, this is my first attempt. It simply loops over the arguments and checks if they start with a -. If so, and the next argument doesn't, then these two items are added to a dictioary, otherwise the current argument and True get added. The try is needed if the final item in the argument list starts with a -.

args = "-t 500 -x -c 3 -d".split()

d = {}

for i, item in enumerate(args):
    if item.startswith('-'):
        try:
            if args[i+1].startswith('-'):
                d[item] = True
            else:
                d[item] = args[i+1]
        except IndexError:
                d[item] = True

print d # prints {'-t': '500', '-x': True, '-c': '3', '-d': True}

Edit: An alternative solution, inspired by Gerrat's splitting on - is the following:

args = "-t 500 -x -c 3 -d".split('-')

d = {}

for arg in args:
    if arg:
        try:
            k, v = arg.split()
        except ValueError:
            k, v = arg.strip(), True

        d[k] = v

However, as Matthias points out, this may not work if the options and values have -s within them.

Answer 7

import re

myDictionnary = {}

strPattern1 = "-[0-9a-z ]*"
strPattern2 = "-([0-9a-z]+) *(.*)"
strToParse = "-t 500 -x -c 3 -d"

listKeyValues = re.findall(strPattern1, strToParse)

for kv in listKeyValues:

    match = re.search(strPattern2, kv)

    key = match.group(1)
    value = match.group(2)

    if len(value) > 0:
        myDictionnary[key] = value
    else:
        myDictionnary[key] = True