Question

我有一个循环：

for i in range(np.shape(data)[1]):
    item1 = data[i,0]

现在这适用于具有形状（M，N）的数据，但是当它是单行时，它是（M，）并且我无法访问提供形状的元组的[1]索引（在其他语言中将是“1”）。在不使用try / exceptions的情况下，始终确定传入数组中的行数的正确pythonic方法是什么。

编辑：

np.shape(data)
Out[21]: (17,)

In [24]: np.shape(data)[-1]
Out[24]: 17

----> 1 np.shape(data)[1]
IndexError: tuple index out of range

重点是，对于行长度为1的数组，它根本没有填充值。如果我不知道传入的数组是仅一行还是N行，我想要确定行号。

编辑：

我发现最快的方法是使用省略号，只要求第一列的数组大小 - 根据大小，你可以使用不同的索引，即

sh = data[...,0].size
for i in range(sh):
    item1 = data[i,0]
        if sh == 1:
            item1 = data[0]
        else:
            item1 = data[i,0]

Answer 1

如果您总是想要最后一个索引，可以使用[-1]

for i in range(np.shape(data)[-1]):
    item1 = data[i,0] # if only rows exist, second index might throw an exception

如果只有行，它会为您提供行
如果有行和列，它会为您提供列
适用于任意深度

Answer 2

听起来你想迭代2D数组的第一列或只是一维数组的第一个元素，是否正确？

为什么不把它变成2D数组呢？（我也在数组上直接循环。）例如

for item1 in np.atleast_2d(data)[:,0]:
    print item1

如果您传递[[1,2,3],[4,5,6]]，则会获得1, 4。如果您传递[1,2,3]，则会获得1。

或者，如果您希望在为其提供1D数组时生成列“向量”，请改用column_stack([data])。（松散地使用术语向量，因为行或列向量都不是向量 - 它们是2D）：

for item1 in np.column_stack([data])[:,0]:
    print item1

在这种情况下，2D输出是相同的，但是如果你传入一维数组，它将遍历整个数组。

换句话说：

In [1]: import numpy as np

In [2]: data1d = np.arange(10)

In [3]: data1d
Out[3]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

In [4]: data2d = np.arange(20).reshape(2,10)

In [5]: data2d
Out[5]:
array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]])

In [6]: np.atleast_2d(data2d) # <-- No change!
Out[6]:
array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]])

In [7]: np.atleast_2d(data1d) # <-- Makes it a "row vector"
Out[7]: array([[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]])

In [8]: np.column_stack([data2d]) # <-- No change (note the []!)
Out[8]:
array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]])

In [9]: np.column_stack([data1d]) # <-- Makes it a column vector
Out[9]:
array([[0],
       [1],
       [2],
       [3],
       [4],
       [5],
       [6],
       [7],
       [8],
       [9]])

另见np.c_。例如：

In [11]: np.c_[data1d]
Out[11]:
array([[0],
       [1],
       [2],
       [3],
       [4],
       [5],
       [6],
       [7],
       [8],
       [9]])

In [12]: np.c_[data2d]
Out[12]:
array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]])

Answer 3

像这样的重塑可能会完成这项工作

data1 = data.reshape(data.shape[0],-1)

(M,N)数组的形状保持不变，(M,)变为(M,1)。

for i in range(data1.shape[1]):
    item1 = data1[i,0]

或者怎么样

for row in data1[:N,0]:
   item1 = row

我想知道为什么你只想迭代“行”(range(data.shape[1])的子集。在(M,)案例中，您只想使用一个值，还是只想使用M？

如果你想迭代第一列（即M值）

for row in data1:
    item1 = row[0]

或

for item1 in data1[:,0]:
    pass

编辑：使用省略号的想法;如果sh==1

，您根本不需要迭代

sh=data[...,0].size
if sh==1:
    item1 = data[0]
else:
    for i in range(sh):
        item1 = data[i,0]

sh也可用于完整迭代

for row in data:
    # row is now either vector or scalar
    item1 = row if sh==1 else row[0]

Answer 4

np.size(data)/np.shape(data)[0]应该有效

确定具有相同函数的（M，N）数组和（M，）数组的行数

4 个答案: