I have a string
"{a:'b', c:'d',e:''}"
Please not that the keys to the dictionary entries are unquoted, so a simple eval("{a:'b', c:'d',e:''}") as suggested in a previous question does not work.
What would be the most convenient way to convert this string to a dictionary?
{'a':'b', 'c':'d', 'e':''}
If this is from a trusted source (do not use this for general user input, as eval is not secure; but then again, if you're getting input from a potentially malicious user you should use JSON format and the json module instead), you can use eval with a trick.
source = """{e: '', a: 'b', c: 'd'}"""
class identdict(dict):
def __missing__(self, key):
return key
d = eval(source, identdict())
print(d)
prints
{'a': 'b', 'c': 'd', 'e': ''}
How this works is that we create a new dictionary subclass identdict that defines the magic method __missing__. This method is called for lookups on keys that are missing from the dictionary. In this case, we just return the key, so the dictionary maps keys to themselves. Then the source is evaluated using an identdict instance as the globals argument. eval will look up the values of variables from the globals mapping; as it is an identdict, the value of each variable accessed is conveniently now the name of the variable.
Works for even more complex strings as values, and anything that is proper Python literal syntax.
Depending on the complexity of what you're parsing, this could work:
s = "{a:'b', c:'d',e:''}"
d = dict([
(x.split(':')[0].strip(), x.split(':')[1].strip("' "))
for x in s.strip("{}").split(',')
])
Manual parsing is error-prone and hard to make general, and eval-based approaches fail when the keys are Python keywords. The currently accepted answer breaks if values contain spaces, commas, or colons, and the eval answer can't handle keys like if or for.
Instead, we can tokenize the input as a series of Python tokens and replace NAME tokens with STRING tokens, then untokenize to build a valid dict literal. From there, we can just call ast.literal_eval.
import ast
import io
import tokenize
def parse(x):
tokens = tokenize.generate_tokens(io.StringIO(x).readline)
modified_tokens = (
(tokenize.STRING, repr(token.string)) if token.type == tokenize.NAME else token[:2]
for token in tokens)
fixed_input = tokenize.untokenize(modified_tokens)
return ast.literal_eval(fixed_input)
Then parse("{a:'b', c:'d',e:''}") == {'a':'b', 'c':'d', 'e':''}, and no problems occur with keywords as keys or special characters in the values:
>>> parse('{a: 2, if: 3}')
{'a': 2, 'if': 3}
>>> parse("{c: ' : , '}")
{'c': ' : , '}
WARNING This approach will not work as desired if you have a key mapping to an empty string in the middle of your "dictionary." I'll not delete this answer because I think this approach might still be salvageable.
This might be a little more general than Will's answer, although, it is still going to depend on the exact structure of what you are parsing. If your key, value pairs will consist of alphanumeric words, you should be fine, though.
In [3]: import re
In [4]: import itertools
In [5]: my_string = "{a:'b', c:'d',e:''}"
In [6]: temp = re.findall(r"\w", my_string)
In [7]: temp = itertools.zip_longest(temp[0::2], temp[1::2], fillvalue = "")
In [8]: dict(temp)
Out[8]: {'a': 'b', 'c': 'd', 'e': ''}
If you want to know what is happening with the zip function, see these questions:
Collect every pair of elements from a list into tuples in Python
I used itertools.zip_longest so you can use a fill value, inspired by:
import re
str="{a:'b', c:'d',e:''}"
dict([i.replace("'","").split(":") for i in re.findall(r"(\w+\:'.*?')",str)])
