Python 使用两列标识行的查找表

我有一个xy坐标的numpy查找表，其中列0=xa，1=ya，2=xb，3=yb。我尝试使用xa和ya（cols0和1）作为一对元素，用于查找xb和yb（cols2和3），这是我想要使用的实际xy坐标

lookup=
[[0,    0,  0,      0]
[2,     0,  1.98,   -0.01]
[4,     0,  3.99,   -0.01]
[6,     0,  6.03,   -0.01]
[8,     0,  8.02,   -0.03]
[10,    0,  9.98,   -0.01]
[12,    0,  11.99,  0]
[14,    0,  13.99,  0]
[0,     1,  -0.03,  0.88]
[2,     1,  1.95,   0.86]
[4,     1,  3.97,   0.85]
[6,     1,  5.97,   0.87]
[8,     1,  7.96,   0.86]
[10,    1,  9.95,   0.92]
[12,    1,  11.95,  0.92]
[14,    1,  13.97,  0.87]]

我有一个数据表，其中x和y位置的格式为xa ya，我希望使用查找表将其更改为xb yb：

gridloc=
[[6,    0]
 [8,    0]
 [8,    0]
 [10,   0]
 [8,    1]
 [10,   1]
 [12,   1]
 [14,   1]

所以我希望结果是这样的：

newloc=
[[6.03,   -0.01]
 [8.02,   -0.03]
 [8.02,   -0.03]
 [9.98,   -0.01]
 [7.96,   0.86]
 [9.95,   0.92]
 [11.95,  0.92]
 [13.97,  0.87]]

我尝试使用此工具创建字典，但出现错误：

mapping = dict(zip(lookup[:,0:2], range(len(lookup))))

Traceback (most recent call last):

  File "<ipython-input-12-528fb6616ce0>", line 1, in <module>
    mapping = dict(zip(lookup[:,0:2], range(len(lookup))))

TypeError: unhashable type: 'numpy.ndarray'

mapping=dict（zip（查找[：，0:2]，范围（len（查找）））
回溯（最近一次呼叫最后一次）：
文件“”，第1行，在
mapping=dict（zip（查找[：，0:2]，范围（len（查找）））
TypeError:不可损坏的类型：“numpy.ndarray”

---

请问有人有什么建议吗？我的桌子应该放在numpy吗？dict是解决问题的方法吗？

首先，列表是可变的，不能用作dict键。这就是为什么需要将数据转换为元组：

mapping = dict(zip(map(tuple, lookup[:, :2]), map(tuple, lookup[:, 2:])))#
mapping
#{(0.0, 0.0): (0.0, 0.0),
# (0.0, 1.0): (-0.029999999999999999, 0.88),
# (2.0, 0.0): (1.98, -0.01),
# (2.0, 1.0): (1.95, 0.85999999999999999),
# (4.0, 0.0): (3.9900000000000002, -0.01),
# (4.0, 1.0): (3.9700000000000002, 0.84999999999999998),
# (6.0, 0.0): (6.0300000000000002, -0.01),
# (6.0, 1.0): (5.9699999999999998, 0.87),
# (8.0, 0.0): (8.0199999999999996, -0.029999999999999999),
# (8.0, 1.0): (7.96, 0.85999999999999999),
# (10.0, 0.0): (9.9800000000000004, -0.01),
# (10.0, 1.0): (9.9499999999999993, 0.92000000000000004),
# (12.0, 0.0): (11.99, 0.0),
# (12.0, 1.0): (11.949999999999999, 0.92000000000000004),
# (14.0, 0.0): (13.99, 0.0),
# (14.0, 1.0): (13.970000000000001, 0.87)}

现在，为了实现您的目标，您需要将

gridloc

转换为元组列表，然后将

mapping

映射到它：

gridloc = list(map(mapping.get, map(tuple, gridloc)))
gridloc
#[(6.0300000000000002, -0.01),
# (8.0199999999999996, -0.029999999999999999),
# (8.0199999999999996, -0.029999999999999999),
# (9.9800000000000004, -0.01),
# (7.96, 0.85999999999999999),
# (9.9499999999999993, 0.92000000000000004),
# (11.949999999999999, 0.92000000000000004),
# (13.970000000000001, 0.87)]

---

另外，这里有一种Numpythonic方法：

In [89]: mask = np.logical_and(gridloc[:,0] == lookup[:,None,0], gridloc[:,1] == lookup[:,None, 1])

In [90]: ind = np.where(mask)[0]

In [91]: lookup[ind, 2:]
Out[91]: 
array([[ 6.030e+00, -1.000e-02],
       [ 8.020e+00, -3.000e-02],
       [ 8.020e+00, -3.000e-02],
       [ 9.980e+00, -1.000e-02],
       [ 7.960e+00,  8.600e-01],
       [ 9.950e+00,  9.200e-01],
       [ 1.195e+01,  9.200e-01],
       [ 1.397e+01,  8.700e-01]])

---

一种选择是使用熊猫索引功能：

import numpy as np
import pandas as pd

lookup = np.array(
    [[0,    0,  0,      0],
     [2,     0,  1.98,   -0.01],
     [4,     0,  3.99,   -0.01],
     [6,     0,  6.03,   -0.01],
     [8,     0,  8.02,   -0.03],
     [10,    0,  9.98,   -0.01],
     [12,    0,  11.99,  0],
     [14,    0,  13.99,  0],
     [0,     1,  -0.03,  0.88],
     [2,     1,  1.95,   0.86],
     [4,     1,  3.97,   0.85],
     [6,     1,  5.97,   0.87],
     [8,     1,  7.96,   0.86],
     [10,    1,  9.95,   0.92],
     [12,    1,  11.95,  0.92],
     [14,    1,  13.97,  0.87]])
gridloc = np.array(
    [[6,    0],
     [8,    0],
     [8,    0],
     [10,   0],
     [8,    1],
     [10,   1],
     [12,   1],
     [14,   1]])

idx = pd.MultiIndex.from_arrays([lookup[:, 0], lookup[:, 1]], names=('xa', 'ya'))
df = pd.DataFrame(lookup[:, 2:], columns=('xb', 'yb'), index=idx)
# This should work but is not implemented for multidimensional arrays
# newloc = df.loc[gridloc].values
# Converting to list of tuples works
newloc = df.loc[list(map(tuple, gridloc))].values  # Add .copy() if need writing
print(newloc)

输出：

[[  6.03000000e+00  -1.00000000e-02]
 [  8.02000000e+00  -3.00000000e-02]
 [  8.02000000e+00  -3.00000000e-02]
 [  9.98000000e+00  -1.00000000e-02]
 [  7.96000000e+00   8.60000000e-01]
 [  9.95000000e+00   9.20000000e-01]
 [  1.19500000e+01   9.20000000e-01]
 [  1.39700000e+01   8.70000000e-01]]

---

你也需要将值映射到

元组吗？@jpp另一方面-你查找元组，然后返回元组-在我看来更漂亮：）我无法将其映射到输出，只有一个映射对象。至于浮点数指针，我真的需要学习Python课程，而不是像我一样在黑暗中蹒跚而行been@georussell您是否在编辑中使用
gridloc=list（map（mapping.get，map（tuple，gridloc）））
尝试过它？错过了，但这确实有效，谢谢。使用Pandas的答案是因为让数组前进对我更有用这很好，尽管值得注意的是它需要二次空间（或者更具体地说，
O（len（gridloc）*len（lookup））
space）。@jdehesa你说什么都没有是什么意思？值多少钱？你能详细说明一下吗？我假设你指的是内存使用，如果是这样的话，那么在大多数情况下，为了在运行时获得性能，你必须放弃内存使用。由于MMORILE的使用不是一个关键问题，所以我没有提出一个基于发电机的方法，它比这样一个向量化方法要慢得多。我的意思是“值得注意”是它是一个需要考虑的因素。如果
gridloc
和
lookup
各有10万行，那么这可能不是一个可行的选择。我并不是说这会使它成为一个糟糕的答案，在大多数类似的情况下，它可能是最好的选择（这就是为什么我投了更高的票），但如果一个有大的ish数组，可能需要使用不同的方法，即使它的效率较低。@jdehesa你是对的，这实际上是一个明显的事实。你也可以假设许多其他的可能性，这些可能性一开始可能看起来微不足道，但你可以很容易地证明，如果你不注意它们，它们会造成巨大的损失。其中之一是默认情况下项目的大小为
float64
。然而，我的观点是，由于我所描述的所有原因，在这种情况下不要使用确定动词。我无法将其用于我更大的、真实的例子，因此我无法对此给出答案，对不起