Question

我正在尝试使用下面的代码创建具有不同随机权重的邻接矩阵。但是，我的问题是，在运行此命令时，所有权重都是列表理解的最后一次迭代的权重吗？在生成过程中打印这些adjacencylists时，它可以正常工作，但是getPopulation函数的输出是相同参数集的5倍。

感觉这很容易解决，但是缺少某些东西（我认为可能非常基本）。也许是需要深度复制之类的问题？

已经尝试使用普通的for循环，打印语句等。

import networkx as nx
import numpy as np

G = nx.DiGraph()
G.add_nodes_from(["Sadness", "Avoidance", "Guilt"])
G.add_edges_from([("Sadness", "Avoidance")], weight=1)
G.add_edges_from([("Avoidance", "Sadness")], weight=1)
G.add_edges_from([("Avoidance", "Guilt"), ("Guilt", "Sadness")], weight=1)
parameters = nx.to_numpy_matrix(G)

def getRandParamValue(adj):
    for p in np.transpose(adj.nonzero()):
        adj[p[0], p[1]] = adj[p[0], p[1]] * np.random.uniform()
    print(adj)
    return adj

def getPopulation(size, initParam):
    return [getRandParamValue(initParam) for i in range(size)]

getPopulation(5, parameters)

在getRandParamValue函数中打印输出后，效果很好：

[[0.         0.40218464 0.        ]
 [0.07330473 0.         0.7196376 ]
 [0.53148413 0.         0.        ]]
[[0.         0.34256617 0.        ]
 [0.01773899 0.         0.12460768]
 [0.1401687  0.         0.        ]]
[[0.         0.11086942 0.        ]
 [0.01449088 0.         0.04592752]
 [0.07903259 0.         0.        ]]
[[0.         0.01970867 0.        ]
 [0.00589168 0.         0.00860802]
 [0.06942081 0.         0.        ]]
[[0.         0.01045412 0.        ]
 [0.00084878 0.         0.00713334]
 [0.0024654  0.         0.        ]]

但是，getPopulation的输出与先前的输出不同，这应该可以预期：

[matrix([[0.        , 0.01045412, 0.        ],
         [0.00084878, 0.        , 0.00713334],
         [0.0024654 , 0.        , 0.        ]]),
 matrix([[0.        , 0.01045412, 0.        ],
         [0.00084878, 0.        , 0.00713334],
         [0.0024654 , 0.        , 0.        ]]),
 matrix([[0.        , 0.01045412, 0.        ],
         [0.00084878, 0.        , 0.00713334],
         [0.0024654 , 0.        , 0.        ]]),
 matrix([[0.        , 0.01045412, 0.        ],
         [0.00084878, 0.        , 0.00713334],
         [0.0024654 , 0.        , 0.        ]]),
 matrix([[0.        , 0.01045412, 0.        ],
         [0.00084878, 0.        , 0.00713334],
         [0.0024654 , 0.        , 0.        ]])]

参数矩阵如下：

[[0. 1. 0.]
 [1. 0. 1.]
 [1. 0. 0.]]

Answer 1

所以问题如下：

def myfunction(L):
    L[0] += 1
    return L

my_outer_list = [1,2,3]
newlist = myfunction(my_outer_list)

print(newlist)
> [2, 2, 3]
print(my_outer_list)
> [2, 2, 3]

newlist[2]=-1
print(newlist)
> [2, 2, -1]
print(my_outer_list)
> [2, 2, -1]

我已将对象my_outer_list传递给该函数。然后修改该对象，然后返回该对象。因此，newlist和my_outer_list不仅相等，它们是同一事物的两个不同名称。我对该对象所做的事情都会更改该对象，无论您使用哪个名称，您都会看到这些更改。

这就是你发生的事情。如果我改为让myfunction返回L.copy()，那么它将返回L的副本，而不是确切的L。

因此您应该返回adj.copy()。

列表理解仅返回上一次迭代

1 个答案: