python - 使用 Pandas 识别最近的物体

Question

我有一项可以使用任何编程语言完成的作业。我选择了 Python 和 Pandas，因为我几乎没有使用它们的经验，并认为这将是一个很好的学习体验。我能够使用我从传统计算机编程中知道的传统循环完成任务，并且它可以在数千行上正常运行，但是一旦我让它处理数百万行，它就会使我的笔记本电脑突然停止。任务概述如下。

你在二维平面上有一条两车道的道路。一条车道供汽车使用，另一条车道保留供卡车使用。数据如下所示(每个表跨越数百万行):

汽车

   id  start  end
0  C1    200  215
1  C2    110  125
2  C3    240  255
...

卡车

   id  start  end
0  T1    115  175
1  T2    200  260
2  T3    280  340
3  T4     25   85
...

上面的两个数据框对应于:



开始 和 结束 列代表道路上的任意位置，其中 开始 = 车辆的后缘和 结束 = 车辆的前缘。

任务是识别离每辆车最近的卡车。一辆卡车与一辆汽车最多可以有三种不同的关系:

Back - 它在汽车的后面 ( cars.end > trucks.end )

对面 - 它在汽车对面 ( cars.start >= trucks.start and cars.end <= trucks.end )

前面 - 它在汽车前面 ( cars.start < trucks.start )

我强调“最多”，因为如果后面或前面有另一辆车离最近的卡车更近，那么这种关系就被忽略了。在上图的情况下，我们可以观察到以下情况:

C1:背面 = T1，横向 = T2，正面 = 无(C3 阻塞)

C2:背面 = T4，横向 = 无，正面 = T1

C3:后 = 无(C1 阻塞)，横向 = T2，前 = T3

最终输出需要附加到 cars数据框以及以下新列:

数据交叉引用自 trucks数据框

对于背部位置，间隙距离 ( cars.start - trucks.end )

对于前部位置，间隙距离 ( trucks.start - cars.end )

最后 cars数据框应如下所示:

   id  start  end  back_id  back_start  back_end  back_distance  across_id  across_start  across_end  front_id  front_start  front_end  front_distance
0  C1    200  215       T1         115       175             25         T2           200         260
1  C2    110  125       T4          25        85             25                                             T1          115        175             -10
2  C3    240  255                                                       T2           200         260        T3          280        340              25

Pandas 甚至是完成这项任务的最佳工具吗？如果有一个更合适的工具可以有效地根据数百万行的一些计算交叉引用和附加列，那么我全神贯注。

Answer 1

所以对于 Pandas ，你可以使用 merge_asof ，这是一种方法，可能对数百万行效率不高:

#first sort values
trucks = trucks.sort_values(['start'])
cars = cars.sort_values(['start'])

#create back condition
df_back = pd.merge_asof(trucks.rename(columns={col:f'back_{col}' 
                                               for col in trucks.columns}), 
                        cars.assign(back_end=lambda x: x['end']), 
                        on='back_end', direction='forward')\
            .query('end>back_end')\
            .assign(back_distance=lambda x: x['start']-x['back_end'])

#create across condition: here note that cars is the first of the 2 dataframes
df_across = pd.merge_asof(cars.assign(across_start=lambda x: x['start']),
                          trucks.rename(columns={col:f'across_{col}' 
                                                 for col in trucks.columns}), 
                          on=['across_start'], direction='backward')\
              .query('end<=across_end')

#create front condition
df_front = pd.merge_asof(trucks.rename(columns={col:f'front_{col}' 
                                                for col in trucks.columns}), 
                         cars.assign(front_start=lambda x: x['start']), 
                         on='front_start', direction='backward')\
             .query('start<front_start')\
             .assign(front_distance=lambda x: x['front_start']-x['end'])

# merge all back to cars
df_f = cars.merge(df_back, how='left')\
           .merge(df_across, how='left')\
           .merge(df_front, how='left')

你得到

print (df_f)
   id  start  end back_id  back_start  back_end  back_distance  across_start  \
0  C2    110  125      T4        25.0      85.0           25.0           NaN   
1  C1    200  215      T1       115.0     175.0           25.0         200.0   
2  C3    240  255     NaN         NaN       NaN            NaN         240.0   

  across_id  across_end front_id  front_start  front_end  front_distance  
0       NaN         NaN       T1        115.0      175.0           -10.0  
1        T2       260.0      NaN          NaN        NaN             NaN  
2        T2       260.0       T3        280.0      340.0            25.0