Python 从两个坐标阵列创建所有x、y对

我有4个列表需要迭代，以便得到以下结果：

x     y     a     b

1   1   a   b
1   2   a   b
1   3   a   b
1   4   a   b
.....
1000   745   a   b
1000   746   a   b
1000   747   a   b
1000   748   a   b
1000   749   a   b
1000   750   a   b

列表a和b的长度相等，我使用zip函数对它们进行迭代，代码如下：

for a,b in zip(aL,bL):
    print(a,"\t",b)

列表x包含1000项，列表b包含750项，循环完成后，我应该有750.000行

我们希望实现以下目标：

x     y     a     b

1   1   a   b
1   2   a   b
1   3   a   b
1   4   a   b
.....
1000   745   a   b
1000   746   a   b
1000   747   a   b
1000   748   a   b
1000   749   a   b
1000   750   a   b

我怎样才能做到这一点？我尝试过enumerate和izip，但这两种结果都不是我想要的

谢谢

编辑：

我遵循您的代码并使用，因为它要快得多。我的输出现在如下所示：

[[[  0.00000000e+00   0.00000000e+00   4.00000000e+01   2.30000000e+01]
  [  1.00000000e+00   0.00000000e+00   8.50000000e+01   1.40000000e+01]
  [  2.00000000e+00   0.00000000e+00   7.20000000e+01   2.00000000e+00]
  ..., 
  [  1.44600000e+03   0.00000000e+00   9.20000000e+01   4.60000000e+01]
  [  1.44700000e+03   0.00000000e+00   5.00000000e+01   6.10000000e+01]
  [  1.44800000e+03   0.00000000e+00   8.40000000e+01   9.40000000e+01]]]

我现在有750张名单，每一张都有1000张。我试着将它们展平，得到每行4个值（x，y，a，b）。这需要很长时间。有没有别的办法把它们压扁

编辑2

我试过了

np.fromiter(itertools.chain.from_iterable(arr), dtype='int')

但它给出了一个错误：用序列设置数组元素，所以我尝试了

np.fromiter(itertools.chain.from_iterable(arr[0]), dtype='int') 

---

但这只返回了一个列表，我怀疑它是数组中的第一个完整列表。

听起来您需要为

x

和

y

创建一个嵌套循环：

for x in yL:
    for y in yL:
        for a, b in zip(aL, bL):
            print "%d\t%d\t%s\t%s" % (x, y, a, b)

试试这个

for i,j in zip(zip(a,b),zip(c,d)):
     print "%d\t%d\t%s\t%s" % (i[0], i[1], j[0], j[1])

---

编辑v2

现在使用

np.stack

代替

np.dstack

，并处理文件输出

---

这比下面提出的解决方案简单得多

import numpy as np
import numpy.random as nprnd

aL = nprnd.randint(0,100,size=10) # 10 random ints
bL = nprnd.randint(0,100,size=10) # 10 random ints

xL = np.linspace(0,100,num=5) # 5 evenly spaced ints
yL = np.linspace(0,100,num=2) # 2 evenly spaced ints

xv,yv = np.meshgrid(xL,yL)

arr = np.stack((np.ravel(xv), np.ravel(yv), aL, bL), axis=-1)

np.savetxt('out.out', arr, delimiter=' ')

使用

np.meshgrid

为我们提供了以下两个数组：

xv = [[   0.   25.   50.   75.  100.]
     [   0.   25.   50.   75.  100.]]
yv = [[   0.    0.    0.    0.    0.]
     [ 100.  100.  100.  100.  100.]]

当我们散开时，会变成：

np.ravel(xv) = [   0.   25.   50.   75.  100.    0.   25.   50.   75.  100.]
np.ravel(yv) = [   0.    0.    0.    0.    0.  100.  100.  100.  100.  100.]

这些阵列的形状与aL和bL相同

aL = [74 79 92 63 47 49 18 81 74 32]
bL = [15  9 81 44 90 93 24 90 51 68]

所以剩下的就是沿着

轴=-1

堆叠所有四个数组：

arr = np.stack((np.ravel(xv), np.ravel(yv), aL, bL), axis=-1)
arr = [[   0.    0.   62.   41.]
       [  25.    0.    4.   42.]
       [  50.    0.   94.   71.]
       [  75.    0.   24.   91.]
       [ 100.    0.   10.   55.]
       [   0.  100.   41.   81.]
       [  25.  100.   67.   11.]
       [  50.  100.   21.   80.]
       [  75.  100.   63.   37.]
       [ 100.  100.   27.    2.]]

