如何有效地将已排序字典的字典展平为 numpy.arrays

如何解决如何有效地将已排序字典的字典展平为 numpy.arrays

我想知道是否有更有效的方法来展平我的数据。请参阅以下扁平化数据结构的示例：

 {t: SortedDict(
    {0: {'t': 5,'ids': [{'1': ['data']}]},1: {'t': 2,2: {'t': 4,3: {'t': 1,4: {'t': 4,5: {'t': 1,6: {'t': 3,7: {'t': 2,8: {'t': 1,9: {'t': 1,'ids': [{'1': ['data']}]}
    }),t:SortedDict(
    {
    27: {'t': 1,'ids': [{'5': ['data','data']}]},28: {'t': 1,'data',29: {'t': 2,30: {'t': 1,'ids': [{'5': ['data']}]},31: {'t': 2,32: {'t': 1,'ids': [{'5': ['data']}]}
    })}

注意：SortedDict 来自 Sorted Containers 库，它是一个 Apache2 许可的 Python 排序集合。

我评估了其他几篇 stackoverflow 帖子，它们在列表理解或 lambda 函数方面做了类似的事情。最终，我写了一个方法，将字典扁平化为三个列表；但是，我不确定这种方法是否是最佳方法。方法如下：

def flatten(self,d,calculation_dict):
    l_key       = [] # Stores linearized keys
    l_results   = [] # Stores linearized values after calculation
    index       = [] # Stores the start of each individual sub-array
    i = 0
    for val in d.values():
            index.append(i)
            for key,t in val.t.items():
                #Add calculation in here since I am Iterating over every element
                l_results.append(t["t"] *  calculation_dict[key]) 
                l_key.append(key)
                i += 1
    h_index = numpy.array(index,dtype=numpy.int32)
    h_l_results = numpy.array(l_results,dtype=numpy.float)
    l_key = numpy.array(l_key,dtype=numpy.int32)
    index.append(i) 
    return (l_key,l_results,index)
    
    #Need output to be numpy.array
    l_key       = [0,1,2,3,4,5,6,7,8,9,27,28,29,30,31,32]
    l_results   = [5.0,2.0,4.0,1.0,3.0,0]
    index       = [0,10]

在我的应用程序中速度极其重要。因此，任何反馈或建议将不胜感激。

编辑：忘了提到我需要在一个 numpy 数组中的最终结果。不确定这是否会改变什么。

编辑：感谢 Glauco 的建议，我修改了扁平化方法如下：

def flatten_numpy(self,calculation_dict):
        l_results   = numpy.empty(self.size,dtype=numpy.float)
        l_key       = numpy.empty(self.size,dtype=numpy.int32)
        index       = []
        i = 0
        for val in d.values():
                index.append(i)
                for key,t in val.t.items():
                    l_results[i] = (tf["tf"] *  idf[term]) 
                    l_key[i] = term
                    i += 1
        index.append(i) 
        h_index = numpy.array(index,dtype=numpy.int32)
        return (l_key,index)

事实证明，在算法的早期，我已经不得不访问每个子字典的大小。利用这一点，我开始累积这个值大小变量，在测试新方法后，它稍微快了一点。测试结果如下：

#Each Test was executed on the different data and ran 1000 times
Test#1 | Flatten        6.422301292419434   | Flatten_numpy     4.761376142501831
Test#2 | Flatten        5.212526082992554   | Flatten_numpy     4.901215553283691
Test#3 | Flatten        5.2060017585754395  | Flatten_numpy     5.266955852508545
Test#4 | Flatten        6.079436302185059   | Flatten_numpy     4.803238153457642
Test#5 | Flatten        5.059106349945068   | Flatten_numpy     4.565468788146973

解决方法

您的方法在算法上是正确的，它是 O(n+m) 它是线性的，没有其他方法。如果您知道 haom 许多 dict 将从集群到达，那么创建空的 numpy 数据结构并在运行时填充它会更方便，避免列表追加。

最后，t 计算：

l_results.append(t["t"] *calculation_dict[key])

可以在收集阶段的底部使用数组快速完成