【问题标题】:What is the fastest way to return a specific list within a dictionary within a dictionary?在字典中返回特定列表的最快方法是什么?
【发布时间】:2019-07-26 06:58:08
【问题描述】:

我在字典中的字典中有一个列表。数据集非常大。如果给定一个特定于键、字典对的列表,我如何才能最快地返回嵌套在两个字典中的列表?

{"Dict1":{"Dict2": ['UNIOUE LIST'] }} 

为了提高效率,是否有替代的数据结构?

【问题讨论】:

  • 由于python的哈希表,如果你知道两个dict的键应该很快。
  • 你的键是字典?
  • 你能在代码中显示这个吗?
  • @Wonka 是的,关键是字典。它是一个以列表为最终值的嵌套字典。
  • @Alex 这没有意义。尝试使用字典作为键会导致 TypeError: unhashable type: 'dict'。在您的示例中,value 中的内部字典。字符串"Dict1" 是它的关联键。

标签: python algorithm sorting data-structures


【解决方案1】:

我不相信 Python 中存在更高效的数据结构。简单地使用常规索引运算符检索列表应该是一个非常快速的操作,即使两个级别的字典都非常大。

nestedDict = {"Dict1":{"Dict2": ['UNIOUE LIST'] }} 
uniqueList = nestedDict["Dict1"]["Dict2"]

我对提高性能的唯一想法是尝试将数据结构扁平化为一个带有元组作为键的字典。这将比嵌套方法占用更多内存,因为顶级字典中的键将为二级字典中的每个条目复制,但它只会为每次查找计算一次哈希函数。但是这种方法在实践中实际上比嵌套方法要慢:

nestedDict = {i: {j: ['UNIQUE LIST'] for j in range(1000)} for i in range(1000)}
flatDict = {(i, j): ['UNIQUE LIST'] for i in range(1000) for j in range(1000)}

import random

def accessNested():
    i = random.randrange(1000)
    j = random.randrange(1000)
    return nestedDict[i][j]

def accessFlat():
    i = random.randrange(1000)
    j = random.randrange(1000)
    return nestedDict[(i,j)]

import timeit

print(timeit.timeit(accessNested))
print(timeit.timeit(accessFlat))

输出:

2.0440238649971434
2.302736301004188

【讨论】:

    【解决方案2】:

    在嵌套字典中访问列表的最快方法是,

    d = {"Dict1":{"Dict2": ['UNIOUE LIST'] }} 
    
    print(d["Dict1"]["Dict2"])
    

    输出:

    ['UNIOUE LIST'] 
    

    但是,如果您对嵌套字典中的列表执行迭代。所以你可以使用下面的代码作为例子,

    d = {"a":{"b": ['1','2','3','4'] }} 
    
    for i in d["a"]["b"]:
        print(i)
    

    输出:

    1
    2
    3
    4
    

    【讨论】:

      【解决方案3】:

      如果我理解正确,您想访问嵌套字典结构,如果...

      如果给我一个特定于键的列表

      所以,这里有一个示例字典和要访问的键

      d = {'a': {'a': 0, 'b': 1}, 
           'b': {'a': {'a': 2}, 'b': 3}}
      key = ('b', 'a', 'a')
      

      懒惰的方法

      如果您已经了解 Python 字典,这速度很快,无需学习其他内容!

      >>> value = d
      >>> for level in key:
      ...     value = temp[level]
      >>> value
      2
      

      ndicts 包中的 NestedDict

      如果您pip install ndicts,那么您会在更好的界面中获得相同的“惰性方法”实现。

      >>> from ndicts.ndicts import NestedDict
      >>> nd = NestedDict(d)
      >>> nd[key]
      2
      >>> nd["b", "a", "a"]
      2
      

      这个选项很快,因为你不能写比nd[key]更少的代码来得到你想要的。

      Pandas 数据框

      这是可以提高性能的解决方案。数据帧中的查找应该很快,尤其是在您有排序索引的情况下。

      在这种情况下,我们有多个层次的分层数据,所以我将首先创建一个 MultiIndex。为了方便起见,我会使用 NestedDict,但任何其他可以使字典变平的方法都可以。

      >>> keys = list(nd.keys())
      >>> values = list(nd.values())
      >>> from pandas import DataFrame, MultiIndex
      >>> index = MultiIndex.from_tuples(keys)
      >>> df = DataFrame(values, index=index, columns="Data").sort_index()
      >>> df
               Data
      a a NaN     0
        b NaN     1
      b a a       2
        b NaN     3
      

      使用 loc 方法获取一行。

      >>> nd.loc[key]
      Data    2
      Name: (b, a, a), dtype: int64
      

      【讨论】:

        猜你喜欢
        • 2010-11-24
        • 1970-01-01
        • 2020-06-05
        • 2021-11-24
        • 1970-01-01
        • 2018-01-25
        • 1970-01-01
        • 1970-01-01
        • 2019-11-30
        相关资源
        最近更新 更多