从这里开始，储蓄是微不足道的：

np.savetxt('out.out', arr, delimiter=' ')

原始答案

idx = 0
out = []
for x in xL:
    for y in yL:
        v1 = aL[idx]
        v2 = bL[idx]
        out.append((x, y, v1, v2))
        # print(x,y, v1, v2)
        idx += 1

但是，它很慢，而且只会随着坐标的增加而变慢。我会考虑使用<代码> NoMPy < /代码>包。下面是一个2 x 5数据集的示例

aL = nprnd.randint(0,100,size=10) # 10 random ints
bL = nprnd.randint(0,100,size=10) # 10 random ints

xL = np.linspace(0,100,num=5) # 5 evenly spaced ints
yL = np.linspace(0,100,num=2) # 2 evenly spaced ints


lenx = len(xL) # 5
leny = len(yL) # 2

arr = np.ndarray(shape=(leny,lenx,4)) # create a 3-d array

这将创建一个具有2行x 5列形状的三维数组。在第三个轴（长度4）上，我们用所需的数据填充数组

for x in range(leny):
    arr[x,:,0] = xL

这种语法一开始有点混乱。你可以了解更多。简而言之，它迭代行数，并将数组的特定部分设置为

xL

。在本例中，我们选择的切片是第x行所有列中的第0个索引。（

：

表示“选择此轴上的所有索引”）。对于我们的小示例，这将产生：

[[[  0   0   0   0]
  [ 25   0   0   0]
  [ 50   0   0   0]
  [ 75   0   0   0]
  [100   0   0   0]]

 [[  0   0   0   0]
  [ 25   0   0   0]
  [ 50   0   0   0]
  [ 75   0   0   0]
  [100   0   0   0]]]

现在，我们对每个列执行相同的操作：

for y in range(lenx):
    arr[:,y,1] = yL

-----

[[[  0   0   0   0]
  [ 25   0   0   0]
  [ 50   0   0   0]
  [ 75   0   0   0]
  [100   0   0   0]]

 [[  0 100   0   0]
  [ 25 100   0   0]
  [ 50 100   0   0]
  [ 75 100   0   0]
  [100 100   0   0]]]

现在我们需要处理数组

aL

和

bL

。这些数组是平面的，因此我们必须首先对它们进行

整形，使其符合
arr
的形状。在我们的简单示例中，这将采用长度为10的数组，并将其重塑为2 x 5的二维数组

a_reshaped = aL.reshape(leny,lenx)
b_reshaped = bL.reshape(leny,lenx)

要将重新成形的数组插入我们的
arr
，我们为所有行和列选择第二个和第三个索引（注意这两个
：
：

arr[:,:,2] = a_reshaped
arr[:,:,3] = b_reshaped

----

[[[  0   0   3  38]
  [ 25   0  63  89]
  [ 50   0   4  25]
  [ 75   0  72   1]
  [100   0  24  83]]

 [[  0 100  55  85]
  [ 25 100  39   9]
  [ 50 100  43  85]
  [ 75 100  63  57]
  [100 100   6  63]]]

这比嵌套循环解决方案的运行速度快得多。希望能有所帮助！
谢谢，我认为这对我很有效。我如何使它以x=1和y=1开始运行，因为现在它以x=6和y=1开始。我想确保它提供750.000行。我尝试过嵌套循环。但这只是给出了e的位置对应列表中的每个项目。我想做的是将两个列表乘以不均匀的数字。L1有1000个项目，L2有750个项目。在主要帖子的示例中，我希望L1中的每个项目与L2中的每个项目匹配，这样我最终得到1000*750=750.000个项目。事实上，这是基于两个列表，在我的例子中，我有4个列表：1->x坐标，2st->y坐标，第三->v1和第四->V2不能有750.000行，也不能为每个x，y对压缩列表a和b。如果
len（a）
是10，您将打印出750.000*10行。您能澄清一下列表a和b要打印什么吗？列表1有1000个纬度点，列表2有750个经度点，列表3有速度值，列表4也有速度值。列表3和列表4大小相等，每个都有750.000项的值。我需要创建一个完整的网格通过乘以1000*750，这将提供750.000个坐标对。我已经更新了我的初始帖子。期待您的回复。不幸的是，这对我不起作用。这只给了我3套，而不是175.000