python: numpy子矩阵什么时候按引用复制，什么时候按值复制？

Question

如果我将一个numpy子矩阵赋值给另一个，似乎该子矩阵是作为引用插入到目标矩阵中，而不是通过元素复制插入到目标矩阵中，有时不是，有时不是，有时会发生奇怪的事情。结果让我有点惊讶，我试着理解确切的规则：

import numpy as np

x = np.matrix("1 2 3; 4 5 6; 7 8 9")
print("0:" +str(x))
>>>0:[[1 2 3]                                                                                                                                                                                                                   
      [4 5 6]                                                                                                                                                                                                                     
      [7 8 9]]    

submatrix = np.zeros((2, 2), dtype=np.int)
submatrix[:,:] = x[:2, :2]
print("1:" + str(submatrix))
>>>1:[[1 2]                                                                                                                                                                                                                     
      [4 5]]     

x[0,0] = 0
print("2:" + str(submatrix))
>>>2:[[1 2]                     # since submatrix[0,0] didn't change to 0, elements must have been copied by value                                                                                                                                                                                                
      [4 5]]  

submatrix[:2,:2] = x[:2, :2]    # perform same assignment again
x[0,0] = 1
print("3:" + str(submatrix))
>>>3:[[0 2]                     # eeeeh what? where is this 0 coming from??                                                                                                                                                                                                          
      [4 5]] 

submatrix[0:2,1:2] = x[0:2, 2:3] # assign second column now
print("4:" + str(submatrix))
>>>4:[[0 3]                                                                                                                                                                                                                     
      [4 6]]                     # assigned correctly

x[0,2] = -3
print("5:" + str(submatrix))
>>>5:[[0 3]                                                                                                                                                                                                                     
      [4 6]]                     # no change

submatrix[0:1,0:2] = x[0:1, 2:3] # assigning first row
print("6:" + str(submatrix))
>>>6:[[-3 -3]                                                                                                                                                                                                                   
      [ 4  6]]                   # dear lord!?

x[0,2] = -5
print("7:" + str(submatrix))                                                                                                                                                                       
>>>7:[[-3 -3]                                                                                                                                                                                                                   
      [ 4  6]]                   # no idea anymore                                                                                                                                                                                                          

有没有人能给我解释一下怎么回事？

使用https://onlinegdb.com/SyP6hvNnS执行的代码

Answer 1

对于您的测试：

1. not to say，fine
2. Ok，所以您已经确定x中的更改不会自动转换为submatrix中的更改。好了，现在我们有了一个前提--数据被复制到submatrix中，x中的更改不会更改anything.
3. # perform same assignment again.嗯，不是。也许在使用的索引方面，但是由于您在(2)中所做的工作，x已经发生了变化。这种更改并不是“隐含地”(不确定有什么更好的术语)带到submatrix上的，您正在使用submatrix[:2,:2] = x[:2, :2]积极地传播这种更改。您已经在(2)中确定，之后的x[0,0] = 1赋值不会对submatrix做任何操作，但它确实更改了x。
4. 在这里并不奇怪
5. 这只是(2)重新散列，但请注意，x在后台再次进行了静默更改。

<代码>G225

现在对你所拥有的进行评估：

x
Out[70]: 
matrix([[ 0,  2, -3],
        [ 4,  5,  6],
        [ 7,  8,  9]])

submatrix
Out[71]: 
array([[0, 3],
       [4, 6]])

1. 在这一点上，看看你的切片产生了什么：submatrix[0:1,0:2]给了array([[0, 3]])。好的，这是有道理的，你只需要取顶行的一部分。它等同于submatrix[0, :] (第0行，此矩阵中的所有列)，您现在可能会对切片表示法感到困惑，因为这是不必要的复杂。这一点在x[0:1, 2:3]中变得更加明显，它就是matrix([[-3]])；相当于x[0, 2]。这个赋值的结果现在应该非常明显了；将submatrix的第一行设置为x[0, 2].

处的标量值

我把7美元留给你。我认为您需要向自己澄清numpy indexing，因为我认为您开始将自己捆绑在切片表示法上。