我想要一个2d NumPy数组（x，y）的列表，其中每个x都在{-5，-4.5，-4，-3.5，...，3.5,4,4.5,5}和同样适用于你。
我能做到
x = np.arange(-5, 5.1, 0.5)
y = np.arange(-5, 5.1, 0.5)
然后遍历所有可能的对，但我确定有更好的方式...
我想要的东西看起来像：
[[-5, -5],
[-5, -4.5],
[-5, -4],
...
[5, 5]]
但顺序并不重要。
答案 0 :(得分：45)
您可以使用np.meshgrid，这通常比a complex number更方便，因为它只需一步即可创建数组：
import numpy as np
X,Y = np.mgrid[-5:5.1:0.5, -5:5.1:0.5]
对于类似linspace的功能，将步骤（即0.5）替换为{{3}}，其大小指定系列中所需的点数。使用此语法，将上述相同的数组指定为：
X, Y = np.mgrid[-5:5:21j, -5:5:21j]
然后您可以创建对：
xy = np.vstack((X.flatten(), Y.flatten())).T
正如@ali_m建议的那样，这一切都可以在一行中完成：
xy = np.mgrid[-5:5.1:0.5, -5:5.1:0.5].reshape(2,-1).T
祝你好运！
答案 1 :(得分：9)
我想你想要np.meshgrid：
从坐标向量返回坐标矩阵。
在给定一维坐标数组x1，x2，...，xn的情况下，为N-D网格上的N-D标量/矢量场的矢量化评估制作N-D坐标数组。
import numpy as np
x = np.arange(-5, 5.1, 0.5)
y = np.arange(-5, 5.1, 0.5)
X,Y = np.meshgrid(x,y)
您可以使用
将其转换为所需的输出XY=np.array([X.flatten(),Y.flatten()]).T
print XY
array([[-5. , -5. ],
[-4.5, -5. ],
[-4. , -5. ],
[-3.5, -5. ],
[-3. , -5. ],
[-2.5, -5. ],
....
[ 3. , 5. ],
[ 3.5, 5. ],
[ 4. , 5. ],
[ 4.5, 5. ],
[ 5. , 5. ]])
答案 2 :(得分：3)
我们可以使用安排功能：
z1 = np.array([np.array(np.arange(1,5)),np.array(np.arange(1,5))])
print(z1)
o/p=> [[1 2 3 4]
[1 2 3 4]]
答案 3 :(得分：2)
如果您只想迭代对（而不是一次对整个点集进行计算），itertools.product可能最适合迭代所有可能的对：
import itertools
for (xi, yi) in itertools.product(x, y):
print(xi, yi)
这可以避免通过meshgrid生成大型矩阵。
答案 4 :(得分：2)
这正是您要寻找的：
matr = np.linspace((1,2),(10,20),10)
这意味着：
对于第一列； 从（1,2）中的1到（10,20）中的10，将递增的10个数字放入。
第二栏； 从（1,2）中的2到（10,20）中的20，将递增的10放在数字上。
结果将是：
[[ 1. 2.]
[ 2. 4.]
[ 3. 6.]
[ 4. 8.]
[ 5. 10.]
[ 6. 12.]
[ 7. 14.]
[ 8. 16.]
[ 9. 18.]
[10. 20.]]
例如，您也可以只增加一列的值：
matr = np.linspace((1,2),(1,20),10)
第一列将从（1,2）的1到（1,20）的1十次，这意味着它将保持为1，结果将是：
[[ 1. 2.]
[ 1. 4.]
[ 1. 6.]
[ 1. 8.]
[ 1. 10.]
[ 1. 12.]
[ 1. 14.]
[ 1. 16.]
[ 1. 18.]
[ 1. 20.]]
答案 5 :(得分：0)
不确定我是否理解这个问题 - 要列出 2-element NumPy数组，这样可行：
import numpy as np
x = np.arange(-5, 5.1, 0.5)
X, Y = np.meshgrid(x, x)
Liszt = [np.array(thing) for thing in zip(X.flatten(), Y.flatten())] # for python 2.7
zip为您提供了一个元组列表，剩下的就是列表理解。
答案 6 :(得分：0)
根据此示例，您可以根据需要进行调暗
def linspace3D(point1,point2,length):
v1 = np.linspace(point1[0],point2[0],length)
v2 = np.linspace(point1[1],point2[1],length)
v3 = np.linspace(point1[2],point2[2],length)
line = np.zeros(shape=[length,3])
line[:,0]=v1
line[:,1]=v2
line[:,2]=v3
return line
答案 7 :(得分：0)
这不是超快速的解决方案，但适用于任何尺寸
import numpy as np
def linspace_md(v_min,v_max,dim,num):
output = np.empty( (num**dim,dim) )
values = np.linspace(v_min,v_max,num)
for i in range(output.shape[0]):
for d in range(dim):
output[i][d] = values[( i//(dim**d) )%num]
return output
答案 8 :(得分：0)
我仍然在Linspace上这样做，因为我更喜欢坚持使用此命令。
您可以按照以下格式创建： np.linspace（np.zeros（ width ）[0]，np.full（（1， width ），-1）[0]，高度< / strong>）
np.linspace(np.zeros(5)[0],np.full((1,5),-1)[0],5)
输出以下内容：
array([[ 0. , 0. , 0. , 0. , 0. ],
[-0.25, -0.25, -0.25, -0.25, -0.25],
[-0.5 , -0.5 , -0.5 , -0.5 , -0.5 ],
[-0.75, -0.75, -0.75, -0.75, -0.75],
[-1. , -1. , -1. , -1. , -1. ]])
添加 .tranpose（），您将得到：
array([[ 0. , -0.25, -0.5 , -0.75, -1. ],
[ 0. , -0.25, -0.5 , -0.75, -1. ],
[ 0. , -0.25, -0.5 , -0.75, -1. ],
[ 0. , -0.25, -0.5 , -0.75, -1. ],
[ 0. , -0.25, -0.5 , -0.75, -1. ]])
答案 9 :(得分：0)
这是一种优雅的方式：
xy = [(i,j) for i in np.linspace(1,4,4) for j in np.linspace(0,2,3)]
这是 print(xy) 的输出：
[(1.0, 0.0),
(1.0, 1.0),
(1.0, 2.0),
(2.0, 0.0),
(2.0, 1.0),
(2.0, 2.0),
(3.0, 0.0),
(3.0, 1.0),
(3.0, 2.0),
(4.0, 0.0),
(4.0, 1.0),
(4.0, 2.0)]
答案 10 :(得分：0)
这是我仅使用 numpy 从数组创建坐标网格的解决方案（我必须想出一个可以在 jax 中使用 vmap 的解决方案）：
def grid(*args):
return np.stack(np.meshgrid(*args, indexing='ij'), axis=-1)
现在grid([1,2,3], [4,5,6])会给你：
array([[[1, 4],
[1, 5],
[1, 6]],
[[2, 4],
[2, 5],
[2, 6]],
[[3, 4],
[3, 5],
[3, 6]]])
您可以按如下方式将其与 linspace 结合使用以获得 2D 坐标网格：
def lingrid(x_start, x_stop, x_steps, y_start, y_stop, y_steps):
a = np.linspace(x_start, x_stop, x_steps)
b = np.linspace(y_start, y_stop, y_steps)
return grid(a, b)
例如，lingrid(0, 1, 3, 0, 2, 3) 给你：
array([[[0. , 0. ],
[0. , 1. ],
[0. , 2. ]],
[[0.5, 0. ],
[0.5, 1. ],
[0.5, 2. ]],
[[1. , 0. ],
[1. , 1. ],
[1. , 2. ]]])