Python 如何有效地使用偏移量重复二维numpy阵列？

假设我有一个由三列点组成的2D numpy数组，我想在x方向上重复这些点，生成一个新数组，该数组包含原始点集，加上一些“重复”点，这些点在x方向上被某个向量平移（1，2，3，…，n）次

为了清楚起见，假设我在原始数组中有点[0.1,2.0,5.0]，并且我想使用向量“重复”它5次，那么在最终数组中我会有以下内容：

new_array = [[0.1, 2.0, 5.0], [2.1, 2.0, 5.0], [4.1, 2.0, 5.0], [6.1, 2.0, 5.0], [8.1, 2.0, 5.0], [10.1, 2.0, 5.0]]

有没有一种方法可以有效地使用内置的numpy矢量化

import numpy as np

point = [0.1, 2, 5]
vector = [2, 0, 0]
n = 5

a = np.zeros((n, len(vector)))
a[1:] = vector
a = np.cumsum(a, axis=0) + point

a[1:]=vector将创建数组

[[0. 0. 0.]
 [2. 0. 0.]
 [2. 0. 0.]
 [2. 0. 0.]
 [2. 0. 0.]]

这是您希望每行的差异。然后将它们累加起来，并将该点作为偏移量添加。
接受答案的变化：

In [33]: point = np.array([0.1, 2.0, 5.0])
In [34]: vector = np.array([2,0,0])
In [35]: np.arange(5)[:,None]*vector
Out[35]: 
array([[0, 0, 0],
       [2, 0, 0],
       [4, 0, 0],
       [6, 0, 0],
       [8, 0, 0]])
In [36]: np.arange(5)[:,None]*vector + point
Out[36]: 
array([[0.1, 2. , 5. ],
       [2.1, 2. , 5. ],
       [4.1, 2. , 5. ],
       [6.1, 2. , 5. ],
       [8.1, 2. , 5. ]])

你的评论提到了一个结构化数组。例如，如果
点
有3个字段，并且您希望修改第一个字段：

In [37]: arr = np.array([(0.1, 2.0, 5.0)], dtype='f,f,f')
In [38]: arr
Out[38]: array([(0.1, 2., 5.)], dtype=[('f0', '<f4'), ('f1', '<f4'), ('f2', '<f4')])
In [41]: arr = arr.repeat(5)
In [42]: arr
Out[42]: 
array([(0.1, 2., 5.), (0.1, 2., 5.), (0.1, 2., 5.), (0.1, 2., 5.),
       (0.1, 2., 5.)], dtype=[('f0', '<f4'), ('f1', '<f4'), ('f2', '<f4')])
In [43]: arr['f0']
Out[43]: array([0.1, 0.1, 0.1, 0.1, 0.1], dtype=float32)
In [44]: arr['f0'] += np.arange(5)*2
In [45]: arr
Out[45]: 
array([(0.1, 2., 5.), (2.1, 2., 5.), (4.1, 2., 5.), (6.1, 2., 5.),
       (8.1, 2., 5.)], dtype=[('f0', '<f4'), ('f1', '<f4'), ('f2', '<f4')])

[37]中的
：arr=np.array（[（0.1,2.0,5.0）]，dtype='f，f，f'）
In[38]：arr
Out[38]：array（[（0.1,2,5.）]，dtype=[（'f0'，'我自己的答案，这要感谢已经给出的两个答案中的一些提示。我也有结构化数组的答案-如果有人感兴趣，我可以编辑这篇文章并添加到下面

给定一个起始数组：
array=np.array（[1,2,3]，…，[10,9,8]）
，一个向量：
vector=np.array（[1,3,5]）
和所需的重复次数：
repeat=5
。您可以使用以下代码：

new_array = np.repeat(array, repeat)
vector_shifts = np.array([vector*index for index in range(0, repeat)])
vector_shifts = vector_shifts[np.newaxis, :]
vector_shifts = np.repeat(vector_shifts, array.shape[0], axis=0)

np.newaxis
创建一个额外的轴，该轴在重复时停止分组，这是标准的
np.repeat（）
行为。例如
np.repeat（np.array（[[1,2,4]，[2,3,5]]，2）
给出一个输出：
np.array（[[1,2,4]，[1,2,4]，[2,3,5]]

vector_shifts = vector_shifts.reshape(vector_shifts.shape[0]*vector_shifts.shape[1], 3)

这将删除为
np.repeat（）
添加的附加轴，以根据需要执行。最后，可以将向量移位添加到新数组中，以提供扩展的重复点数组

new_array += vector_shift

非常感谢，这给了我一个如何做的想法，我实际上是在处理结构化数组，因此问题略有不同，但可以应用类似的方法！完成后我将发布我自己的方法。这是一个具有三列的二维数组，当数组中有两个点时会发生：
[[x0，y0，z0]，[x1，y1，z1]]
？您是否希望重复交错？非常感谢您的更正！只要重复，我不在乎点的顺序。在我自己的实现中，由于np.repeat（）的缘故，我将类似的点分组在一起函数输出。有趣的术语是，Interleave是用于此类操作的常见行业术语吗？我之前在问问题之前查询搜索引擎时很难想到这样一个术语。是的，这很不幸，不是吗！我设法找到了解决方法，但现在将发布答案。非常感谢回复不过，你的方法非常优雅，唯一的问题是我使用的向量必须是通用的（它代表晶体结构中的轴方向）。