为什么Python会复制尺寸长度相同的NumPy数组？

Question

我在引用NumPy数组时遇到问题。 我有一个表格的数组

import numpy as np
a = [np.array([0.0, 0.2, 0.4, 0.6, 0.8]),
     np.array([0.0, 0.2, 0.4, 0.6, 0.8]),
     np.array([0.0, 0.2, 0.4, 0.6, 0.8])]

如果我现在创建一个新变量，

b = np.array(a)

并做

b[0] += 1
print(a)

然后a不会改变。

a = [array([0. , 0.2, 0.4, 0.6, 0.8]),
     array([0. , 0.2, 0.4, 0.6, 0.8]),
     array([0. , 0.2, 0.4, 0.6, 0.8])]

但如果我做同样的事情：

a = [np.array([0.0, 0.2, 0.4, 0.6, 0.8]),
     np.array([0.0, 0.2, 0.4, 0.6, 0.8]),
     np.array([0.0, 0.2, 0.4, 0.6])]

所以我在最后一个维度的末尾删除了一个数字。 然后我再做一次：

b = np.array(a)
b[0] += 1
print(a)

现在， a正在发生变化，我以为是在Python的正常行为。

a = [array([1. , 1.2, 1.4, 1.6, 1.8]),
     array([0. , 0.2, 0.4, 0.6, 0.8]),
     array([0. , 0.2, 0.4, 0.6])]

谁能解释一下这个？

Answer 1

In [1]: a = [np.array([0.0, 0.2, 0.4, 0.6, 0.8]), 
   ...:      np.array([0.0, 0.2, 0.4, 0.6, 0.8]), 
   ...:      np.array([0.0, 0.2, 0.4, 0.6, 0.8])]                               
In [2]:                                                                         
In [2]: a                                                                       
Out[2]: 
[array([0. , 0.2, 0.4, 0.6, 0.8]),
 array([0. , 0.2, 0.4, 0.6, 0.8]),
 array([0. , 0.2, 0.4, 0.6, 0.8])]

a是数组列表。 b是2d数组。

In [3]: b = np.array(a)                                                         
In [4]: b                                                                       
Out[4]: 
array([[0. , 0.2, 0.4, 0.6, 0.8],
       [0. , 0.2, 0.4, 0.6, 0.8],
       [0. , 0.2, 0.4, 0.6, 0.8]])
In [5]: b[0] += 1                                                               
In [6]: b                                                                       
Out[6]: 
array([[1. , 1.2, 1.4, 1.6, 1.8],
       [0. , 0.2, 0.4, 0.6, 0.8],
       [0. , 0.2, 0.4, 0.6, 0.8]])

b从获得价值a ，但不包含任何的a对象。 此的基本数据结构b是从非常不同a ，该列表。 如果不清楚，您可能想要查看numpy基础知识（谈论形状，步幅和数据缓冲区）。

在第二种情况下， b是一个对象数组，包含相同的对象作为a ：

In [8]: b = np.array(a)                                                         
In [9]: b                                                                       
Out[9]: 
array([array([0. , 0.2, 0.4, 0.6, 0.8]), array([0. , 0.2, 0.4, 0.6, 0.8]),
       array([0. , 0.2, 0.4, 0.6])], dtype=object)

这个b行为很像a - 都包含数组。

该对象数组的构造与2d数字数组完全不同。 我认为数值数组是默认的，或正常的，numpy行为，而对象数组是'让步'，给我们一个有用的工具，但是没有多维数组的计算能力。

很容易错误地制作一个对象数组 - 有人说太容易了。 通过设计可靠地制造一个可能更难。 对于原始a例子，我们要做的是：

In [17]: b = np.empty(3, object)                                                
In [18]: b[:] = a[:]                                                            
In [19]: b                                                                      
Out[19]: 
array([array([0. , 0.2, 0.4, 0.6, 0.8]), array([0. , 0.2, 0.4, 0.6, 0.8]),
       array([0. , 0.2, 0.4, 0.6, 0.8])], dtype=object)

甚至for i in range(3): b[i] = a[i]

Answer 2

简而言之，这是您的数据的结果。 你会注意到它的工作/不起作用（取决于你如何查看），因为你的数组大小不同 。

对于相同大小的子阵列，可以将元件紧凑地加载到存储器有效方案中，其中任何ND阵列可以由存储器中的紧凑1-D阵列表示。 然后，NumPy在内部处理多维索引到1D索引的转换。 例如，2D阵列的索引[i，j]将映射到i * N + j（如果以行主格式存储）。 原始数组列表中的数据被复制到一个紧凑的1D数组中，因此对此数组所做的任何修改都不会影响原始数组。

使用不规则的列表/数组，这是不可能的。 该数组实际上是一个python列表，其中每个元素都是一个python对象。 为了提高效率，只复制对象引用而不是数据。 这就是为什么你可以改变第二种情况下的原始列表元素而不是第一种情况。

Answer 3

