Python 在对每个数组进行更改时迭代数组列表

这是我上一个问题的后续帖子：

为了能够完成更复杂的任务，例如为每个包含某些计算结果的数组附加一列，我想概括这里提出的解决方案：

import numpy as np
list=[one, two, three]

for arr in list:
    arr=np.column_stack([arr,5*arr[:,2]-arr[:,1])])

---

所有三个数组都具有相同的维度。

分配给变量不会更新列表，它只是对数组中的值的临时引用

使用

enumerate

获取列表索引，然后可以将其替换为结果

for index, arr in enumerate(myList):
    myList[index] = np.column_stack([arr,5*arr[:,2]-arr[:,1])])

---

另外，避免使用内置类和函数的名称作为自己的变量名<代码>列表是一个标准类。

恐怕您所引用的解决方案只能用于对数组进行就地更改。任何更改大小的操作都将创建一个新数组

那么这个

>>> X,Y,Z = (np.arange(i+1, i+10, dtype=float).reshape(3, 3) for i in range(3))
>>> L = [X,Y,Z]
>>> for arr in L:
...    np.sin(arr, out=arr)

还是这个

>>> for arr in L:
...     arr[1] = arr[1, ::-1]

会有用的

您甚至可以替换整个阵列，只要您在适当的位置执行此操作：

>>> for arr in L:
...     arr[...] = 1.7

但是这个

>>> for arr in L:
...    np.append(arr, arr[-1])

---

不会更改原始阵列，但会创建新阵列。赋值回

arr

没有帮助，因为它只是将名称

arr

重新绑定到新对象。

不要忘记，在Python中，变量是对值的引用。迭代变量是一个变量，因此为该变量指定一个新值不会更改iterable

在这种情况下，为什么不使用列表理解

import numpy as np
my_list = [one, two, three]

my_list = [np.column_stack([arr,5*arr[:,2]-arr[:,1])]) for arr in list]

还有，请不要阴影

列表

类型

In [59]: one=np.arange(6).reshape(2,3)
In [60]: two=np.arange(6).reshape(2,3)

暂时不要考虑循环，只需尝试更改一个循环即可：

In [61]: arr = one
In [62]: arr=np.column_stack([arr,5*arr[:,2]-arr[:,1]])
In [63]: arr
Out[63]: 
array([[ 0,  1,  2,  9],
       [ 3,  4,  5, 21]])
In [65]: one
Out[65]: 
array([[0, 1, 2],
       [3, 4, 5]])

此操作已更改

arr

，但未更改

one

。最初

arr

引用了与

one

相同的对象（

ndarray

），但在新赋值之后，它引用了一个新数组

在

arr

被分配了

alist

元素。但在循环中，它被分配了另一个对象，而不改变原始对象。在下一次迭代中，

arr

被分配给列表中的下一个元素，依此类推

你需要记住几件事

• Python如何为变量赋值
• Python如何为迭代变量赋值
• 什么样的函数像

  column\u stack

  to

在你之前的问题中

In [69]: for arg in [one,two]:
    ...:     arg[:,1:] += 10
    ...:     
In [70]: one
Out[70]: 
array([[ 0, 11, 12],
       [ 3, 14, 15]])
In [71]: two
Out[71]: 
array([[ 0, 11, 12],
       [ 3, 14, 15]])

这是因为

arg[：，1:::+=10

正在修改当前分配给

arg

的数组。数组是可变的；元素值可以就地更改

np.column\u stack（）

未在适当位置执行操作。它制造新的阵列

使用列表更改

one

和

two

的唯一方法是一系列操作，如：

In [72]: newlist=[np.column_stack([arr,5*arr[:,2]-arr[:,1]]) for arg in [one,two]]
In [73]: newlist
Out[73]: 
[array([[ 0,  1,  2,  9,  9],
        [ 3,  4,  5, 21, 21]]), array([[ 0,  1,  2,  9,  9],
        [ 3,  4,  5, 21, 21]])]
In [74]: one
Out[74]: 
array([[ 0, 11, 12],
       [ 3, 14, 15]])
In [75]: one, two = newlist
In [76]: one
Out[76]: 
array([[ 0,  1,  2,  9,  9],
       [ 3,  4,  5, 21, 21]])

---

[72]中的

创建一个包含新数组的新列表<[75]中的code>将这些新数组分配给变量

one

和

two

。这抹去了他们以前的参考资料。实际上我做了

one=[np.column_堆栈（[one，5*one[：，2]-one[：，1]]）

，对于

two

，

two
也一样，谢谢，但不幸的是，这不起作用。数组中没有任何内容被替换。您是否希望它修改变量
one
，
two
，
two
，以及
two
？是的，我们的想法是将包含计算结果的列附加到三个数组中的每一个。使用变量只返回对其包含的值的引用，而不返回对变量本身的引用。您不能通过由其生成的数组更改变量的值。但是，如果变量包含可变数据，则可以对该对象进行变异。这必须使用对象本身的方法来完成，而不是对该变量进行赋值参考它。
In [72]: newlist=[np.column_stack([arr,5*arr[:,2]-arr[:,1]]) for arg in [one,two]]
In [73]: newlist
Out[73]: 
[array([[ 0,  1,  2,  9,  9],
        [ 3,  4,  5, 21, 21]]), array([[ 0,  1,  2,  9,  9],
        [ 3,  4,  5, 21, 21]])]
In [74]: one
Out[74]: 
array([[ 0, 11, 12],
       [ 3, 14, 15]])
In [75]: one, two = newlist
In [76]: one
Out[76]: 
array([[ 0,  1,  2,  9,  9],
       [ 3,  4,  5, 21, 21]])