Python中的列表访问

我有这样的两张单子

Nodelist1=[[['B', 10], ['IN', 1000]], [['C', 15], ['OUT', 1001]], [['F', 30], ['IN', 1100]]]
Nodelist2= [[['G', 20], ['IN', 1000, 'OUT', 1111]], [['D', 25], ['INWARD', 1]]]

我想做的是像这样比较这两个列表

if len(Nodelist1[i][1])==len(Nodelist2[j][1]) 

如果条件为真，那么我想从

节点列表2

中删除

节点列表1[I][0]

，它是

['B'，10]

，并从

节点列表1

和

节点列表2[j][1]

中删除

节点列表1[I][0]

那我应该

Nodelist1 as [[['C', 15], ['OUT', 1001]], [['F', 30], ['IN', 1100]]]
Nodelist2 as [[['G', 20], ['IN', 1000, 'OUT', 1111]]]

我的代码如下：

   if len(Nodelist1)>len(Nodelist2):
      for i in range(len(Nodelist1)):
         for j in range(len(Nodelist2)):
            if len(Nodelist1[i][1])==len(Nodelist2[j][1]):
                if Nodelist1[i][1]==Nodelist2[j][1]:
                    Nodelist1.remove(Nodelist1[i])
                    Nodelist2.remove(Nodelist2[j])  
                else:
                    Nodelist1.remove(Nodelist1[i])
                    Nodelist2.remove(Nodelist2[j])  

if len(Nodelist1)>len(Nodelist2):
    # store indexes of items to remove
    list1_to_del = []
    list2_to_del = []
    for i, item1 in enumerate(Nodelist1):
        for j, item2 in enumerate(Nodelist2):
            if len(item1) == len(item2):
                list1_to_del.append(i)
                list2_to_del.append(j)
             else:
                pass # not sure of your intensions and indentation

    # filter lists
    if list1_to_del:
        Nodelist1 = [item for i, item in enumerate(Nodelist1) if i not in set(list1_to_del)]
    if list2_to_del:
        Nodelist2 = [item for i, item in enumerate(Nodelist12) if i not in set(list2_to_del)]

它给我一个错误：

if len(Nodelist1[i][1])==len(Nodelist2[j][1]):
    IndexError: list index out of range

---

在循环列表时，您正在从列表中删除元素。因此，当您移动到列表的末尾时，没有足够的元素。索引访问将引发一个索引器。

在列表中循环时，您正在从列表中删除元素。因此，当您移动到列表的末尾时，没有足够的元素。而且索引访问将引发索引器。

以迭代的方式从列表中删除项是一个相当糟糕的主意，例如

for i in range(len(Nodelist1)):
    pass

你可以这样做：

   if len(Nodelist1)>len(Nodelist2):
      for i in range(len(Nodelist1)):
         for j in range(len(Nodelist2)):
            if len(Nodelist1[i][1])==len(Nodelist2[j][1]):
                if Nodelist1[i][1]==Nodelist2[j][1]:
                    Nodelist1.remove(Nodelist1[i])
                    Nodelist2.remove(Nodelist2[j])  
                else:
                    Nodelist1.remove(Nodelist1[i])
                    Nodelist2.remove(Nodelist2[j])  

if len(Nodelist1)>len(Nodelist2):
    # store indexes of items to remove
    list1_to_del = []
    list2_to_del = []
    for i, item1 in enumerate(Nodelist1):
        for j, item2 in enumerate(Nodelist2):
            if len(item1) == len(item2):
                list1_to_del.append(i)
                list2_to_del.append(j)
             else:
                pass # not sure of your intensions and indentation

    # filter lists
    if list1_to_del:
        Nodelist1 = [item for i, item in enumerate(Nodelist1) if i not in set(list1_to_del)]
    if list2_to_del:
        Nodelist2 = [item for i, item in enumerate(Nodelist12) if i not in set(list2_to_del)]

---

但解决方案有点笨拙：/

以迭代的方式从列表中删除项是一个相当糟糕的主意，例如

for i in range(len(Nodelist1)):
    pass

你可以这样做：

   if len(Nodelist1)>len(Nodelist2):
      for i in range(len(Nodelist1)):
         for j in range(len(Nodelist2)):
            if len(Nodelist1[i][1])==len(Nodelist2[j][1]):
                if Nodelist1[i][1]==Nodelist2[j][1]:
                    Nodelist1.remove(Nodelist1[i])
                    Nodelist2.remove(Nodelist2[j])  
                else:
                    Nodelist1.remove(Nodelist1[i])
                    Nodelist2.remove(Nodelist2[j])  

