如何简洁实现元组列表遍历并筛选最小距离轨迹点？

需求说明 #

我有一个由点元组组成的列表，元组第一个元素来自第一条轨迹traj[0]（代表该点在traj[0]中的索引），第二个元素来自第二条轨迹traj[1]（代表该点在traj[1]中的索引）。需要完成以下处理：

• 若多个元组的第一个元素相同（比如示例中的41、47），则计算每组内每个元组对应点的距离，选取距离最小的traj[1]中的点作为traj[0]对应点；
• 若元组第一个元素唯一，则直接选取对应traj[1]中的点。

输入示例列表 #

[(40, 10),
 (41, 11),
 (41, 12),
 (42, 13),
 (43, 14),
 (44, 15),
 (45, 16),
 (46, 17),
 (47, 18),
 (47, 19),
 (47, 20),
 (48, 21),
 (49, 22)]

尝试的代码（存在局限） #

c=[]
for j in range(len(list)):
             if (j+1)==(len(list)-1):
                if list[j][0]==list[j+1][0]:
                    d=distance(traj[0][j][0],traj[1][j][1])
                    d1=distance(traj[0][j+1][0],traj[1][j+1][1])
                    if (d < d1):    
                            c.append(traj[1][list[j][1]])
                            break
                    elif (d > d1) :
                            c.append(traj[1][list[j+1][1]])  
                            break
                else:
                    c.append(traj[1][list[j][1]])
                    c.append(traj[1][list[j+1][1]])
                    
                    break              
             elif list[j][0]==list[j+1][0]: 
                        d=distance(traj[0][j][0],traj[1][j][1])
                        d1=distance(traj[0][j+1][0],traj[1][j+1][1])
                        if (d < d1): 
                                     c.append(traj[1][list[j][1]])

                        elif (d > d1):
                                     c.append(traj[1][list[j+1][1]])
                                
             elif list[j][0]==list[j-1][0]:  
                continue           
          
             else:
                 c.append(traj[1][list[j][1]]) 

现有问题与预期输出 #

当前代码仅能处理最多2个重复元素的情况，无法适配3个及以上对应点的场景。需要更简洁的实现，同时避免重复点。

预期输出（实际为traj[1]中的坐标）：

c=[10, (11 or 12), 13, 14, 15, 16, 17, (18 or 19 or 20), 21, 22]

优化实现方案 #

通过分组处理的方式，先按元组第一个元素对所有配对点分组，再针对每组计算最小距离对应的点，逻辑清晰且支持任意数量的重复元素：

# 先定义距离计算函数（以欧氏距离为例，可根据需求替换）
def distance(point1, point2):
    return ((point1[0] - point2[0])**2 + (point1[1] - point2[1])**2)**0.5

# 输入的点配对列表
point_pairs = [(40, 10),
 (41, 11),
 (41, 12),
 (42, 13),
 (43, 14),
 (44, 15),
 (45, 16),
 (46, 17),
 (47, 18),
 (47, 19),
 (47, 20),
 (48, 21),
 (49, 22)]

# 步骤1：按traj[0]的索引分组
grouped_pairs = {}
for traj0_idx, traj1_idx in point_pairs:
    if traj0_idx not in grouped_pairs:
        grouped_pairs[traj0_idx] = []
    grouped_pairs[traj0_idx].append(traj1_idx)

# 步骤2：遍历每组，选择距离最小的traj[1]点
result = []
for traj0_idx, traj1_indices in grouped_pairs.items():
    # 唯一配对，直接加入结果
    if len(traj1_indices) == 1:
        result.append(traj[1][traj1_indices[0]])
    else:
        # 计算所有配对点的距离，筛选最小的那个
        min_distance = float('inf')
        best_point = None
        for idx in traj1_indices:
            current_dist = distance(traj[0][traj0_idx], traj[1][idx])
            if current_dist < min_distance:
                min_distance = current_dist
                best_point = traj[1][idx]
        result.append(best_point)

# 可选：如果需要严格按照traj[0]的索引顺序排序（Python3.7+字典默认插入有序，若输入列表已递增可省略）
result = [point for _, point in sorted(zip(grouped_pairs.keys(), result))]

方案优势 #

• 适配任意数量的重复配对点，不管是2个还是更多；
• 逻辑分层清晰，避免了复杂的索引判断，降低出错概率；
• 自动完成去重，每个traj[0]的点仅对应一个最优的traj[1]点。

内容的提问来源于stack exchange，提问作者milad