Python Numpy查找与数组匹配的数字_Python_Arrays_Numpy

Python Numpy查找与数组匹配的数字

python arrays numpy

Python Numpy查找与数组匹配的数字,python,arrays,numpy,Python,Arrays,Numpy,非常感谢您的帮助！！过去几天我一直在努力解决这个问题我有两个阵列：作为pd进口熊猫 OldDataSet = { 'id': [20,30,40,50,60,70] ,'OdoLength': [26.12,43.12,46.81,56.23,111.07,166.38]} NewDataSet = { 'id': [3000,4000,5000,6000,7000,8000] ,'OdoLength': [25.03,42.12,45.74,46,110.05,165.41]

非常感谢您的帮助！！过去几天我一直在努力解决这个问题

我有两个阵列：作为pd进口熊猫

 OldDataSet = {
 'id': [20,30,40,50,60,70]
 ,'OdoLength': [26.12,43.12,46.81,56.23,111.07,166.38]}

 NewDataSet = {
 'id': [3000,4000,5000,6000,7000,8000]
 ,'OdoLength': [25.03,42.12,45.74,46,110.05,165.41]}

 df1= pd.DataFrame(OldDataSet)
 df2 = pd.DataFrame(NewDataSet)

 OldDataSetArray = df1.as_matrix()
 NewDataSetArray = df2.as_matrix()

我试图得到的结果是：

数组1和数组2根据数组2中剩余的数字按差进行匹配

20  26.12   3000    25.03   
30  43.12   4000    42.12   
40  46.81   6000    46  
50  56.23   7000    110.05  
60  111.07  8000    165.41  
70  166.38  0   0

从ID为20的数组1开始，查找最接近的一个，在本例中，它将是ID为3000的数组2中的第一个数字（26.12-25.03）。所以ID为20，与3000匹配。更棘手的是，如果数组2中的一个值不是最接近的，则跳过它。例如，将ID40值46.81与45.74、46进行比较，46 ID6000中的最小值为.81。所以ID40-->ID6000。现在跳过阵列2中的ID 5000，以便将来进行任何比较。因此，现在在比较数组1 ID 50时，它将与数组2中的下一个可用数字110.05进行比较。阵列1 ID 50与阵列2 ID 7000匹配

更新

这是我尝试过的代码，它是有效的。是的，这不是最好的，所以如果有人有其他建议，请让我知道

 import pandas as pd
 import operator 

 OldDataSet = {
 'id': [20,30,40,50,60,70]
 ,'OdoLength': [26.12,43.12,46.81,56.23,111.07,166.38]}

NewDataSet = {
'id': [3000,4000,5000,6000,7000,8000]
,'OdoLength': [25.03,42.12,45.74,46,110.05,165.41]}

df1= pd.DataFrame(OldDataSet)
df2 = pd.DataFrame(NewDataSet)

OldDataSetArray = df1.as_matrix()
NewDataSetArray = df2.as_matrix()




newPos = 1
CurrentNumber = 0
OldArrayLen = len(OldDataSetArray) -1
NewArrayLen = len(NewDataSetArray) -1
numberResults = []

for oldPos in range(len(OldDataSetArray)):
PreviousNumber =  abs(OldDataSetArray[oldPos, 0]- NewDataSetArray[oldPos, 0])


 while newPos <= len(NewDataSetArray) - 1:   
    CurrentNumber = abs(OldDataSetArray[oldPos, 0] - NewDataSetArray[newPos, 0])

#if it is the last row for the inner array, then match the next available 
#in Array 1 to that last record
    if newPos == NewArrayLen and oldPos < newPos and oldPos +1 <= OldArrayLen:
       numberResults.append([OldDataSetArray[oldPos +1, 1],NewDataSetArray[newPos, 1],OldDataSetArray[oldPos +1, 0],NewDataSetArray[newPos, 0]])

    if PreviousNumber < CurrentNumber:
        numberResults.append([OldDataSetArray[oldPos, 1], NewDataSetArray[newPos - 1, 1], OldDataSetArray[oldPos, 0], NewDataSetArray[newPos - 1, 0]])
        newPos +=1
        break
    elif PreviousNumber > CurrentNumber:
        PreviousNumber = CurrentNumber
        newPos +=1  


#sort by array one values        
numberResults = sorted(numberResults, key=operator.itemgetter(0)) 
numberResultsDf = pd.DataFrame(numberResults)

将熊猫作为pd导入
进口经营者
OldDataSet={
“id”：[20,30,40,50,60,70]
，'OdoLength'：[26.12,43.12,46.81,56.23111.07166.38]}
新数据集={
“id”：[30004000500060007008000]
，'OdoLength'：[25.03,42.12,45.74,46110.05165.41]}
df1=pd.DataFrame（旧数据集）
df2=pd.DataFrame（新数据集）
OldDataSetArray=df1.as_矩阵（）
NewDataSetArray=df2.as_matrix（）
newPos=1
CurrentNumber=0
OldArrayLen=len（OldDataSetArray）-1
NewArrayLen=len（NewDataSetArray）-1
numberResults=[]
对于范围内的oldPos（len（OldDataSetArray））：
PreviousNumber=abs（OldDataSetaray[oldPos，0]-NewDataSetaray[oldPos，0]）
而newPos则可以使用NumPy广播来构建距离矩阵：
a = numpy.array([26.12, 43.12, 46.81, 56.23, 111.07, 166.38,])
b = numpy.array([25.03, 42.12, 45.74, 46, 110.05, 165.41,])

numpy.abs(a[:, None] - b[None, :])
# array([[   1.09,   16.  ,   19.62,   19.88,   83.93,  139.29],
#        [  18.09,    1.  ,    2.62,    2.88,   66.93,  122.29],
#        [  21.78,    4.69,    1.07,    0.81,   63.24,  118.6 ],
#        [  31.2 ,   14.11,   10.49,   10.23,   53.82,  109.18],
#        [  86.04,   68.95,   65.33,   65.07,    1.02,   54.34],
#        [ 141.35,  124.26,  120.64,  120.38,   56.33,    0.97]])

然后，您可以使用argmin
（行或列）查找该矩阵中最近的元素（取决于您是要在a
还是b
）
可以使用NumPy广播构建距离矩阵：
a = numpy.array([26.12, 43.12, 46.81, 56.23, 111.07, 166.38,])
b = numpy.array([25.03, 42.12, 45.74, 46, 110.05, 165.41,])

numpy.abs(a[:, None] - b[None, :])
# array([[   1.09,   16.  ,   19.62,   19.88,   83.93,  139.29],
#        [  18.09,    1.  ,    2.62,    2.88,   66.93,  122.29],
#        [  21.78,    4.69,    1.07,    0.81,   63.24,  118.6 ],
#        [  31.2 ,   14.11,   10.49,   10.23,   53.82,  109.18],
#        [  86.04,   68.95,   65.33,   65.07,    1.02,   54.34],
#        [ 141.35,  124.26,  120.64,  120.38,   56.33,    0.97]])

然后，您可以使用argmin
（行或列）查找该矩阵中最近的元素（取决于您是要在a
还是b
）
计算所有差异，并使用`np.argmin查找最接近的
    a,b=np.random.rand(2,10)

    all_differences=np.abs(np.subtract.outer(a,b))

    ia=all_differences.argmin(axis=1)

    for i in range(10):
        print(i,a[i],ia[i], b[ia[i]])



    0 0.231603891949 8 0.21177584152
    1 0.27810475456 7 0.302647382888
    2 0.582133214953 2 0.548920922033
    3 0.892858042793 1 0.872622982632
    4 0.67293347218 6 0.677971552011
    5 0.985227546492 1 0.872622982632
    6 0.82431697833 5 0.83765895237
    7 0.426992114791 4 0.451084369838
    8 0.181147161752 8 0.21177584152
    9 0.631139744522 3 0.653554586691

编辑
使用数据帧和索引：
va,vb=np.random.rand(2,10)
na,nb=np.random.randint(0,100,(2,10))

dfa=pd.DataFrame({'id':na,'odo':va})
dfb=pd.DataFrame({'id':nb,'odo':vb})


all_differences=np.abs(np.subtract.outer(dfa.odo,dfb.odo))

ia=all_differences.argmin(axis=1)

dfc=dfa.merge(dfb.loc[ia].reset_index(drop=True),\
left_index=True,right_index=True)

输入：
In [337]: dfa

Out[337]: 
   id       odo
0  72  0.426457
1  12  0.315997
2  96  0.623164
3   9  0.821498
4  72  0.071237
5   5  0.730634
6  45  0.963051
7  14  0.603289
8   5  0.401737
9  63  0.976644

In [338]: dfb
Out[338]: 
   id       odo
0  95  0.333215
1   7  0.023957
2  61  0.021944
3  57  0.660894
4  22  0.666716
5   6  0.234920
6  83  0.642148
7  64  0.509589
8  98  0.660273
9  19  0.658639

输出：
In [339]: dfc
Out[339]: 
   id_x     odo_x  id_y     odo_y
0    72  0.426457    64  0.509589
1    12  0.315997    95  0.333215
2    96  0.623164    83  0.642148
3     9  0.821498    22  0.666716
4    72  0.071237     7  0.023957
5     5  0.730634    22  0.666716
6    45  0.963051    22  0.666716
7    14  0.603289    83  0.642148
8     5  0.401737    95  0.333215
9    63  0.976644    22  0.666716

计算所有差异，并使用`np.argmin查找最接近的
    a,b=np.random.rand(2,10)

    all_differences=np.abs(np.subtract.outer(a,b))

    ia=all_differences.argmin(axis=1)

    for i in range(10):
        print(i,a[i],ia[i], b[ia[i]])



    0 0.231603891949 8 0.21177584152
    1 0.27810475456 7 0.302647382888
    2 0.582133214953 2 0.548920922033
    3 0.892858042793 1 0.872622982632
    4 0.67293347218 6 0.677971552011
    5 0.985227546492 1 0.872622982632
    6 0.82431697833 5 0.83765895237
    7 0.426992114791 4 0.451084369838
    8 0.181147161752 8 0.21177584152
    9 0.631139744522 3 0.653554586691

编辑
使用数据帧和索引：
va,vb=np.random.rand(2,10)
na,nb=np.random.randint(0,100,(2,10))

dfa=pd.DataFrame({'id':na,'odo':va})
dfb=pd.DataFrame({'id':nb,'odo':vb})


all_differences=np.abs(np.subtract.outer(dfa.odo,dfb.odo))

ia=all_differences.argmin(axis=1)

dfc=dfa.merge(dfb.loc[ia].reset_index(drop=True),\
left_index=True,right_index=True)

输入：
In [337]: dfa

Out[337]: 
   id       odo
0  72  0.426457
1  12  0.315997
2  96  0.623164
3   9  0.821498
4  72  0.071237
5   5  0.730634
6  45  0.963051
7  14  0.603289
8   5  0.401737
9  63  0.976644

In [338]: dfb
Out[338]: 
   id       odo
0  95  0.333215
1   7  0.023957
2  61  0.021944
3  57  0.660894
4  22  0.666716
5   6  0.234920
6  83  0.642148
7  64  0.509589
8  98  0.660273
9  19  0.658639

输出：
In [339]: dfc
Out[339]: 
   id_x     odo_x  id_y     odo_y
0    72  0.426457    64  0.509589
1    12  0.315997    95  0.333215
2    96  0.623164    83  0.642148
3     9  0.821498    22  0.666716
4    72  0.071237     7  0.023957
5     5  0.730634    22  0.666716
6    45  0.963051    22  0.666716
7    14  0.603289    83  0.642148
8     5  0.401737    95  0.333215
9    63  0.976644    22  0.666716

您尝试了什么？输出看起来不稳定（每行元素数不同，因为有些元素没有匹配项）。你能证实吗？@kabanus我补充了我所拥有的tried@Divakar，是的，有些将没有匹配项。因为有些将丢弃数组2。有人有什么建议吗？您尝试了什么？输出看起来不稳定（每行的元素数不同，因为有些没有匹配项）。你能证实吗？@kabanus我补充了我所拥有的tried@Divakar，是的，有些将没有匹配项。因为有些会从数组2中删除。有人有什么建议吗？从数组2中跳过一些会生效吗？例如，最终结果集跳过ID5000。这里是行号。原则上，用行号查找索引不是问题。从数组2中跳过一些行会生效吗？例如，最终结果集跳过ID5000。这里是行号。原则上，用行号查找索引不是问题。如何获取与结果集关联的ID？Nils Werner，感谢您的回复。但是，最终结果集的最小值为0&0、1&1、2&3、3&3、4&4、5&5。位置3被调出两次。你能看到我发布的预期结果并告诉我你的想法吗？让我知道，如果你看到了一个循环的出路。再次感谢你的帮助！嗯，45.74
和46
都最接近46.81
。完全预期且有效的结果，否？最终匹配基于最近和下一个可用结果。因此，46.81最接近46（差值为.81）。意味着数组2中的45.74被跳过，不能用于任何匹配。因为46.81与46匹配，所以数组2的下一个可用数字是110.05。然后，数组1的数字56.23将从数组2的数字110.05和165.41中减去最接近的数字（110.05），因为它是最接近的，并且与剩余数字中的56.23相匹配。这很难解释，我希望这是有意义的。好吧，请改写你的问题，因为这绝对不清楚。我如何才能获得与结果集关联的ID？Nils Werner，谢谢你的回答。但是，最终结果集的最小值为0&0、1&1、2&3、3&3、4&4、5&5。位置3被调出两次。你能看到我发布的预期结果并告诉我你的想法吗？让我知道，如果你看到了一个循环的出路。再次感谢你的帮助！嗯，45.74
和46
都最接近46.81
。完全预期且有效的结果，否？最终匹配基于最近和下一个可用结果。因此，46.81最接近46（差值为.81）。意味着数组2中的45.74被跳过，不能用于任何匹配。因为46.81与46匹配，所以数组2的下一个可用数字是110.05。然后，数组1的数字56.23将从数组2的数字110.05和165.41中减去最接近的数字（110.05），因为它是最接近的，并且与剩余数字中的56.23相匹配。这很难解释，我希望这是有意义的。好的，请改写你的问题，因为这绝对不清楚。