【问题标题】:Split dictionary of lists into list of dictionaries将列表字典拆分为字典列表
【发布时间】:2010-12-19 07:21:35
【问题描述】:

我需要做的是转换这样的东西

{'key1': [1, 2, 3], 'key2': [4, 5, 6]}

进入

[{'key1': 1, 'key2': 4}, {'key1': 2, 'key2': 5}, {'key1': 3, 'key2': 6}]

值列表的长度可以变化! 最快的方法是什么(最好不使用 for 循环)?

【问题讨论】:

  • 您可能想稍微澄清一下您的问题...我花了一些时间从您的示例中了解您想要什么:转换带有两个键(key1,key2)的地图,每个键都有一个列表将值(相同但长度不同)添加到一对列表中,并且在位置 i 的位置中,key1 和 key2 设置为它们各自列表的第 i 个元素。是这样吗?
  • 为什么对没有 for 循环的操作如此着迷?这是一个愚蠢的约束。
  • 这不是必须的,我写了“最好”。认为可能有一种快速的pythonic方式来做到这一点(一些我还不知道的神奇功能;))

标签: python


【解决方案1】:

如果你总是可以使用两个键:

[{'key1':a, 'key2':b} for (a,b) in zip(d['key1'], d['key2'])]

【讨论】:

    【解决方案2】:
    >>> a = {'key1': [1, 2, 3], 'key2': [4, 5, 6]}
    >>> [dict((key, a[key][i]) for key in a.keys()) for i in range(len(a.values()[0]))]
    [{'key2': 4, 'key1': 1}, {'key2': 5, 'key1': 2}, {'key2': 6, 'key1': 3}]
    

    【讨论】:

    • 值列表的长度可以变化。 range(3) 相当稳定。
    【解决方案3】:
    d = {'key1': [1, 2, 3], 'key2': [4, 5, 6]}
    
    keys = d.keys()
    vals = zip(*[d[k] for k in keys])
    l = [dict(zip(keys, v)) for v in vals]
    print l
    

    生产

    [{'key2': 4, 'key1': 1}, {'key2': 5, 'key1': 2}, {'key2': 6, 'key1': 3}]
    

    【讨论】:

      【解决方案4】:

      假设键的数量和每个键的值都是任意的且先验未知,当然,使用 for 循环获得结果是最简单的:

        itit = thedict.iteritems()
        k, vs = next(itit)
        result = [{k: v} for v in vs]
        for k, vs in itit:
          for d, v in itertools.izip(result, vs):
            d[k] = v
      

      它可以被折叠,但我怀疑这样做的性能影响(如果所涉及的数据结构如此庞大以至于需要进行性能优化,那么在内存中构建任何超出严格要求的额外辅助结构可能会变得昂贵-- 我的这种简单方法特别小心,以避免任何此类中间结构)。

      编辑:另一种选择,如果整体数据结构很大但在某些用例中您可能只需要“转换”结构的“点点滴滴”,则特别有趣,即构建一个类它提供了您需要的界面,但它是“即时”完成的,而不是“大爆炸”、“一劳永逸”的转换(如果原始结构可以改变并且转换后的结构需要改变,这可能特别有用)反映原件的现状等)。

      当然,出于这样的目的,准确确定您的下游代码将使用“字典列表”的哪些功能非常有帮助。例如,假设您实际上需要的只是“只读”索引(不更改、迭代、切片、排序……):X[x] 必须返回一个字典,其中每个键 k 映射到一个值,使得(校准O 列表的原始字典)X[x][k] is O[k][x]。那么:

      class Wrap1(object):
        def __init__(self, O):
          self.O = O
        def __getitem__(self, x):
          return dict((k, vs[x]) for k, vs in self.O.iteritems())
      

      如果您实际上不需要包装结构来跟踪对原始结构的修改,那么__getitem__ 也可以“缓存”它返回的字典:

      class Wrap2(object):
        def __init__(self, O):
          self.O = O
          self.cache = {}
        def __getitem__(self, x):
          r = self.cache.get(x)
          if r is None:
            r = self.cache[x] = dict((k, vs[x]) for k, vs in self.O.iteritems())
          return r
      

      请注意,这种方法最终可能会在缓存中产生一些重复,例如,如果 O 的列表每个有 7 个项目,则 x==6 和 x==-1 的缓存可能会以两个相等的字典结束;如果这是一个问题,例如,您可以通过在继续之前向它们添加 len(self.O) 来规范化 __getitem__ 中的负 xs。

      如果您还需要迭代以及这个简单的索引,那并不难:只需添加一个 __iter__ 方法,易于实现,例如作为一个简单的生成器...:

        def __iter__(self, x):
          for i in xrange(len(self.O)):
            yield self[i]
      

      等等,逐渐地,如果你需要越来越多的列表功能(最坏的情况是,一旦你实现了这个__iter__,你就可以构建self.L = list(self)——恢复到“大爆炸”方法-- 并且,对于任何进一步的请求,请发送至self.L... 但如果您想对 special 方法也采用这种方法,或者使用一些更微妙的技巧,例如self.__class__ = list; self[:] = self.L,然后是适当的dels;-)。

      【讨论】:

        【解决方案5】:
        list(map( dict, zip(*([(key, val) for val in data[key]] for key in data.keys()))))
        

        【讨论】:

          【解决方案6】:

          没有for循环,map的内部过程实际上是在迭代,只是没有关键字for

          >>> x={'key1': [1, 2, 3], 'key2': [4, 5, 6]}
          
          >>> map(lambda x,y:{'key1':x,'key2':y},x['key1'],x['key2'])
          
          [{'key2': 4, 'key1': 1}, {'key2': 5, 'key1': 2}, {'key2': 6, 'key1': 3}]
          

          【讨论】:

            【解决方案7】:

            适用于任意数量的键

            >>> map(dict, zip(*[[(k, v) for v in value] for k, value in d.items()]))
            [{'key2': 4, 'key1': 1}, {'key2': 5, 'key1': 2}, {'key2': 6, 'key1': 3}]
            

            例如:

            d = {'key3': [7, 8, 9], 'key2': [4, 5, 6], 'key1': [1, 2, 3]}
            
            >>> map(dict, zip(*[[(k, v) for v in value] for k, value in d.items()]))
            [{'key3': 7, 'key2': 4, 'key1': 1}, {'key3': 8, 'key2': 5, 'key1': 2}, {'key3': 9, 'key2': 6, 'key1': 3}]
            

            适用于任意数量的值或键的通用解决方案:(python2.6)

            >>> from itertools import izip_longest
            >>> d = {'key2': [3, 4, 5, 6], 'key1': [1, 2]}
            >>> map(lambda a: dict(filter(None, a)), izip_longest(*[[(k, v) for v in value] for k, value in d.items()]))
            [{'key2': 3, 'key1': 1}, {'key2': 4, 'key1': 2}, {'key2': 5}, {'key2': 6}]
            

            如果你没有python2.6:

            >>> d = {'key2': [3, 4, 5, 6], 'key1': [1, 2]}
            >>> map(lambda a: dict(filter(None, a)), map(None, *[[(k, v) for v in value] for k, value in d.items()]))
            [{'key2': 3, 'key1': 1}, {'key2': 4, 'key1': 2}, {'key2': 5}, {'key2': 6}]
            

            【讨论】:

              【解决方案8】:

              怎么样?

              d = {'key1': [1, 2, 3], 'key2': [4, 5, 6]}
              [dict(zip(d.keys(),i)) for i in zip(*d.values())]
              

              返回:

              [{'key1': 1, 'key2': 4}, {'key1': 2, 'key2': 5}, {'key1': 3, 'key2': 6}]
              

              【讨论】:

                猜你喜欢
                • 2011-05-04
                • 2021-09-09
                • 1970-01-01
                • 2020-04-23
                • 1970-01-01
                • 1970-01-01
                • 1970-01-01
                • 2021-10-23
                • 1970-01-01
                相关资源
                最近更新 更多