如何避免在遍历数据帧时进行很长时间的python计算

我试图在数据帧中添加两列，以根据距离计算每个方向和每个时间帧内每辆车的车辆周围邻居50和邻居100，如果距离低于50，我将向邻居50添加一个计数，以此类推，我应该只使用熊猫来完成此任务

我应该根据每辆车的x和y位置，通过以下等式计算距离：

距离=（（x2-x1）**2+（y2-y1）**2）**0.5

我使用了以下代码：

#import numpy as np

df['neighbor_50'] = 0
df['neighbor_100'] = 0
frame_group =  df.groupby(['frame','direction'])
list_keys = list(frame_group.indices.keys())

for key in list_keys :
    frame , direction = key[0] , key[1]
    #new_df =  df.loc[(df['frame'] == frame) & (df['direction'] == direction)]
    mask1 = (df['frame'] == frame) & (df['direction'] == direction) 
    ids = df[mask1]['id']
    for i in ids:
        for j in ids:
            if i != j:
                #distance = sqrt((x2-x1)**2 + (y2-y1)**2)
                maski = (df['frame'] == frame) & (df['direction'] == direction)& (df['id'] == i)
                maskj = (df['frame'] == frame) & (df['direction'] == direction)& (df['id'] == j)
                x2 = df[maski]['x'].iloc[0]
                x1 = df[maskj]['x'].iloc[0]
                y2 = df[maski]['y'].iloc[0]
                y1 = df[maskj]['y'].iloc[0]
                
                distance = ((x2 - x1)**2 + (y2 - y1)**2)**0.5
                #distance = np.hypot((x2 - x1),(y2 - y1))
                mask = (df['frame'] == frame) & (df['direction'] == direction) &( df['id']== i)
                if distance <= 50:
                    df.loc[mask , 'neighbor_50'] += 1
                if distance <= 100 :
                    df.loc[mask ,'neighbor_100'] += 1

