Неправильное индексирование внутри двойного цикла for

Question

Я публикую ниже упрощенную версию кода, которая воспроизводит мою проблему:

import numpy as np

a1 = np.array([[0., (2/3)**(1/2), (1/3)**(1/2)],
           [-(1/2)**(1/2), -(1/6)**(1/2), (1/3)**(1/2)],
           [-(1/2)**(1/2), (1/6)**(1/2), -(1/3)**(1/2)],
           [(1/2)**(1/2), -(1/6)**(1/2), (1/3)**(1/2)],
           [(1/2)**(1/2), (1/6)**(1/2), -(1/3)**(1/2)],
           [0., -(2/3)**(1/2), -(1/3)**(1/2)]])

b1 = np.array([[-1. , 0., 0.],
           [-1/2, (3/4)**(1/2), 0.],
           [1/2, -(1/12)**(1/2), -(2/3)**(1/2)],
           [-1/2, -(3/4)**(1/2), 0.],
           [-1/2, -(1/12)**(1/2), -(2/3)**(1/2)],
           [0., (1/3)**(1/2), -(2/3)**(1/2)]])

a2 = np.array([[(1/2)**(1/2), (1/6)**(1/2), -(1/3)**(1/2)],
           [0., -(2/3)**(1/2), -(1/3)**(1/2)],
           [(1/2)**(1/2), -(1/6)**(1/2), (1/3)**(1/2)],
           [-(1/2)**(1/2), (1/6)**(1/2), -(1/3)**(1/2)],
           [0., (2/3)**(1/2), (1/3)**(1/2)],
           [-(1/2)**(1/2), -(1/6)**(1/2), (1/3)**(1/2)]])

b2 = np.array([[1/2 , -(3/4)**(1/2), 0.],
           [-1., 0., 0.],
           [-1/2, (1/12)**(1/2), (2/3)**(1/2)],
           [-1/2, -(3/4)**(1/2), 0.],
           [0., -(1/3)**(1/2), (2/3)**(1/2)],
           [1/2, (1/12)**(1/2), (2/3)**(1/2)]])


avector = [a1, a2]
bvector = [b1, b2]

cvector = [np.zeros([6, 3])]*2

for i in range(2):
    for j in range(6):
        cvector[i][j] = np.cross(avector[i][j], bvector[i][j])
        print(i, j, cvector[i][j])

print(cvector)

Вывод будет:

0 0 [ 0.         -0.57735027  0.81649658]
0 1 [-0.5        -0.28867513 -0.81649658]
0 2 [-0.5       -0.8660254  0.       ]
0 3 [ 0.5        -0.28867513 -0.81649658]
0 4 [-0.5        0.8660254  0.       ]
0 5 [ 1.  0.  0.] 
1 0 [-0.5        -0.28867513 -0.81649658]
1 1 [ 0.          0.57735027 -0.81649658]
1 2 [-0.5       -0.8660254  0.       ]
1 3 [-0.5         0.28867513  0.81649658]
1 4 [ 1.  0. -0.]
1 5 [-0.5        0.8660254  0.       ]

[array([[-0.5       , -0.28867513, -0.81649658],
       [ 0.        ,  0.57735027, -0.81649658],
       [-0.5       , -0.8660254 ,  0.        ],
       [-0.5       ,  0.28867513,  0.81649658],
       [ 1.        ,  0.        , -0.        ],
       [-0.5       ,  0.8660254 ,  0.        ]]),
array([[-0.5       , -0.28867513, -0.81649658],
       [ 0.        ,  0.57735027, -0.81649658],
       [-0.5       , -0.8660254 ,  0.        ],
       [-0.5       ,  0.28867513,  0.81649658],
       [ 1.        ,  0.        , -0.        ],
       [-0.5       ,  0.8660254 ,  0.        ]])]

Можно отметить, что первая строка 0 0, вычисленная внутри цикла for, не соответствует матрице cvector[0][0]. Я надеюсь, что они совпадают. То же самое происходит с шестой строкой 0 5 и матрицей cvector[0][0].

Если вы измените range(2) на range(1) в первом цикле for, вы не увидите такое же и, на мой взгляд, правильное поведение.

Кто-нибудь знает, почему это происходит?

Answer 1

Когда вы создаете cvector, используя [np.zeros([6, 3])]*2, вы не создаете 2 np.array. Второй экземпляр - просто вид первого. Итак, cvector[0] = cvector[1]. Таким образом, в цикле вы перезаписываете вычисления i=0, когда делаете это снова для i=1.

Вместо этого вы можете создать два независимых массива, например:

cvector = [np.zeros([6, 3]), np.zeros([6, 3])]

и работает как положено:

(0, 0, array([ 0.        , -0.57735027,  0.81649658]))
(0, 1, array([-0.5       , -0.28867513, -0.81649658]))
(0, 2, array([-0.5      , -0.8660254,  0.       ]))
(0, 3, array([ 0.5       , -0.28867513, -0.81649658]))
(0, 4, array([-0.5      ,  0.8660254,  0.       ]))
(0, 5, array([1., 0., 0.]))
(1, 0, array([-0.5       , -0.28867513, -0.81649658]))
(1, 1, array([ 0.        ,  0.57735027, -0.81649658]))
(1, 2, array([-0.5      , -0.8660254,  0.       ]))
(1, 3, array([-0.5       ,  0.28867513,  0.81649658]))
(1, 4, array([ 1.,  0., -0.]))
(1, 5, array([-0.5      ,  0.8660254,  0.       ]))

[array([[ 0.        , -0.57735027,  0.81649658],
       [-0.5       , -0.28867513, -0.81649658],
       [-0.5       , -0.8660254 ,  0.        ],
       [ 0.5       , -0.28867513, -0.81649658],
       [-0.5       ,  0.8660254 ,  0.        ],
       [ 1.        ,  0.        ,  0.        ]]),
 array([[-0.5       , -0.28867513, -0.81649658], 
       [ 0.        ,  0.57735027, -0.81649658],
       [-0.5       , -0.8660254 ,  0.        ],
       [-0.5       ,  0.28867513,  0.81649658],
       [ 1.        ,  0.        , -0.        ],
       [-0.5       ,  0.8660254 ,  0.        ]])]

---

Рассмотрим этот пример, чтобы показать, почему первый массив перезаписывается:

In [1]: import numpy as np

In [2]: cvector = [np.zeros([6, 3])]*2

In [3]: cvector
Out[3]: 
[array([[0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.]]), 
 array([[0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.]])]

In [4]: cvector[0][0] = (1, 2, 3)

In [5]: cvector
Out[5]: 
[array([[1., 2., 3.],
        [0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.]]), 
 array([[1., 2., 3.],
        [0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.]])]

Обратите внимание, как первый элемент перезаписывается в обоих случаях.