numpy中有arange / linspace的多维版本吗？

我想要一个2d NumPy数组（x，y）的列表，其中每个x分别位于{-5，-4.5，-4，-3.5，...，3.5、4、4.5、5}中，并且与y相同。

我可以做

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]]

但是顺序并不重要。

您可以使用np.mgrid它，它通常比np.meshgrid一步更方便，因为它一步创建数组：

import numpy as np
X,Y = np.mgrid[-5:5.1:0.5, -5:5.1:0.5]

要获得类似linspace的功能，请0.5用一个复数代替步（即），该复数的大小指定了序列中所需的点数。使用此语法，将与上述相同的数组指定为：

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

祝你好运！

这就是您要寻找的：

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.]]

我想你要np.meshgrid：

从坐标向量返回坐标矩阵。

给定一维坐标数组x1，x2，...，xn，制作ND坐标数组以对ND网格上的ND标量/矢量场进行矢量化评估。

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. ]])

如果您只想遍历对（而不是一次对整个点集进行计算），最好itertools.product遍历所有可能的对：

import itertools

for (xi, yi) in itertools.product(x, y):
    print(xi, yi)

这样可以避免通过生成大型矩阵meshgrid。

我们可以使用安排功能为：

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]]

不知道我是否理解这个问题-列出2个元素的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 给您一个元组列表，列表推导完成其余的工作。

它不是超级快速的解决方案，但适用于任何维度

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

我仍然在Linspace上执行此操作，因为我更喜欢遵循此命令。

您可以按照以下格式创建：np.linspace（np.zeros（width）[0]，np.full（（1，width），-1）[0]，height）

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.  ]])

根据此示例，您可以根据需要进行调暗

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