Python 在循环中更新numpy数组

我从下面得到了一些奇怪的结果，但我对python比较陌生，所以可能会弄乱一些东西。以下是：

import numpy as np

a = np.array([1,2,3,4])
print(a)

old_a = a

for x in range(0,1):
   new_a = old_a
   new_a[0] = old_a[1]
   new_a[1] = old_a[2]
   new_a[2] = old_a[3]
   new_a[3] = old_a[0]
   print(new_a)

[1 2 3 4]
[2 3 4 2]

我原以为第二个数组是[2 3 4 1]

但是，如果我使用下面的“clean”def创建一个新数组，它似乎可以工作

def clean(b_in):
   out = np.zeros(4)
   for x in range(0,4):
       out[x] = b_in[x]
   return out

b = np.array([1,2,3,4])
print(b)

new_b = b

for x in range(0,1):
   old_b = clean(new_b)
   new_b[0] = old_b[1]
   new_b[1] = old_b[2]
   new_b[2] = old_b[3]
   new_b[3] = old_b[0]
   print(new_b) 

[1 2 3 4]
[2 3 4 1]

我遗漏了什么？如何避免清洁def

谢谢

****更新问题如下****

谢谢你的回复。因此，尽管下面有关于滚动功能的响应，但这是实现与滚动功能相同的最佳方法吗

import numpy as np

a = np.array([1,2,3,4])
print(a)

old_a = a

for x in range(0,10):
   new_a = old_a.copy()
   new_a[0] = old_a[1]
   new_a[1] = old_a[2]
   new_a[2] = old_a[3]
   new_a[3] = old_a[0]
   old_a = new_a.copy()
   print(new_a)

再次感谢

编辑

这是我决定的：

import numpy as np

a = np.array([1,2,3,4])
print(a)

old_a = a
new_a = np.zeros_like(old_a)

for x in range(0,10):
    new_a[0] = old_a[1]
    new_a[1] = old_a[2]
    new_a[2] = old_a[3]
    new_a[3] = old_a[0]
    old_a = new_a.copy()
    print(new_a)

[1 2 3 4]
[2 3 4 1]
[3 4 1 2]
[4 1 2 3]
[1 2 3 4]
[2 3 4 1]
[3 4 1 2]
[4 1 2 3]
[1 2 3 4]
[2 3 4 1]
[3 4 1 2]

---

谢谢大家!

当您更改

new\u a

的值时，您也在更改

old\u a

的值，因为您通过分配

new\u a=old\u a

进行浅拷贝而不是深度拷贝：

new_a[0] = old_a[1]
new_a[1] = old_a[2]
new_a[2] = old_a[3]
#old_a[0] is already old_a[1], as you reassigned it on line #1
new_a[3] = old_a[0] 

以下是浅拷贝和深拷贝的区别：

浅复制构造一个新的复合对象，然后（尽可能）向其中插入对原始对象的引用。 深度副本构造一个新的复合对象，然后递归地将在原始副本中找到的对象的副本插入其中

对于numpy阵列，您可以使用

deepcopy

或

copy（）

来避免清洁def：

import numpy as np
#from copy import deepcopy #for python lists
a = np.array([1,2,3,4])
print(a)
old_a = a
for x in range(0,1):
   #new_a = deepcopy(old_a) #for python lists
   new_a = old_a.copy() # for numpy array
   new_a[0] = old_a[1]
   new_a[1] = old_a[2]
   new_a[2] = old_a[3]
   new_a[3] = old_a[0]
   print(new_a)

编辑

在您更新的问题之后，看起来您想要更新

旧的\u a

本身，因此无需

将其复制到新数组中，您只需像这样实现您想要做的事情：

import numpy as np
a = np.array([1,2,3,4])
print(a)
old_a = a
for x in range(0,1):
   old_a[0], old_a[1], old_a[2], old_a[3] = old_a[1], old_a[2], old_a[3], old_a[0]
   print(old_a)

看看这是否有助于您了解自己在做什么：

import numpy as np

a = np.array([1,2,3,4])
print(a)

old_a = a

for x in range(0,1):
    new_a = old_a
    new_a[0] = old_a[1]
    print  new_a
    new_a[1] = old_a[2]
    print  new_a
    new_a[2] = old_a[3]
    print  new_a
    new_a[3] = old_a[0]
    print(new_a)

[1 2 3 4]
[2 2 3 4]
[2 3 3 4]
[2 3 4 4]
[2 3 4 2]

因此，当您执行此操作时，
new\u a[3]=old\u a[0]
，位置
O
已经是“2”。
下面是您所期望的

for x in range(0,1):
    new_a = old_a.copy()
    new_a[0] = old_a[1]
    print  new_a
    new_a[1] = old_a[2]
    print  new_a
    new_a[2] = old_a[3]
    print  new_a
    new_a[3] = old_a[0]
    print(new_a)

[1 2 3 4]
[2 2 3 4]
[2 3 3 4]
[2 3 4 4]
[2 3 4 1]

实现这一点的最快方法是“花式”索引：

a     = np.array([1,2,3,4])
new_a = a[np.array([1,2,3,0])]
print new_a

array([2, 3, 4, 1])

即使这个答案并没有回答您的问题，但对于您的具体情况，如果您正在搜索的是按一个元素移动元素，那么有一个更简单的解决方案。它避免了你陷入困境的复杂性，并且简化了事情

import numpy as np

a = np.array([1,2,3,4])
b = np.roll(a, -1)
print(a, b)

输出

[1 2 3 4] [2 3 4 1]

您的作业
new\u a=old\u a
就是问题所在，因为
new\u a
现在指向与
old\u a
相同的内存。如果要复制
numpy
数组，请使用
new\u a=old\u a.copy（）
。此外，由于要覆盖所有元素，您不需要复制，但可以使用
new\u b=np.zeros\u like（old\u b）
创建形状相同的零数组，或者使用
new\u b=np.empty\u like（old\u b）
创建空数组。否，您正在为

的

下的第一行制作不必要的副本。最好在循环之外声明
new\u a
，这样一个副本就足够了。请用四个空格：）。@Austin检查更新的答案，寻找更好的方法。啊，现在知道了。非常感谢，切利不认为您需要在这里使用
deepcopy
。Numpy有自己的复制功能，随时可用。看到我上面的评论。哦，忘了他在用numpy，更新了答案，谢谢：）@AshishRanjan--为什么你需要一个“for”循环？@AshishRanjan看看操作码，他不使用“x”@AshishRanjan应该向一个新手指出，他确实需要“for”循环。对于落选者：我知道这并不是对问题的确切答案，我已经在帖子下面给出了我的评论。我只是想就如何以最好的
numpy
方式解决这个具体案例给出一点建议。当然，我会在下面发布，但我还没有公开的15个声誉。再次感谢