#将numpy作为np导入
df['neighbor_50']=0
df['neighbor_100']=0
frame_group=df.groupby（['frame'，'direction']）
list\u keys=list（frame\u group.index.keys（））
对于输入列表中的键，请执行以下操作：
帧，方向=键[0]，键[1]
#新的_df=df.loc[（df['frame']=frame）&（df['direction']=direction）]
mask1=（df['frame']==帧）和（df['direction']==方向）
ids=df[mask1]['id']
对于ID中的i：
对于ID中的j：
如果我j:
#距离=sqrt（（x2-x1）**2+（y2-y1）**2）
maski=（df['frame']==frame）&（df['direction']==direction）&（df['id']==i）
maskj=（df['frame']==frame）&（df['direction']==direction）&（df['id']==j）
x2=df[maski]['x'].iloc[0]
x1=df[maskj]['x'].iloc[0]
y2=df[maski][y'].iloc[0]
y1=df[maskj]['y'].iloc[0]
距离=（（x2-x1）**2+（y2-y1）**2）**0.5
#距离=np.hypot（（x2-x1），（y2-y1））
掩码=（df['frame']==frame）&（df['direction']==direction）&（df['id']==i）
如果距离有几种方法可以做到这一点，但如果不使用
scipy
或
numpy
，这可能是最快的：

导入熊猫
#仅用于生成测试数据
随机输入
进口itertools
#仅用于调试（显示进度条）
从TQM导入TQM
tqdm.pandas（）
#生成一些逼真的测试数据
df=1.DataFrame(
itertools.chain.from_iterable(
[
[
{
“id”：int（标识符），
“框架”：框架，
“方向”：random.randint（0,1），
“x”：random.random（）*random.randint（-100100），
“y”：random.random（）*random.randint（-100100），
}
用于范围内的帧（50）
]
用于范围内的标识符（100）
]
)
)
def get_neighbor_count（组：pandas.DataFrame）->pandas.DataFrame:
“”“函数，该函数获取一定距离（50和100个单位）内的邻居数，以及
在同一个方向。
Args：
组（pandas.DataFrame）：输入数据帧（同一时间段内的所有ID）
返回：
pandas.DataFrame：与邻居数相同的数据帧
"""
#自身的笛卡尔积（将整个数据帧与自身连接起来）
组[“键”]=0
组[“索引”]=组索引
group_笛卡尔=group.merge（group，on=“key”，后缀=（“”，“_目标”）。删除(
列=[“键”]
)
#使用self筛选出组合（距离==0）
group_cartesian=group_cartesian.loc[
组笛卡尔[“id”！=组笛卡尔[“id\u目标”]
]
只考虑在同一方向上的组合
group_cartesian=group_cartesian.loc[
组笛卡尔[“方向”]==组笛卡尔[“方向”]
]
#计算点之间的距离（函数：距离=（（x2-x1）**2+（y2-y1）**2）**0.5）
组笛卡尔[“距离”]=(
（组笛卡尔[“x”]-组笛卡尔[“x”]）**2
+（组笛卡尔[“y”]-组笛卡尔[“y”]）**2
) ** 0.5
#设置索引（将结果匹配回组所需）
组笛卡尔=组笛卡尔。设置索引（“索引”）
#选择小于50或小于100的行
在_50=group_cartesian.loc[group_cartesian[“distance”]中，有几种方法可以做到这一点，但这可能是不使用
scipy
或
numpy
的最快方法：

导入熊猫
#仅用于生成测试数据
随机输入
进口itertools
#仅用于调试（显示进度条）
从TQM导入TQM
tqdm.pandas（）
#生成一些逼真的测试数据
df=1.DataFrame(
itertools.chain.from_iterable(
[
[
{
“id”：int（标识符），
“框架”：框架，
“方向”：random.randint（0,1），
“x”：random.random（）*random.randint（-100100），
“y”：random.random（）*random.randint（-100100），
}
用于范围内的帧（50）
]
用于范围内的标识符（100）
]
)
)
def get_neighbor_count（组：pandas.DataFrame）->pandas.DataFrame:
“”“函数，该函数获取一定距离（50和100个单位）内的邻居数，以及
在同一个方向。
Args：
组（pandas.DataFrame）：输入数据帧（同一时间段内的所有ID）
返回：
pandas.DataFrame：与邻居数相同的数据帧
"""
#自身的笛卡尔积（将整个数据帧与自身连接起来）
组[“键”]=0
组[“索引”]=组索引
group_笛卡尔=group.merge（group，on=“key”，后缀=（“”，“_目标”）。删除(
列=[“键”]
)
#使用self筛选出组合（距离==0）
group_cartesian=group_cartesian.loc[
组笛卡尔[“id”！=组笛卡尔[“id\u目标”]
]
只考虑在同一方向上的组合
group_cartesian=group_cartesian.loc[
组笛卡尔[“方向”]==组笛卡尔[“方向”]
]
#计算点之间的距离（函数：距离=（（x2-x1）**2+（y2
import numpy as np

df['neighbor_50'] = 0
df['neighbor_100'] = 0
frame_group =  df.groupby(['frame','direction'])
list_keys = list(frame_group.indices.keys())

for key in list_keys :
    frame , direction = key[0] , key[1]
    #new_df =  df.loc[(df['frame'] == frame) & (df['direction'] == direction)]
    mask = (df['frame'] == frame) & (df['direction'] == direction) 
    ids = df[mask]['id'].values
    for i in range(len(ids)-1):
        id1 = ids[i]
        for j in range(i+1,len(ids)):
            id2 = ids[j]
            
            maski = (df['frame'] == frame) & (df['direction'] == direction)& (df['id'] == id1)
            maskj = (df['frame'] == frame) & (df['direction'] == direction)& (df['id'] == id2)
            x2 = df[maski]['x'].iloc[0]
            x1 = df[maskj]['x'].iloc[0]
            y2 = df[maski]['y'].iloc[0]
            y1 = df[maskj]['y'].iloc[0]
            
            #distance = ((x2 - x1)**2 + (y2 - y1)**2)**0.5
            distance = np.hypot((x2 - x1),(y2 - y1))
           
            if distance <= 100 :
                df.loc[maski ,'neighbor_100'] += 1
                df.loc[maskj ,'neighbor_100'] += 1
                
                if distance <= 50:
                    df.loc[maski , 'neighbor_50'] += 1
                    df.loc[maskj , 'neighbor_50'] += 1