在第一种情况下，NumPy看到numpy.array的输入可以解释为numpy.array维数组，所以它就是这样。 结果是一个新的float64 dtype数组，输入数据被复制到其中，与输入对象无关。 b[0]是新数组第一行的视图，完全独立于a[0] ，修改b[0]不影响a[0] 。

在第二种情况下，由于子阵列的长度不相等，因此输入不能被解释为二维阵列。 但是，考虑到子阵列是不透明的对象，列表可以被解释为对象的一维数组，这是NumPy所依赖的解释。 numpy.array调用的结果是对象numpy.array的一维数组，包含对作为输入列表元素的数组对象的引用。 b[0]是相同的阵列对象， a[0]是和b[0] += 1变异该对象。

这种长度依赖性是在NumPy中尝试制作锯齿状数组或数组数组是一个非常非常糟糕的理由的众多原因之一。 说真的，不要这样做。

Answer 4

当你犯了一个np.array与清单相一致的长度，一个新的对象np.ndarray的float创建秒。

因此，您的a[0]和b[0]不共享相同的引用。

a = [np.array([0.0, 0.2, 0.4, 0.6, 0.8]),
     np.array([0.0, 0.2, 0.4, 0.6, 0.8]),
     np.array([0.0, 0.2, 0.4, 0.6, 0.8])]
b = np.array(a)
id(a[0])
# 139663994327728
id(b[0])
# 139663994324672

但是，对于不同长度的列表， np.array创建np.ndarray其中object为其元素。

a2 = [np.array([0. , 0.2, 0.4, 0.6, 0.8]), 
     np.array([0. , 0.2, 0.4, 0.6, 0.8]), 
     np.array([0. , 0.2, 0.4, 0.6])]
b2 = np.array(a2)
b2
array([array([1. , 1.2, 1.4, 1.6, 1.8]), array([0. , 0.2, 0.4, 0.6, 0.8]),
       array([0. , 0.2, 0.4, 0.6])], dtype=object)

其中b2仍然保持与a2相同的引用：

for s in a2:
    print(id(s))
# 139663994330128
# 139663994328448
# 139663994329488

for s in b2:
    print(id(s))
# 139663994330128
# 139663994328448
# 139663994329488

这使得对b2[0]的加法导致除了a2[0] 。

Answer 5

@coldspeed正确地解释了为什么你看到行为上的差异。 我只想指出复制是预期的。

在您可以看到的文档中 ，该函数具有默认设置为True的复制标志：

numpy.array(object, dtype=None, copy=True, order='K', subok=False, ndmin=0)

如果只在必要时才进行复制，请改用np.asarray 。

在你的例子中并没有真正有所作为，因为a是一个列表而不是一个numpy数组，因此它将始终被复制。

如果a是数组，则行为如下：

import numpy as np
a = np.array([[0.0, 0.2, 0.4, 0.6, 0.8],
              [0.0, 0.2, 0.4, 0.6, 0.8],
              [0.0, 0.2, 0.4, 0.6, 0.8]])
b=np.array(a)
b[0] += 1
a

Out[6]: 
array([[0. , 0.2, 0.4, 0.6, 0.8],
       [0. , 0.2, 0.4, 0.6, 0.8],
       [0. , 0.2, 0.4, 0.6, 0.8]])
c = np.asarray(a)
c[0] +=1
a

Out[9]: 
array([[1. , 1.2, 1.4, 1.6, 1.8],
       [0. , 0.2, 0.4, 0.6, 0.8],
       [0. , 0.2, 0.4, 0.6, 0.8]])

Answer 6

设计numpy.array()的主要用例是创建一个n维数字数组，其中数字都存储在numpy自己设计的内部结构中。

只要有可能 ， numpy.array()就会这样做。

（这个内部结构的效率将是你使用numpy ndarray而不是Python列表的主要原因，所以数字被复制的事实实际上对你来说应该是一个理想/好事）

当你的a是3个ndarray的列表，每个大小为5时， numpy.array()显然可以创建一个n维数字的ndarray（特别是一个二维的，形状为(3,5) ） 。

因此，对b[0]任何更改实际上是对数字的内部数据结构的更改，这些数据结构都是从a复制a 。

当你的a是一个不等大小的ndarray列表时， numpy.array() 不再可能将它转换为形状的n维数组(3,5) 。

因此，该函数可以完成它可以做的下一个最好的事情，即将3个ndarray中的每个作为object ，并返回这些object的1维ndarray。 返回的ndarray的长度是3 （ object的数量）。 你可以通过打印b.shape （将打印(3,)而不是(3,5) ）和b.dtype （将打印object而不是float64 ）来看到这一点。

在这种情况下， numpy.array() 不会深入到你的每个3个ndarray中来复制那些3个ndarray的数量，因为它不会创建自己有效设计的n维数字数组 - 它只是要返回一维object的数组。

因此，您对b[0]所做的任何更改也可以通过a看到，因为a和b保持对同一object的引用（3个不等大小的ndararray）。