如何检查一个字符串是否包含字典

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

其他的答案都非常好，使我对正确的解决方案，但先前接受的答案了一个错误。这是我工作的解决方案：

def recursive_dict_eval(myDict): 
    for key,value in myDict.items(): 
     try: 
      if(isinstance(value, dict)): 
       recursive_dict_eval(value) 
      evaled_value=ast.literal_eval(value) 
      assert isinstance(evaled_value,dict) 
      myDict[key]=recursive_dict_eval(evaled_value) 

     except (SyntaxError, ValueError, AssertionError): 
      #SyntaxError, ValueError are for the literal_eval exceptions 
      pass 
    return myDict 

Answer 2

如果您需要处理嵌套str定义dict，json.loads with an object_hook可能会为你工作：

import json 

def convert_subdicts(d): 
    for k, v in d.items(): 
     try: 
      # Try to decode a dict 
      newv = json.loads(v, object_hook=convert_subdicts) 
     except Exception: 
      continue 
     else: 
      if isinstance(newv, dict): 
       d[k] = newv # Replace with decoded dict 
    return d 

origdict = {'a': 42, 'b': "my_string", 'c': "{'d': 33, 'e': 'another string'}"} 
newdict = convert_subdicts(origdict.copy()) # Omit .copy() if mutating origdict okay 

这应该递归处理，其中包含dict S可能会发生包含定义subdicts str价值观的情况。如果您不需要处理该情况，则可以省略使用object_hook，或者用ast.literal_eval完全替换json.loads。

Answer 3

我在上面的评论中引用的一般思想是通过字典运行并尝试和评估。将其存储在局部变量中，然后检查评估的表达式是否是字典。如果是，则将其重新分配给通过的输入。如果没有，请保持独立。

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

def convert_to_dict(d): 
    for key, val in d.items(): 
     try: 
      check = ast.literal_eval(val) 
     except: 
      continue 
     if isinstance(check, dict): 
      d[key] = check 
    return d 

convert_to_dict(my_dict) 

Answer 4

您可以检查您是否已经使用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}"}'} 

您需要确保深层复制对象，或者当您有像上面列表的列表一样的嵌套对象时，您将不会得到字典的真实独立副本。

Answer 5

这是一个处理递归的命题。正如评论中所建议的那样，它试图评估一切，然后检查结果是否是字典，如果是我们递归的，否则我们跳过该值。我sligthly改变了最初的字典，以显示它hanldes recusion罚款：

import ast 
my_dict = {'a': 42, 'b': "my_string", 'c': "{'d': 33, 'e': \"{'f' : 64}\"}"} 

def recursive_dict_eval(old_dict): 
    new_dict = old_dict.copy() 
    for key,value in old_dict.items(): 
     try: 
      evaled_value=ast.literal_eval(value) 
      assert isinstance(evaled_value,dict) 
      new_dict[key]=recursive_dict_eval(evaled_value) 

     except (SyntaxError, ValueError, AssertionError): 
      #SyntaxError, ValueError are for the literal_eval exceptions 
      pass 
    return new_dict 

print(my_dict) 
print(recursive_dict_eval(my_dict)) 

输出：

{'a': 42, 'b': 'my_string', 'c': '{\'d\': 33, \'e\': "{\'f\' : 64}"}'} 
{'a': 42, 'b': 'my_string', 'c': {'e': {'f': 64}, 'd': 33}}