Python NumPy数组

我正在处理两个数组，试图像处理二维数组一样处理它们。我在NumPy中使用了很多矢量化计算。知道如何填充这样的数组吗：

X = [1, 2, 3, 1, 2, 3, 1, 2, 3]

或：

---

忽略消息的第一部分

我必须以网格的形式填充两个数组。但是网格尺寸因用户而异，这就是为什么我需要一个通用的表单。今天早上我一直在努力，终于得到了我想要的

如果我早些时候造成任何混乱，我道歉。英语不是我的母语，有时我很难解释事情

这是为我完成这项工作的代码：

    myIter = linspace(1, N, N)
    for x in myIter:
        for y in myIter:
            index = ((x - 1)*N + y) - 1
            X[index] = x / (N+1)
            Y[index] = y / (N+1)

用户输入N。

---

X，Y的长度是N*N.

如果要创建重复值的列表，可以使用列表/元组乘法

print numpy.array(range(1, 4) * 3)
print numpy.array(range(1, 5) * 4).astype(float) * 2 / 10

>>> import numpy
>>> numpy.array((1, 2, 3) * 3)
array([1, 2, 3, 1, 2, 3, 1, 2, 3])
>>> numpy.array((0.2, 0.4, 0.6, 0.8) * 3).reshape((3, 4))
array([[ 0.2,  0.4,  0.6,  0.8],
       [ 0.2,  0.4,  0.6,  0.8],
       [ 0.2,  0.4,  0.6,  0.8]])

---

谢谢你更新你的问题，现在更清楚了。虽然我认为这是最好的（因为它更具可读性），但我要指出，您发布的新代码也可以这样概括：

>>> arr = numpy.arange(1, N + 1) / (N + 1.0)
>>> X = arr[numpy.indices((N, N))[0]].flatten()
>>> Y = arr[numpy.indices((N, N))[1]].flatten()

在许多情况下，当使用

numpy

时，可以通过使用

numpy

强大的索引系统来避免while循环。通常，当使用数组

I

对数组

A

进行索引时，结果是一个与

I

形状相同的数组

J

。对于

i

中的每个索引

i

，值

A[i]

被分配到

J

中的相应位置。例如，假设您有

arr=numpy.arange（0,9）/（9.0）

，并且希望索引

3

、

5

和

8

处的值。您只需使用

numpy.array（[3,5,8]）

作为

arr

的索引：

>>> arr
array([ 0.        ,  0.11111111,  0.22222222,  0.33333333,  0.44444444,
        0.55555556,  0.66666667,  0.77777778,  0.88888889])
>>> arr[numpy.array([3, 5, 8])]
array([ 0.33333333,  0.55555556,  0.88888889])

如果你想要一个二维阵列呢？只需传入一个二维索引：

>>> arr[numpy.array([[1,1,1],[2,2,2],[3,3,3]])]
array([[ 0.11111111,  0.11111111,  0.11111111],
       [ 0.22222222,  0.22222222,  0.22222222],
       [ 0.33333333,  0.33333333,  0.33333333]])

>>> arr[numpy.array([[1,2,3],[1,2,3],[1,2,3]])]
array([[ 0.11111111,  0.22222222,  0.33333333],
       [ 0.11111111,  0.22222222,  0.33333333],
       [ 0.11111111,  0.22222222,  0.33333333]])

因为您不想一直输入这样的索引，所以可以自动生成它们——使用

numpy.index

：

>>> numpy.indices((3, 3))
array([[[0, 0, 0],
        [1, 1, 1],
        [2, 2, 2]],

       [[0, 1, 2],
        [0, 1, 2],
        [0, 1, 2]]])

简而言之，以上代码就是这样工作的。（还可以查看

numpy.mgrid

和

numpy.ogrid

——它们提供了更灵活的索引生成器。）

由于许多

numpy

操作都是矢量化的（即，它们应用于数组中的每个元素），因此您只需为作业找到正确的索引，无需循环。

您可以使用该函数。从示例中可以看出：

>>> a = np.array([0, 1, 2])
>>> np.tile(a, 2)
array([0, 1, 2, 0, 1, 2])

使用此功能，您还可以像在其他答案中使用“重塑”一样，立即重塑阵列（通过定义“重复”是指更多维度）：

加法：对内置函数

平铺

和乘法之间的速度差异进行一点比较：

In [3]: %timeit numpy.array([1, 2, 3]* 3)
100000 loops, best of 3: 16.3 us per loop
In [4]: %timeit numpy.tile(numpy.array([1, 2, 3]), 3)
10000 loops, best of 3: 37 us per loop

In [5]: %timeit numpy.array([1, 2, 3]* 1000)
1000 loops, best of 3: 1.85 ms per loop
In [6]: %timeit numpy.tile(numpy.array([1, 2, 3]), 1000)
10000 loops, best of 3: 122 us per loop 

编辑

您在问题中给出的代码的输出也可以通过以下方式实现：

arr = myIter / (N + 1)
X = numpy.repeat(arr, N)
Y = numpy.tile(arr, N)

这样可以避免数组循环（这是使用numpy的最大优点之一）。生成的代码更简单（当然，如果您了解函数，请参阅和的文档），速度更快

import numpy as np   

X = range(1,4)*3
X = list(np.arange(.2,.8,.2))*4

---

这将分别成为您的两个列表。希望这就是你要问的

我不确定你到底想做什么，但作为一个猜测：如果你有一个一维数组，你需要把它变成二维，你可以使用数组类重塑方法

    >>> import numpy
    >>> a = numpy.array([1,2,3,1,2,3])
    >>> a.reshape((2,3))
    array([[1, 2, 3],
          [1, 2, 3]])

---

嗯。。。你必须提供更多的信息。显然，您可以像以前那样通过写入值来填充数组。那你想做什么呢？将给定的元素重复一定次数？你所说的“一般形式的重复”是什么意思？这些答案有什么不足之处？看来你收到的答案对你来说是不够的。嗯，在你编辑之前，他们真的以正确的方式回答了你的问题。所以，请考虑更新你的问题，这样才能揭示你的真实问题。否则它只是噪音，你所说的“一般形式”，这里确实不需要。谢谢，我希望现在一切都清楚了在我的回答中，我为您的代码添加了一个替代方案。我不知道它是否足够通用，但它提供了与代码相同的输出。但是通过避免循环和使用内置函数，代码更简单、更快。我更喜欢平铺而不是乘法，因为你可以对numpy向量进行操作：）对于大量重复，平铺也比乘法快得多。有没有办法用numpy替换while循环@太阳报：我不认为有“一般”的替代品，但是如果你有一个特殊的案例，如果你认为可以做得更简单但不知道如何做，你可以把它作为一个问题发布。

import numpy as np   

X = range(1,4)*3
X = list(np.arange(.2,.8,.2))*4

    >>> import numpy
    >>> a = numpy.array([1,2,3,1,2,3])
    >>> a.reshape((2,3))
    array([[1, 2, 3],
          [1, 2, 3]])