numpy.array 形状 (R, 1) 和 (R,) 之间的区别

In numpy，一些操作恢复原状(R, 1)但有些返回(R,)。这将使矩阵乘法更加繁琐，因为显式reshape是必须的。例如，给定一个矩阵M，如果我们想做numpy.dot(M[:,0], numpy.ones((1, R))) where R是行数（当然，同样的问题也发生在列上）。我们将得到matrices are not aligned错误自M[:,0]状态良好(R,) but numpy.ones((1, R))状态良好(1, R).

所以我的问题是：

1. 形状有什么区别(R, 1) and (R,)。我从字面上知道它是数字列表和列表列表，其中所有列表仅包含一个数字。只是想知道为什么不设计numpy以便它有利于形状(R, 1)代替(R,)为了更容易的矩阵乘法。

2. 对于上面的例子，还有更好的方法吗？没有像这样显式重塑：numpy.dot(M[:,0].reshape(R, 1), numpy.ones((1, R)))

1.NumPy中形状的含义

你写道，“我从字面上知道它是数字列表和列表列表，其中所有列表仅包含一个数字”，但这是一种无益的思考方式。

考虑 NumPy 数组的最佳方式是它们由两部分组成：数据缓冲区这只是一个原始元素块，以及view它描述了如何解释数据缓冲区。

例如，如果我们创建一个包含 12 个整数的数组：

>>> a = numpy.arange(12)
>>> a
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

Then a由一个数据缓冲区组成，排列如下：

┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┐
│  0 │  1 │  2 │  3 │  4 │  5 │  6 │  7 │  8 │  9 │ 10 │ 11 │
└────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘

以及描述如何解释数据的视图：

>>> a.flags
  C_CONTIGUOUS : True
  F_CONTIGUOUS : True
  OWNDATA : True
  WRITEABLE : True
  ALIGNED : True
  UPDATEIFCOPY : False
>>> a.dtype
dtype('int64')
>>> a.itemsize
8
>>> a.strides
(8,)
>>> a.shape
(12,)

这里的shape (12,)表示数组由从 0 到 11 的单个索引进行索引。从概念上讲，如果我们标记这个单个索引i，数组a看起来像这样：

i= 0    1    2    3    4    5    6    7    8    9   10   11
┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┐
│  0 │  1 │  2 │  3 │  4 │  5 │  6 │  7 │  8 │  9 │ 10 │ 11 │
└────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘

If we reshape一个数组，这不会改变数据缓冲区。相反，它创建了一个新视图来描述解释数据的不同方式。所以之后：

>>> b = a.reshape((3, 4))

数组b具有相同的数据缓冲区a，但现在它的索引为two索引分别从 0 到 2 和 0 到 3。如果我们标记两个索引i and j，数组b看起来像这样：

i= 0    0    0    0    1    1    1    1    2    2    2    2
j= 0    1    2    3    0    1    2    3    0    1    2    3
┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┐
│  0 │  1 │  2 │  3 │  4 │  5 │  6 │  7 │  8 │  9 │ 10 │ 11 │
└────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘

意思就是：

>>> b[2,1]
9

可以看到第二个索引变化很快，第一个索引变化很慢。如果您希望反过来，您可以指定order范围：

>>> c = a.reshape((3, 4), order='F')

这会产生一个索引如下的数组：

i= 0    1    2    0    1    2    0    1    2    0    1    2
j= 0    0    0    1    1    1    2    2    2    3    3    3
┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┐
│  0 │  1 │  2 │  3 │  4 │  5 │  6 │  7 │  8 │  9 │ 10 │ 11 │
└────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘

意思就是：

>>> c[2,1]
5

现在应该清楚数组具有一维或多维大小为 1 的形状意味着什么。之后：

>>> d = a.reshape((12, 1))

数组d由两个索引进行索引，第一个索引从 0 到 11，第二个索引始终为 0：

i= 0    1    2    3    4    5    6    7    8    9   10   11
j= 0    0    0    0    0    0    0    0    0    0    0    0
┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┐
│  0 │  1 │  2 │  3 │  4 │  5 │  6 │  7 │  8 │  9 │ 10 │ 11 │
└────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘

and so:

>>> d[10,0]
10

长度为 1 的维度是“自由”的（在某种意义上），因此没有什么可以阻止您进城：

>>> e = a.reshape((1, 2, 1, 6, 1))

给出一个像这样索引的数组：

i= 0    0    0    0    0    0    0    0    0    0    0    0
j= 0    0    0    0    0    0    1    1    1    1    1    1
k= 0    0    0    0    0    0    0    0    0    0    0    0
l= 0    1    2    3    4    5    0    1    2    3    4    5
m= 0    0    0    0    0    0    0    0    0    0    0    0
┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┐
│  0 │  1 │  2 │  3 │  4 │  5 │  6 │  7 │  8 │  9 │ 10 │ 11 │
└────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘

and so:

>>> e[0,1,0,0,0]
6

See the NumPy 内部文档有关如何实现数组的更多详细信息。

2. 该怎么办？

Since numpy.reshape只是创建一个新视图，您不应该害怕在必要时使用它。当您想以不同的方式对数组进行索引时，它是正确的工具。

然而，在长时间的计算中，通常可以首先安排构造具有“正确”形状的数组，从而最大限度地减少重塑和转置的次数。但如果没有看到导致需要重塑的实际背景，就很难说应该改变什么。

你问题中的例子是：

numpy.dot(M[:,0], numpy.ones((1, R)))

但这是不现实的。首先，这个表达式：

M[:,0].sum()

更简单地计算结果。其次，第 0 列真的有什么特别之处吗？也许你真正需要的是：

M.sum(axis=0)