循环嵌套结果？

笑星星

图1是编程，图2 是first 执行的结果，图3是second执行的结果，我想知道为啥图3的结果和图2的结果存在差别原因，我想把图3的结果变成图2的结果的模式要怎样修改，谢谢！


#循环嵌套
list1 = ['11001','孙悟空','男','29']
list2 = ['11002','猪八戒','男','39']
list3 = ['11003','沙悟净','男','49']
list4 = ['11004','白龙马','男','59']
listA = [list1,list2]
listB = [list3,list4]
listc = [listA,listB]
#first
##for i in range(len(listA)):
##     for x in listA[i]:
##         print(x,end = '#')
##     print()
#second
for n1 in range(len(listc)):  
    for x in listc[n1]:   
        print(x)
        for n2 in range(len(x)):
            for y in x[n2]:
                #print(y)
                print(y,end = '#')
            print()

FishC

在图3的代码中，第一个循环`for n1 in range(len(listc)):`用于遍历`listc`列表中的元素，而第二个循环`for x in listc:`用于遍历`listc`列表中的每个元素，也就是一个个子列表。然后，第三个循环`for n2 in range(len(x)):`用于遍历每个子列表`x`中的元素，而第四个循环`for y in x:`用于遍历每个子列表`x`中的每个元素。

所以，在第二个循环中，每次遍历到的`x`是一个子列表，第三个循环会根据这个子列表的长度来执行相应次数的迭代。而在第四个循环中，每次遍历到的`y`是子列表中的元素。

因此，图2和图3的输出结果存在差别是因为图2中只遍历了一次`listA`，而图3中遍历了多次`listc`以及其中的子列表。

如果你想将图3的输出结果变成图2的模式，可以参考以下代码修改第二个循环：

1. for x in listA:
   
2.     for n2 in range(len(x)):
   
3.         for y in x:
   
4.             print(y, end='#')
   
5.         print()

复制代码

这样，我们直接遍历`listA`中的每个元素，而不是遍历`listc`中的每个元素。这样就可以实现与图2相似的输出结果。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

笑星星

请问我是想从listc开始遍历，并把listc最底层的列表的每个元素遍历出来，例如：
11001 孙悟空 男 29
11002 猪八戒 男 39
······
11004 白龙马 男 59
  并且我想了解有无规律对于多层循环嵌套的遍历

FishC

笑星星 发表于 2024-01-18 21:44
请问我是想从listc开始遍历，并把listc最底层的列表的 ...

如果你想从`listc`开始遍历，并且将最底层列表的每个元素提取出来，可以使用递归进行多层循环嵌套的遍历。

下面是一个示例代码，用于实现你的需求：

1. def traverse_list(lst):
   
2.     for item in lst:
   
3.         if isinstance(item, list):
   
4.             traverse_list(item)  # 递归调用自身进行下一层的遍历
   
5.         else:
   
6.             print(item, end=' ')
   
7. 
   
8. listc = [[1, 1, 0, 0, 1], "孙悟空", "男", [2, 9, 1, 1, 0, 0, 2], "猪八戒", "男", 39, [1, 1, 0, 0, 0, 4], "白龙马", "男", 59]
   
9. 
   
10. traverse_list(listc)

复制代码

这段代码中定义了一个名为`traverse_list`的函数，它接受一个列表作为参数。函数首先遍历传入的列表，对于每个元素，如果是一个子列表，就通过递归调用`traverse_list`函数来遍历下一层。如果是最底层的元素，则直接打印输出。

这样，调用`traverse_list(listc)`即可实现从`listc`开始的多层循环嵌套的遍历，并输出最底层列表的每个元素。

对于多层循环嵌套的遍历，没有固定的规律，需要根据具体的数据结构来设计遍历方法。可以利用递归来处理多层的嵌套关系，不断深入到下一层进行遍历，直到达到最底层为止。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

jackz007

        图3的问题是你对字符串也用了 for ... in 来分解，那么，枚举到的自然就是字符串中的每一个字符，而这并不是我们所想要的效果，所以，只能把  for ... in 循环使用到列表的层级，只要枚举到列表中的每一个元素（'11001'、'孙悟空'、'男'、'29'）就可以了。就本例而言，本来应该用到 3 层嵌套，而你却用了 4 层。所以，就出了问题。
        建议代码这样改：

1. . . . . . .
   
2. #second
   
3. for i in listc :  
   
4.     for j in i :
   
5.         for k in j :
   
6.             print(k , end = '#')
   
7.         print()

复制代码

笑星星

图3的问题是你对字符串也用了 for ... in 来分解，那么，枚举到的自然就是字符串中的每一个字符，而这并不是我们所想要的效果，所以，只能把  for ... in 循环使用到列表的层级，只要枚举到列表中的每一个元素（'11001'、'孙悟空'、'男'、'29'）就可以了。就本例而言，本来应该用到 3 层嵌套，而你却用了 4 层。所以，就出了问题。

1. list1 = ['11001','孙悟空','男','29']
   
2. list2 = ['11002','猪八戒','男','39']
   
3. list3 = ['11003','沙悟净','男','49']
   
4. list4 = ['11004','白龙马','男','59']
   
5. listA = [list1,list2]
   
6. listB = [list3,list4]
   
7. listc = [listA,listB]
   
8. for n1 in range(len(listc)):  
   
9.     for x in listc[n1]:  
   
10. 
    
11.         print(x)  #此处枚举了最底层的列表
    
12.         for n2 in range(len(x)):
    
13.             for y in x[n2]:   #此处下标循环应该枚举到的是字符串，但结果是字符，为啥？
    
14.                 #print(y)
    
15.                 print(y,end = '#')  #结果是字符，而我理解应该是字符串，为啥？
    
16.         print()
    

复制代码

我从执行结果得出的结论是我的枚举到的是字符串中的每一个字符，不是我要的结果，但是我不能理解为啥会这样。您的程序我也理解了，

笑星星

笑星星 发表于 2024-1-19 18:17
我从执行结果得出的结论是我的枚举到的是字符串中的每一个字符，不是我要的结果，但是我不能理解为啥会这 ...

我想清楚了，不用回答了，谢谢