numpy reshape 问题（matlab 比较）

Question

假设我有一个名为 s 的一维向量，由 0、3、6、9 组成。

在 MATLAB 中，形状表示为 (1,4)。即 1x4 行向量。

但在 numpy 中，形状为 (4,)。为什么？这个符号不应该表示一个 4x1 向量吗，因为 python 也使用 row x col 约定？

现在，如果我想重塑行向量，我会在 MATLAB 中输入 reshape(s,[4,1]) 来获得列向量。

我假设等效操作的标准符号是 s.reshape(4,1)。但是在文档中我看到了 s.reshape(-1,1)。为什么？一种语法比另一种更好吗？在这种情况下，-1 是什么意思？

Answer 1

从numpy 退后一步，看看 Python 列表：

In [165]: alist = [0,3,6,9]                                                     
In [166]: alist                                                                 
Out[166]: [0, 3, 6, 9]
In [167]: alist[1]                                                              
Out[167]: 3

这个3 是一个标量；如果我尝试将其编入索引，我会收到错误，alist[1][0]。

现在列出一个列表：

In [168]: alist = [[0],[3],[6],[9]]                                             
In [169]: alist                                                                 
Out[169]: [[0], [3], [6], [9]]
In [170]: alist[1]                                                              
Out[170]: [3]
In [171]: alist[1][0]                                                           
Out[171]: 3

我可以索引它两次。

在 Octave 中，穷人的 MATLAB

>> x = [0,3,6,9];
>> x(2)
ans =  3
>> size(x)
ans =
   1   4

>> size(x(2))
ans =
   1   1

x(2) 仍然是一个二维矩阵；我可以无限期地索引它，x(2)(1)(1)(1)。大小本身是一个二维矩阵； MATLAB 中的所有内容都是 2d（或更高）。

>> size(size(x))
ans =
   1   2

返回 Python/numpy：

In [172]: arr = np.array([0,3,6,9])                                             
In [173]: arr.shape                                                             
Out[173]: (4,)             # a 1 element tuple

In [175]: arr[1]                                                                
Out[175]: 3
In [176]: type(Out[175])                                                        
Out[176]: numpy.int64
In [177]: Out[175].shape                                                        
Out[177]: ()

索引该 1d 数组的元素的结果是一个 numpy 标量对象，具有 0d 形状。 https://docs.scipy.org/doc/numpy/reference/arrays.scalars.html

从许多问题来看，MATLAB 用户似乎很难理解 1 维甚至 0 维的数组。较低的 2d 界限在他们的思想中变得根深蒂固。它似乎也是某些（如果不是全部）版本的线性代数的基础。有矩阵、行向量和列向量，但没有“普通”向量。

但numpy 在 Python 中运行，其数组的行为与 Python 列表一致。并且在逻辑上与自身一致。

这是“列”向量和“行”向量的样子。注意形状 - 两个元素元组。和嵌套括号（2 级）。与嵌套列表的相似之处是故意的。

In [178]: arr = np.array([[0],[3],[6],[9]])                                     
In [179]: arr.shape                                                             
Out[179]: (4, 1)
In [180]: arr                                                                   
Out[180]: 
array([[0],
       [3],
       [6],
       [9]])
In [181]: arr = np.array([[0,3,6,9]])                                           
In [182]: arr.shape                                                             
Out[182]: (1, 4)
In [183]: arr                                                                   
Out[183]: array([[0, 3, 6, 9]])