r和python的区别_python - numpy.array形状（R，1）和（R，）之间的区别-CSDN博客

1. NumPy中形状的含义

你写道，“我确实知道它的数字列表和列表列表，其中所有列表只包含一个数字”，但这是一个无用的思考方式。

考虑NumPy数组的最佳方法是它们由两部分组成，一个数据缓冲区，它只是一个原始元素块，另一个视图描述了如何解释数据缓冲区。

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

>>> a = numpy.arange(12)

>>> a

array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])

然后numpy.reshape由一个数据缓冲区组成，排列如下：

┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┐

│ 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

>>> a.strides

(8,)

>>> a.shape

(12,)

这里的形状numpy.reshape意味着数组由单个索引索引，从0到11运行。从概念上讲，如果我们将此单个索引标记为a，则数组i如下所示：

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 │

└────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘

如果我们重塑数组，这不会改变数据缓冲区。相反，它会创建一个新视图，描述解释数据的不同方式。之后：

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

数组numpy.reshape具有与a相同的数据缓冲区，但现在它被两个索引索引，这两个索引分别从0到2和0到3运行。如果我们标记两个指数i和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]

您可以看到第二个索引快速变化，第一个索引变化缓慢。如果您更喜欢这种方式，则可以指定numpy.reshape参数：

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

现在应该清楚，数组具有一个或多个尺寸为1的形状意味着什么。

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

数组numpy.reshape由两个索引编制索引，第一个索引从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 │

└────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘

所以：

>>> d[10,0]

长度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 │

└────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘

所以：

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

有关如何实现数组的更多详细信息，请参阅NumPy内部文档。

2.怎么办？

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

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

您问题中的示例是：

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

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

M[:,0].sum()

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

M.sum(axis=0)