将迭代的值存储到numpy数组-Python，numpy

因此，我正在努力使这段代码对更大的数据集更有用。这是代码，以后我会详细解释：

import numpy as np
np.set_printoptions(threshold='nan')

tri_nums = [3, 2, 1]


paths = [1, 3, 4, 5]

vol_list = [10, 10, 10, 15, 15, 25]

n = 0

array_list = []

while n <= len(tri_nums):
    for num in tri_nums:
        print "assigning volume", vol_list[sum(tri_nums)-len(vol_list)+1]
        volume_array = np.zeros(shape = (6, 6))
        volume_array[paths[num-1],paths[num]] = vol_list[sum(tri_nums)-len(vol_list)+1]
        array_list.append(volume_array)
        print paths[num-1], paths[num]


    tri_nums.pop(0)
    paths.pop(0)
    n+=1
    print paths
    print tri_nums


final_array = sum(array_list)
print array_list
print final_array

列表

路径

（在原始情况下）由四个“节点”（节点1、3、4和5）组成。在每个相邻节点之间有一条路径，即路径1-3、3-4、4-5

可以看到，

volume_数组

是一个6x6数组，由零组成。要更改的

volume\u数组中的行值对应于每个路径的第一个值，即
1
、
3
、
4
。列值对应于每个路径的第二个数字，即
3
，
4
，
5

棘手的一点来了

vol_list
中的值分配给上述数组项，如下所示：

对于
tri\u nums
的每个值，将
vol\u列表中的一个值添加到
volume\u数组中。此数组中的行值由路径的第一个值定义，即
[4]
，列值由路径的第二个值定义（对于值
[4]
，这意味着
[5]
）
对于
tri\u nums[0]
，将值
10
添加三次，一次添加到
volume\u array[4][5]
，一次添加到
volume\u array[3][4]
，一次添加到
volume\u array[1][3]

对于
tri\u nums[1]
值
15
添加两次，一次添加到
volume\u array[4][5]
中，一次添加到
volume\u array[3][4]
对于
tri\u nums[2]
值
25
将一次添加到
volume\u数组[4][5]

最后，将前面三个步骤中生成的数组中的所有值相加，得到
final\u array

另一件值得一提的事情是
tri\u nums
的总和等于
len（vol\u list）
。此外，
tri\u nums[n]
始终是>
tri\u nums[n+1]

理想情况下，我希望为
path
、
tri_num
和
vol_list
实现此代码，其中包含数百项。我现在使用的方法意味着我需要手工制作数百个while循环。如何使
while
循环同时工作，从而避免出现“数百个while循环”的情况

一切正常，但最终结果是：

[[  0.   0.   0.   0.   0.   0.]
 [  0.   0.   0.  10.   0.   0.]
 [  0.   0.   0.   0.   0.   0.]
 [  0.   0.   0.   0.  25.   0.]
 [  0.   0.   0.   0.   0.  25.]
 [  0.   0.   0.   0.   0.   0.]]

这意味着
vol\u list
的最终值（
25
）尚未分配给
array\u list[4][5]
，因此不在
final\u array
中。它只需要再做一个循环就行了，但我不知道如何让它完成最后一个循环

如果有什么不清楚的地方，请告诉我

谢谢
您错过数组的最后一个元素的原因是，您正在增加
n
，同时从
tri\u nums
中弹出元素。在
while
循环的每次迭代开始时，查看
n
和
tri_nums
的值：

iteration    n    tri_nums    n <= len(tri_nums)
0            0    [3, 2, 1]   True
1            1    [2, 1]      True
2            2    [1]         False

也就是说，遍历列表、创建多个数组并将它们全部相加的整个方法是非常低效的。因为不是这样，所以我不会讨论所有的低效率问题，但有几个关键问题我想提一下：


您可以利用输入数据中的许多结构
您应该尽量使用Numpy矢量化操作，而不是本机Python操作
您一直将数字放在相同的索引上，因此您可以先将数字相加，然后只在最后创建数组

考虑到所有这些，我建议更改代码，使
volu list
只包含每个数字一次

然后，您可以通过先将数字相加，然后将结果和粘贴到数组中来构造所需的数组。Numpy方便地包括
cumsum
函数来计算数组的部分和：

>>> np.cumsum([10, 15, 25])
array([10, 25, 50])

它允许您在索引操作中同时指定多个值。因此，您的整个算法可以简化为：

final_array = np.zeros((6, 6))
final_array[paths[:-1], paths[1:]] = np.cumsum(vol_list)

如果长列表的内存需求出现问题，您可能希望将其用于存储，而不是普通的Numpy数组。
list
是一种数据类型-不应将其用作变量名（重命名）
而count<1:
是多余的，因为如果删除它，将得到相同的结果。只有当你以后想迭代不止一次时，才有必要保留它。任何你能用手做的事情都可以用电脑来做。想一想你会采取哪些步骤来手工完成。然后让电脑来做。有时要让计算机达到这个目标比较困难，但是YMMV。既然你问了，代码示例有点长，描述也比较复杂。我认为，如果将描述的各个部分与相应的代码片段穿插在一起，问题会更清楚。在几个地方添加示例输出将有助于进一步改进。话虽如此，我有点明白你在做什么；让我看看我是否能想出一个答案。另外，考虑到这可能是更好的位置（但如果是这样的话，它可以被迁移，不需要手动重新发布）。此外，现在我在看代码，有些事情没有意义。例如，每个
while
循环都有细微的不同。例如，第一个循环在每次迭代时引用两个
路径条目，即
路径[n]
和
路径[n+1]
，但其他循环每次引用一个
路径条目。每个循环以不同的方式将其索引计算到
volume\u数组中。第三个循环递增
b
，但实际上并不在循环中的任何位置使用其值。这些是故意的不一致吗？为什么？这三个指数是什么<
vol_list = [10, 15, 25]

>>> np.cumsum([10, 15, 25])
array([10, 25, 50])

final_array = np.zeros((6, 6))
final_array[paths[:-1], paths[1:]] = np.cumsum(vol_list)