1

我有一个嵌套的列表元组列表（元组等），如下所示：

[(' person', 
[(('surname', u'Doe', True),), 
(('name', u'John', False),), 
('contact', 
[(('email', u'john@doe.me', True),), 
(('phone', u'+0123456789', False),), 
(('fax', u'+0987654321', False),)]), 
('connection', 
[(('company', u'ibcn', True),), 
('contact', 
[(('email', u'mail@ibcn.com', True),), 
(('address', u'main street 0', False),), 
(('city', u'pythonville', False),), 
(('fax', u'+0987654321', False),)])])])]

既无法知道列表中（双）元组的数量，也无法知道嵌套的深度。

我想将其转换为嵌套字典（字典），消除布尔值，如下所示：

{'person': {'name': 'John', 'surname': 'Doe', 
    'contact': {'phone': '+0123456789', 'email': 'john@doe.me','fax': '+0987654321',
    'connection': {'company name': 'ibcn', 'contact':{'phone': '+2345678901',
                   'email': 'mail@ibcn.com', 'address': 'main street 0'
                   'city': 'pythonville', 'fax': +0987654321'
}}}}}

到目前为止，我所拥有的只是一种递归方法，可以以每行的方式打印嵌套结构：

def tuple2dict(_tuple):
    for item in _tuple:
        if type(item) == StringType or type(item) == UnicodeType:
            print item
        elif type(item) == BooleanType:
            pass
        else:
            tuple2dict(item)

但是，我不确定我是否走在正确的轨道上......

编辑：我已经编辑了原始结构，因为它缺少逗号。

4

4 回答 4

3

你在正确的轨道上。递归方法将起作用。据我从您的示例数据中可以看出，每个元组首先都有字符串项，其中包含键。之后，您有另一个元组或列表作为值，或者一个字符串值后跟一个布尔值 true 或 false。

编辑：

递归的诀窍是你必须知道什么时候停止。基本上，在您的情况下，最深的结构似乎是嵌套的三个元组，将名称与值匹配。

偷偷摸摸。我可耻地承认这是世界上最丑陋的代码。

def tuple2dict(data):
    d = {}
    for item in data:
        if len(item) == 1 and isinstance(item, tuple):
            # remove the nested structure, you may need a loop here
            item = item[0]
            key = item[0]
            value = item[1]
            d[key] = value
            continue
        key = item[0]
        value = item[1]
        if hasattr(value, '__getitem__'):
            value = tuple2dict(value)
        d[key] = value
    return d
于 2012-09-12T23:27:39.593 回答
1

不漂亮......但它有效......基本上

def t2d(t):
 if isinstance(t,basestring):return t
 length = len(t)
 if length == 1:
     return t2d(t[0])
 if length == 2:

     t1,t2 = t2d(t[0]),t2d(t[1])
     print "T:",t1,t2
     if isinstance(t1,dict) and len(t1) == 1:
         t2['name'] = t1.values()[0]
         t1 = t1.keys()[0]
     return dict([[t1,t2]])
 if length == 3 and isinstance(t[2],bool):
     return t2d(t[:2])

 L1 =[t2d(tp) for tp in t]
 L2 = [lx.items() for lx in L1]
 L3 = dict( [i[0] for i in L2])
 return L3

我应该提到它特别适用于您发布的 dict...（似乎公司设置不正确，所以我破解了它（参见 t2['name']...））

于 2012-09-13T00:38:49.440 回答
0

你绝对是在正确的轨道上。递归函数是要走的路。

可以从长度为 2 的可迭代元组构建字典。现在，要摆脱布尔值，您可以使用切片。只需切掉除前两个元素之外的所有内容。

 >> (1,2,3)[:3]
 (1,2)
于 2012-09-12T23:31:06.037 回答
0

这是我的最终解决方案。不是很优雅，我必须承认。它还通过将密钥与现有条目连接来处理密钥的多个条目。

def tuple2dict(_obj):
    _dict = {}
    for item in _obj:
        if isinstance(item, tuple) or isinstance(item, list):
            if isinstance(item[0], basestring):
                _dict[item[0]] = tuple2dict(item[1])
            else:
                if isinstance(item[0], tuple):
                    # if the key already exists, then concatenate the old
                    # value with the new one, adding a space in between.
                    _key = item[0][0]
                    if _key in _dict:
                        _dict[_key] = " ".join([_dict[_key], item[0][1]])
                    else:
                        _dict[_key] = item[0][1]
    return _dict
于 2012-09-13T11:37:33.293 回答