遍历列表

Question

我有一个函数，我想遍历列表列表。问题是，这个列表列表是动态的，这意味着它会根据用户输入而变化。

这是我的代码示例：

result = func(5)
for z in Z[0]:
    result += func(z)

其中 Z 是列表的动态列表，而 func 是我的函数。该函数应遍历列表子集列表 Z[0] 中的每个元素并对结果求和。当列表列表如下所示时，该代码可以工作：

Z = [[1.1],[2.1],[3.1],[4.1]]

Z[0] 只是 [1.1]。然而，有时这个动态列表在每个列表中都有更多元素，在这种情况下，我需要遍历每个元素。如下：

Z = [list([1.1, 1.3]),list([3.1]),list([4]])

在这种情况下：

Z[0] = [list([1.1, 1.3])]

我的代码应该执行以下操作：

result = func(5)
for z in Z[0]:
    result += func(z)

....
func(1.1) + func(1.3)

当我尝试使用列表列表运行代码时，出现错误：“只能将列表（而不是“浮点”）连接到列表中”

我确定这与尝试迭代列表有关。如果有人对此有简单的解决方法，或者知道我很想知道的问题。

编辑： 我想我真正的问题是这些动态列表是如何形成的，正如下面的答案所指出的那样，我将尝试进一步解释我的问题：

我在这里使用@Michael 给出的答案：Replacing certain elements of an array based on a given index

这是我用来生成列表列表的代码：

Arr1 = [9,7,3,1]

Arr2 = [[14,6],[13,2]]

Arr3 = [0,2]

Z = np.array([[Arr1[i]] if not np.sum(Arr3 == i) else Arr2[i] for i in np.arange(Arr1.size)], dtype=object)

Z = [[list([14, 6])], [list([7])], list[([13, 2])], list[([1])]]

子集 Z[0] 结果与

[list([14,6])]

当我尝试迭代时，它给了我错误（只能将列表（而不是“浮动”）连接到列表中）。

当条件 i = Arr3 不满足（比如 Arr3 为空）并且它只是恢复到原始数组时，此代码的输出给出：

Z = [[9][7][3][1]]

Z[0] = [9]

这样，迭代列表的代码就可以工作了。但是我也需要为上述工作。

如果我从这行代码中删除括号：

Z = np.array([[Arr1[i]] if not np.sum(Arr3 == i) else Arr2[i] for i in np.arange(Arr1.size)], dtype=object) 

remove brackets around [Arr1[i]]
--->

Z = np.array([Arr1[i] if not np.sum(Arr3 == i) else Arr2[i] for i in np.arange(Arr1.size)], dtype=object)

然后

Z = [list([14,6]),list([7]),list([13,2]),list([1])]

and
z[0] = [14,6]

并且迭代列表的代码有效！但是，它不适用于条件 i = Arr 3 不满足的情况，因为输出看起来像

[9 7 3 1]

Z[0] = 9

我得到错误'float' object is not iterable。

对不起，这很多，但我认为它更好地解释了我的问题。我不确定是否在任何情况下都能正确生成列表。

Answer 1

很难理解您的问题，但是如果您只是想对主列表中的每个 nums 列表求和，那么您可以执行类似的操作

def sum_nums(nums: list):
    return [sum(num) for num in nums]


nums = [
    [1, 2],
    [7, 9, 10],
    [2],
    [9]
]

print(sum_nums(nums))

输出

[3, 26, 2, 9]

Answer 2

如果Z 的每个元素都是一个列表，只是大小不同（即[1.1] 或[1.1, 2.2] 等），您可以遍历列表，列表的大小无关紧要。

for l in Z:
    result = 0

    for z in l:
        result += func(z)

    # do something with inner list result

对于 Z 中的每个列表，[1.1] 是一个列表，然后对于 Z 中列表中的每个元素，如果高于则 1.1，在此值上运行 func 然后添加到结果。

如果 Z 可以是非列表元素的列表（即Z = [1.1, 2.2]），那么此方法将不起作用，但您还没有证明这是您的情况。

编辑 - 将结果添加到列表中以单独获取内部列表的总和

Answer 3

您的输入是：

Z = [[1.1, 1.3],[2.1],[3.1],[4.1]]

我认为您需要做的是遍历所有元素，应用您的函数并添加结果并返回

def sum_of_all_elements(list_of_list):
   result = 0
   for nested_list in list_of_list:
      for element in nested_list:
         result += func(element)
   return result
print(sum_of_all_elements(Z))

使用行理解

result = sum([ func(element) for element in nested_list for nested_list in Z])

Answer 4

你的逻辑看起来是正确的。我在您使用以下代码提供的两个示例中对其进行了测试，它产生了正确的结果。

def func(x):
    return x**2

Z1 = [[1.1],[2.1],[3.1],[4.1]] # works
Z2 = [list([1.1, 1.3]), list([3.1]), list([4])] # works
 
result1 = func(5)
for z in Z1[0]:
    result1 += func(z)
print(result1)
## Result is 26.21
# (5**2) + (1.1**2) = 25 + 1.21 = 26.21

result2 = func(5)
for z in Z2[0]:
    result2 += func(z)
print(result2)
## Result is 26.21
# (5**2) + (1.1**2) + (1.3**2) = 25 + 1.21 + 1.69 = 27.9

但是，我相信当输入数组 Z 的嵌套列表层数超出预期时，就会出现您的问题。在下面的示例中，值“1”被格式化为单独的列表。当代码迭代 1.1 和 1.3 时，它可以处理这两种情况，因为它们是浮点数。一旦代码到达格式化为列表 [1] 的第三个元素，它就会“惊讶”并且不知道如何处理该列表，因为它期待一个浮点数。代码的设计初衷是不希望有这个新的额外列表层。

Z3 = [list([1.1, 1.3, [1]]), list([3.1]), list([4])] # does not work

result3 = func(5)
for z in Z3[0]:
    result3 += func(z) ## Error occurs on this line
print(result3)

为避免此问题，您可以确保用户输入的嵌套列表不超过您的代码预期的数量。或者，您可以不使用嵌套列表，而是使用 numpy 数组或 pandas 数据框并添加新维度而不是嵌套列表的新级别。

Answer 5

numbers = [1, 2, 3, 4, 5, 6]
new_number = [n + 1 for n in range (1, 10)]
name = "AKHIL  CHOWDARY"
new_name = [letter for letter in name if letter! = " "]
print(new_number, new_name)
new_number = [n + n for n in range(15) if n % 2   != 0]
print(new_number)
names = ["akhil", "mahesh", "suresh", "rajesh", "dinesh"]
new_names = [name for name in names if len(name) > 5]
print(new_names)