if len(Nodelist1)>len(Nodelist2):
    # store indexes of items to remove
    list1_to_del = []
    list2_to_del = []
    for i, item1 in enumerate(Nodelist1):
        for j, item2 in enumerate(Nodelist2):
            if len(item1) == len(item2):
                list1_to_del.append(i)
                list2_to_del.append(j)
             else:
                pass # not sure of your intensions and indentation

    # filter lists
    if list1_to_del:
        Nodelist1 = [item for i, item in enumerate(Nodelist1) if i not in set(list1_to_del)]
    if list2_to_del:
        Nodelist2 = [item for i, item in enumerate(Nodelist12) if i not in set(list2_to_del)]

---

但解决方案有点笨拙：///p>您可能不应该对范围内的i（len（您的_列表））使用

，

，而您可以简单地对_列表中的val使用

（或枚举）。但这不是问题所在

问题是，您在遍历列表时正在删除列表中的元素。索引被移动了。例如，如果要删除索引
i
处的元素，则下一个元素现在具有索引
i
。但是，您在循环中执行
i+=1

一个解决方案是保留一个要删除的元素列表，并在循环结束后删除它们

此外：

当时和其他情况都在做同样的事情。。。这毫无意义。
您可能不应该对范围内的i（len（您的_列表））使用
，
而您可以简单地对_列表中的val执行
（或枚举）。但这不是问题所在

问题是，您在遍历列表时正在删除列表中的元素。索引被移动了。例如，如果要删除索引
i
处的元素，则下一个元素现在具有索引
i
。但是，您在循环中执行
i+=1

一个解决方案是保留一个要删除的元素列表，并在循环结束后删除它们

此外：

当时和其他情况都在做同样的事情。。。这毫无意义。
对。此外，他/她正在跳过列表中删除项目后的所有项目。向后迭代：
对于范围内的i（len（Nodelist1）-1，-1，-1）
和
对于范围内的j（len（Nodelist2）-1，-1，-1）
@Jamie:问题是我的列表下次可能会更改，在这种情况下，迭代bachward将起作用，但在其他情况下不行。我认为至少您应该创建两个新列表。然后可以循环浏览原始列表并从副本中删除元素。@user2592166Right。此外，他/她正在跳过列表中删除项目后的所有项目。向后迭代：
对于范围内的i（len（Nodelist1）-1，-1，-1）
和
对于范围内的j（len（Nodelist2）-1，-1，-1）
@Jamie:问题是我的列表下次可能会更改，在这种情况下，迭代bachward将起作用，但在其他情况下不行。我认为至少您应该创建两个新列表。然后你可以在原始列表中循环并从副本中删除元素。@user2592166你真的需要使用
range
？还有什么可以用来迭代并获得结果？我没有真正看到这里的逻辑，为什么
[[['B'，10]，'IN'，1000]]
从
节点列表1中删除
为什么要从
节点列表2中删除
[[D'，25]，[intrown'，1]
？这似乎与您的描述不匹配，因为这些元素完全不同。@F.J:如果len（Nodelist1[i][1]）==len（Nodelist2[J][1]），那么我想删除哪个匹配项，但是
Nodelist1[i][1]
将是
['IN'，1000]
当
i
是
0
，而
Nodelist2[J][1]
将是
当
j
是
2
时，它们是不相等的。你真的需要使用
range
吗？还有什么可以用来迭代并获得结果？我在这里没有真正看到逻辑，为什么
[[B'，10]，'IN'，1000]
会从
节点列表1
中删除，为什么
[D'，25]，['intrown'，1]]
是否从
节点列表2
中删除？这似乎与您的描述不匹配，因为这些元素完全不同。@F.J:如果len（节点列表1[i][1]）==len（节点列表2[J][1]），那么我想删除哪个匹配项，但是
节点列表1[i][1]
将是
['IN'，1000]
当
i
为
0
时，
Nodelist2[j][1]
当
j
为
2
时，
i
为
2
时，
Nodelist2[j][1]
将为
。这两个值不相等。这也是个坏主意，不会出现索引错误，但会跳过元素。请查看以下代码：
x=[1,2,3]；对于x中的i:x.remove（i）
。在此之后，
x
将是列表
[2]
，并不像您预期的那样为空。我想删除else中的元素，因为它们内部仍然有相同数量的元素。这也是一个坏主意，您不会得到索引错误，但会跳过元素。请查看以下代码：
x=[1,2,3]；对于x中的I:x.remove（I）
。在此之后，
x
将是列表
[2]
，并不像您预期的那样为空。我想删除else中的元素，因为它们内部仍然有相同数量的元素。问题是，如果我不删除它，我的下一个元素也将满足条件，即['C'，15]和['F'，30]问题是如果我不删除它，我的下一个元素也将满足条件，即['C'，15]和['F'，30]