Python 管理要点列表，最佳方法？

我的代码遇到了性能问题，决定重写它，需要一些关于如何解决这个问题的建议。 我有一个巨大的光流数据列表，由一个框架，X和Y坐标组成。 像这样：

我在这里上传了一个示例：

我需要找到一种方法来管理这些数据，以便能够快速查找并查看哪些列表包含某些帧

到目前为止，我已经遍历了所有的数据，看看哪些列表包含，比如第34帧和第35帧，然后将它们索引到一个新的列表中以供参考

thisFrame = 34
nextFrame = thisFrame + 1
if any(e[0] == thisFrame for e in item) and any(e[0] == nextFrame for e in item): #Check if the item contains this frame and next
    DoStuff()

对一个10.000+点的列表这样做几千次很快就会变成瓶颈。因此，我的想法是为每一帧制作一个dict，这样就可以很容易地找到某一帧上可用的项目：

{frame, [list1,list2,list3]}

但我想这次我最好问一下。 有没有一种好的goto方法来存储并能够在大数据集中进行查找，以避免每次需要查找时都遍历所有数据集？

是Python最优化的数据结构之一。将数据转换为字典需要一些时间，但之后，查找（例如，项中的thisFrame）会及时完成，这比列表快得多

您最好使用以下代码将其转换为字典：

注意：看起来您的列表嵌套了两次，如果不是这样，您必须稍微修改迭代

item_dict = {}
for big_lst in item:
    for lst in big_lst:
        try:
            item_dict[lst[0]] += [lst[1:],] # Append to existing value
        except KeyError:
            item_dict[lst[0]] = [lst[1:],] # Initialize value

编辑02/05:try/except更快

item_dict

将如下所示，合并重复帧，以便单帧查找将返回[x，y]对的列表

item_dict = {
    1: [list1, list2, list3]
    2: [list1, list2]
    3: [list1]
    4: [list1, list2, list3]
}

从那时起，查找速度将非常快：

thisFrame = 34
nextFrame = thisFrame + 1
if thisFrame in item_dict and nextFrame in item_dict:
    foo = item_dict[thisFrame] # e.g. [list1, list2]
    bar = item_dict[nextFrame] # e.g. [list1, list2, list3]
    DoStuff()

如果需要跟踪单个[x，y]对所属的父列表，可以在每个列表中添加一个附加元素，该元素将父列表的索引存储在

项中

：

item_dict = {}
for list_index, big_lst in enumerate(item):
    for lst in big_lst:
        if lst[0] in item_dict:
            item_dict[lst[0]] += [lst[1:]+[list_index],] # Append
        else:
            item_dict[lst[0]] = [lst[1:]+[list_index],] # Initialize

然后，像这样的查找

parent_list = item_dict[thisFrame][2] # [x, y, list_index]

将返回可访问的父列表：

item[parent_list]

---

我在这里要做的是：

首先，我试图通过创建一个名为frame的字典，将所有x，y合并到唯一的frame。 其次，我通过将值转换为键和键转换为值来还原字典

请让我知道这是否有效：否则我将修改或删除它

#!/usr/bin/python

import ast

dict_frame = dict()
def generate_datastructure():
    l = ''
    with open('2d_optical_tracking_data.txt', 'r') as fh:
        l = ast.literal_eval(fh.read())
    frame = dict()
    for ls in l:
        for elm in ls:
            key = elm[0]
            val_list = elm[1:]
            frame.setdefault(key, [])
            frame[key].extend(val_list)

    # convert all the value into set:
    for key, val in frame.iteritems():
        dict_frame[tuple(set(val))] = key

def lookup(key):
    print dict_frame

if __name__ == '__main__':
    tofind = '45.835999'
    generate_datastructure()
    for key, val in dict_frame.iteritems():
        if tofind in key:
            print val

---

我撞到了性能墙

你是怎么得出这个结论的？你有重复的帧吗？如果没有，您最好不要存储

帧

，并根据您想要请求的帧导出索引。那么，我可以合并这两个帧：[[110，'79.607002'，'76.638']，[111，'61.595001'，'85.915001']和[[110，'257.90201'，'108.176']，[111，'232.58501'，'108.98']@yopy我想可以，这实际上可以避免

any（）

查找。他的查找不是关键，他试图从匹配的值中找出关键，这就是我所理解的，所以不是O（1）@yopy这两个

any

函数返回一个布尔值，用于检查

项中任何列表的第一个索引中是否存在
thisFrame
和
nextFrame
。我相信在我答案的末尾查字典也会做同样的事情？这正是我所想的。在字典中有索引，以引用主结构。谢谢大家的帮助！
#!/usr/bin/python

import ast

dict_frame = dict()
def generate_datastructure():
    l = ''
    with open('2d_optical_tracking_data.txt', 'r') as fh:
        l = ast.literal_eval(fh.read())
    frame = dict()
    for ls in l:
        for elm in ls:
            key = elm[0]
            val_list = elm[1:]
            frame.setdefault(key, [])
            frame[key].extend(val_list)

    # convert all the value into set:
    for key, val in frame.iteritems():
        dict_frame[tuple(set(val))] = key

def lookup(key):
    print dict_frame

if __name__ == '__main__':
    tofind = '45.835999'
    generate_datastructure()
    for key, val in dict_frame.iteritems():
        if tofind in key:
            print val