Question

我的程序生成以下列表（摘录）：

my_list = [{'x': 1764, 'y': 18320, 'class': 'note', 'id': 'd1e2443'},
           {'x': 1764, 'y': 20030, 'class': 'note', 'id': 'd1e2591'},
           {'x': 1807, 'y': 12650, 'class': 'note', 'id': 'd1e1362'},
           {'x': 2243, 'y': 20120, 'class': 'note', 'id': 'd1e2609'},
           {'x': 2243, 'y': 22685, 'class': 'note', 'id': 'd1e2769'},
           {'x': 2257, 'y': 12560, 'class': 'note', 'id': 'd1e1380'},
           {'x': 2688, 'y': 20210, 'class': 'note', 'id': 'd1e2625'},
           {'x': 2707, 'y': 10040, 'class': 'note', 'id': 'd1e1194'},
           {'x': 2707, 'y': 12650, 'class': 'note', 'id': 'd1e1398'},
           {'x': 2707, 'y': 14720, 'class': 'note', 'id': 'd1e1571'},
           {'x': 2901, 'y': 18140, 'class': 'note', 'id': 'd1e2475'}]

它已按＆＃39; x＆＃39; -key的值排序。我正在尝试编写一个方法，该方法返回给定坐标(xPos, yPos)的此列表的两个元素的元组：

左侧最近的元素（x <= xPos）
最靠近右侧的元素（x > xPos）

距离只是欧几里德距离（＆＃34;毕达哥拉斯＆＃34;）。该函数的第二个参数是允许的最大距离：

def getNearest(noteList, posX, posY, maxDistance):
    [...]
    return leftElement, rightElement

我尝试使用bisect函数来获取最接近xPos元素的插入点以及xPos - maxDistance（case＆＃39; left＆＃39;）和{{1 （case＆＃39; right）分别缩小搜索范围。然后我计算了这个切片列表中每个剩余元素的距离

不知何故，这感觉非常不优雅。有没有更好的方法呢？

修改也许我的意图并不是很清楚：我需要列表中的两个元素。 “2D”窗格中最近的元素＆＃39;在左边，一个在右边。因此我也需要考虑y坐标。

可能会发生（几乎每次都是），与x坐标相关的最接近的元素比具有近y坐标的元素更远。

Answer 1

这似乎是一个很好的解决方案，但从你描述它的方式来看，我认为不需要做一个以上的二等分。

bisect_left已经返回元素的索引，以满足您的第一个条件（x <= xPos - maxDistance）。从那里开始，我只需逐个向右迭代元素，直到达到x > xPos + maxDistance。

考虑到CPU缓存，这可能会产生更好的性能，因为您需要iterating adjacent positions instead of jumping around

如果你开始处理大量的点或maxDistance，这个算法可能就不够了。在这种情况下，你应该考虑使用kd-tree，正如wenzul建议的那样。

Answer 2

您可以使用min()查找posX两侧最近的元素，就其欧几里德距离而言。

>>>import math
>>>def getNearest(noteList, posX, posY):
...    leftElement = min([i for i in my_list if i['x'] <= posX], key=lambda x:abs(math.sqrt((x['x']- posX)**2+(x['y']- posY)**2)))
...    rightElement = min([i for i in my_list if i['x'] > posX], key=lambda x:abs(math.sqrt((x['x']- posX)**2+(x['y']- posY)**2)))
...    return (leftElement, rightElement)


>>> getNearest(my_list, 2000, 2000)
({'y': 12650, 'x': 1807, 'class': 'note', 'id': 'd1e1362'}, {'y': 10040, 'x': 2707, 'class': 'note', 'id': 'd1e1194'})

>>> getNearest(my_list, 2000, 20000)
({'y': 20030, 'x': 1764, 'class': 'note', 'id': 'd1e2591'}, {'y': 20120, 'x': 2243, 'class': 'note', 'id': 'd1e2609'})

Key是2D窗格上每个元素与传递给函数的元素之间的欧几里德距离，即(posX, PosY)。

Answer 3

我试图将我最初的想法与答案中的一些建议合并。这就是我想出的：

class translatedDictList(object):
    def __init__(self, dictList, key):
        self.dictList = dictList
        self.key = key

    def __getitem__(self, item):
        return self.dictList[item][self.key]

    def __len__(self):
        return self.dictList.__len__()

def getNearest(self, symbolList, pos, maxDistance):
    translatedList = translatedDictList(symbolList, 'x')

    splitIndex = bisect.bisect(translatedList, pos[0])
    minIndex = bisect.bisect(translatedList, pos[0] - maxDistance)
    maxIndex = bisect.bisect(translatedList, pos[0] + maxDistance)

    # Euclidean distance acutally not needed anymore!
    leftElement = min(symbolList[minIndex:splitIndex],
                      key=lambda n: abs(n['x'] - pos[0]) +
                                    abs(n['y'] - pos[1]))
    rightElement = min(symbolList[splitIndex:maxIndex],
                       key=lambda n: abs(n['x'] - pos[0]) +
                                     abs(n['y'] - pos[1]))

    return leftElement, rightElement

print(getNearest(self.symbolsSorted, (1200, 1500), 1000))

也许有一种更智能的方式来翻译symbolList以便使用bisect()？

它应该是o(log*n)并且据我所知，我甚至不需要再计算欧氏距离，因为我只是比较并且对实际距离不感兴趣。

从词典列表中获取最接近的元素

3 个答案: