python - 如何检查字符串是否包含字典

Question

我想递归地解析字典中的所有值，这些值是带有 ast.literal_eval(value) 的字符串，但如果字符串不包含字典，则不执行该 eval。我想要这个，因为我在字典中有一个字符串，它本身就是一个字典，我希望这个值是一个字典。最好举个例子

my_dict = {'a': 42, 'b': "my_string", 'c': "{'d': 33, 'e': 'another string'}"}

现在我不想做 ast.literal_eval(my_dict['c']) 我想要一个通用的解决方案，我可以做 convert_to_dict(my_dict)

我想自己写一个方法，但是我不知道如何检查一个字符串是否包含一个字典，然后 ast.literal_eval 会失败，因此问题。

Answer 1

您可以在使用literal_eval 并重新分配后检查您是否有字典:

from ast import literal_eval

def reassign(d):
    for k, v in d.items():
        try:
            evald = literal_eval(v)
            if isinstance(evald, dict):
                d[k] = evald
        except ValueError:
            pass

只需传入字典:

In [2]: my_dict = {'a': 42, 'b': "my_string", 'c': "{'d': 33, 'e': 'another stri
   ...: ng'}"}

In [3]: reassign(my_dict)

In [4]: my_dict
Out[4]: {'a': 42, 'b': 'my_string', 'c': {'d': 33, 'e': 'another string'}}

In [5]: my_dict = {'a': '42', 'b': "my_string", '5': "{'d': 33, 'e': 'another st
...: ring', 'other_dict':{'foo':'bar'}}"}
In [6]: reassign(my_dict)  
In [7]: my_dict
Out[7]: 
{'5': {'d': 33, 'e': 'another string', 'other_dict': {'foo': 'bar'}},
 'a': '42',
 'b': 'my_string'}

你还应该知道，如果你的字典中有某些其他对象，比如 datetime 对象等。那么 literal_eval 就会失败，所以它是否真的取决于你的字典可以包含什么工作与否。

如果您需要递归方法，您只需在新字典上调用重新分配即可。

def reassign(d):
    for k, v in d.items():
        try:
            evald = literal_eval(v)
            if isinstance(evald, dict):
                d[k] = evald
                reassign(evald)
        except ValueError:
            pass

再次传递字典:

In [10]: my_dict = {'a': 42, 'b': "my_string", 'c': "{'d': 33, 'e': \"{'f' : 64}
    ...: \"}"}

In [11]: reassign(my_dict)

In [12]: my_dict
Out[12]: {'a': 42, 'b': 'my_string', 'c': {'d': 33, 'e': {'f': 64}}}

如果你想要一个新的字典:

from ast import literal_eval
from copy import deepcopy

def reassign(d):
    for k, v in d.items():
        try:
            evald = literal_eval(v)
            if isinstance(evald, dict):
                yield k, dict(reassign(evald))
        except ValueError:
            yield k, deepcopy(v)

这会给你一个新的字典:

In [17]: my_dict = {'a': [1, 2, [3]], 'b': "my_string", 'c': "{'d': 33, 'e': \"{
    ...: 'f' : 64}\"}"}

In [18]: new =  dict(reassign(my_dict))

In [19]: my_dict["a"][-1].append(4)

In [20]: new
Out[20]: {'a': [1, 2, [3]], 'b': 'my_string', 'c': {'d': 33, 'e': {'f': 64}}}

In [21]: my_dict
Out[21]: 
{'a': [1, 2, [3, 4]],
 'b': 'my_string',
 'c': '{\'d\': 33, \'e\': "{\'f\' : 64}"}'}

您需要确保深度复制对象，否则当您有嵌套对象(如上面的列表列表)时，您将无法获得字典的真正独立副本。