Python 替换numpy条目的省时方法

我有以下类型的多个阵列：

import numpy as np

orig_arr = np.full(shape=(5,10), fill_value=1) #only an example, actual entries different

上面数组中的每个条目都是包含进一步信息的字典中的一个数字，它存储在一个数组中

toy_dict = {0:np.arange(13, 23, dtype=float), 1:np.arange(23, 33, dtype=float)}

我的任务是用dict中存储的数组替换

orig\u-arr

中的条目（这里是

toy\u-dict

）

我目前的方法很幼稚，但我正在寻找更快的方法：

goal_arr = np.full(shape=(orig_arr.shape[0], orig_arr.shape[1], 10), fill_value=2, dtype=float)

for row in range(orig_arr.shape[0]):
  for col in range(orig_arr.shape[1]):
    goal_arr[row,col] = toy_dict[0] # actual replacement happens here

如您所见，我正在使用一个中间步骤，创建一个具有所需形状的

goal\u arr

我的问题是：如何以更快的方式添加三维，我可以改进哪些部分？ 提前谢谢

（我查过的另一个问题：，）

---

编辑： 在mathfux给出了一个很好的答案之后，我测试了他提出的代码与我的代码在较大数组的速度比较方面的差异（对于我的用例来说更现实）：

进口：

将numpy导入为np
导入时间
第一个尺寸=50
第二个尺寸=20
深度尺寸=300
上限计数=5000
toy_dict={k:np.random.random_样本（大小=深度）范围内的k（上限计数）}

我的原始版本，参数化后

start=time.time（）
orig_arr=np.random.randint（0，上限计数，大小=（第一个维度，第二个维度））
目标=np.empty（形状=（原始形状[0]，原始形状[1]，深度尺寸），数据类型=浮点）
对于范围内的行（原始阵列形状[0]）：
对于范围内的列（原始阵列形状[1]）：
目标到达[行，列]=玩具到达[行，列]]
end=time.time（）
打印（结束-开始）

时间：0.008016824722290039

现在，mathfux’善意地提供了答案：

开始=时间。时间（）
orig_arr=np.random.randint（0，上限计数，大小=（第一个维度，第二个维度））
目标=np.empty（形状=（原始形状[0]，原始形状[1]，深度尺寸），数据类型=浮点）
a=np.array（list（toy_dict.values（））#不知道是否可以对其进行优化
idx=np.指数（原始阵列形状）
目标_arr[idx[0]，idx[1]]=a[orig _arr[idx[0]，idx[1]]
end=time.time（）
打印（结束-开始）

时间：0.015697956085205078

有趣的是，高级指数的速度较慢。我认为这是由于dict->list->array转换需要时间

不过，谢谢你的回答

---

编辑2：

我在第二个代码块中（但在之前）没有发生列表转换的情况下运行代码：

时间：0.00230699752807617

---

这支持了我的论点。由于

toy_dict

只创建一次，因此建议的解决方案速度更快。谢谢。

您需要避免每一个不是numpy数组本身的iterable对象以及Python级别的迭代。因此，您可能希望将字典的值存储在单独的数组中，然后使用奇特的索引：

goal_arr = np.empty(shape=(orig_arr.shape[0], orig_arr.shape[1], 10), dtype=float)
a = np.array(list(toy_dict.values())) #do not know if it can be optimized
idx = np.indices(orig_arr.shape)
goal_arr[idx[0], idx[1]] = a[orig_arr[idx[0], idx[1]]]

您可以在这里看到，创建

goal\u arr

是必须的，但是我使用了

np.empty

而不是

np.full

，因为这样效率更高

备注：只有当

列表（toy_dict.keys（））

是

[0，1，2…]

形式的列表时，这种方法才有效。在其他情况下，您需要考虑如何在

orig\u arr

上应用映射

toy\u dict.keys（）。我发现这项任务相当困难，所以把它排除在范围之外

用法
样本运行：

print('orig_arr:\n', orig_arr)
print('toy_dict:\n', toy_dict)
print('goal arr:\n', goal_arr)
---------------------------------
orig_arr:
 [[7 3 0]
 [1 3 2]]
toy_dict:
 {0: array([8, 7, 3, 4, 8, 8, 6, 6, 5, 2]), 1: array([7, 2, 4, 7, 5, 5, 6, 8, 6, 5]), 2: array([5, 3, 4, 7, 6, 8, 6, 4, 4, 7]), 3: array([9, 2, 5, 1, 1, 8, 1, 1, 7, 0]), 4: array([9, 6, 7, 2, 7, 2, 4, 4, 5, 8]), 5: array([4, 9, 5, 2, 8, 3, 9, 4, 7, 9]), 6: array([6, 0, 7, 8, 5, 4, 7, 8, 8, 2]), 7: array([6, 5, 9, 3, 6, 2, 0, 2, 3, 2]), 8: array([5, 3, 9, 3, 2, 3, 0, 8, 3, 5])}
goal arr:
 [[[6. 5. 9. 3. 6. 2. 0. 2. 3. 2.]
  [9. 2. 5. 1. 1. 8. 1. 1. 7. 0.]
  [8. 7. 3. 4. 8. 8. 6. 6. 5. 2.]]

 [[7. 2. 4. 7. 5. 5. 6. 8. 6. 5.]
  [9. 2. 5. 1. 1. 8. 1. 1. 7. 0.]
  [5. 3. 4. 7. 6. 8. 6. 4. 4. 7.]]]

你可能还会发现
关于高级索引有帮助。
我很高兴这对您有用。还有两件事需要注意：1）
numpy
在阵列较小时工作速度明显较慢，因此我从不完全相信百分之一百秒或更小的计时。2） 
np.array（list（）
可能比将此iterable转换为数组的最佳有效方法慢几倍，因此您可能需要寻找
np.fromiter
或类似的方法来将数组转换为数组。
print('orig_arr:\n', orig_arr)
print('toy_dict:\n', toy_dict)
print('goal arr:\n', goal_arr)
---------------------------------
orig_arr:
 [[7 3 0]
 [1 3 2]]
toy_dict:
 {0: array([8, 7, 3, 4, 8, 8, 6, 6, 5, 2]), 1: array([7, 2, 4, 7, 5, 5, 6, 8, 6, 5]), 2: array([5, 3, 4, 7, 6, 8, 6, 4, 4, 7]), 3: array([9, 2, 5, 1, 1, 8, 1, 1, 7, 0]), 4: array([9, 6, 7, 2, 7, 2, 4, 4, 5, 8]), 5: array([4, 9, 5, 2, 8, 3, 9, 4, 7, 9]), 6: array([6, 0, 7, 8, 5, 4, 7, 8, 8, 2]), 7: array([6, 5, 9, 3, 6, 2, 0, 2, 3, 2]), 8: array([5, 3, 9, 3, 2, 3, 0, 8, 3, 5])}
goal arr:
 [[[6. 5. 9. 3. 6. 2. 0. 2. 3. 2.]
  [9. 2. 5. 1. 1. 8. 1. 1. 7. 0.]
  [8. 7. 3. 4. 8. 8. 6. 6. 5. 2.]]

 [[7. 2. 4. 7. 5. 5. 6. 8. 6. 5.]
  [9. 2. 5. 1. 1. 8. 1. 1. 7. 0.]
  [5. 3. 4. 7. 6. 8. 6. 4. 4. 7.]]]