Python 为什么list.remove（）不'；t工作“；正确地说；？

我有一个类（点），它有4个列表和一个列表容器。在我的主要工作中，我试图从一个列表中弹出一个值。如果列表变为空，则我将其从容器中删除。这一切都很好，但有时输出表示它会像以前一样尝试从容器中删除相同的列表。为什么它是这样工作的

我的代码：

class Points():

    def __init__(self):
        points = ["One", "Two", "Three", "Four", "Five"]
        self.A = points.copy()
        self.B = points.copy()
        self.C = points.copy()
        self.D = points.copy()
        self.container = [self.A, self.B, self.C, self.D]

    def getPoint(self, letter, index):
        try:
            res = self.container[letter].pop(index-1)

            if (len(self.A) == 0) and (self.A in self.container):
                print("OUT OF A")
                self.container.remove(self.A)
            if (len(self.B) == 0) and (self.B in self.container):
                print("OUT OF B")
                self.container.remove(self.B)
            if (len(self.C) == 0) and (self.C in self.container):
                print("OUT OF C")
                self.container.remove(self.C)
            if (len(self.D) == 0) and (self.D in self.container):
                print("OUT OF D")
                self.container.remove(self.D)
        except:
            return -1
        return res

if __name__ == "__main__":
    m_Points = Points()

    for item in range(25):
        try:
            letterCode = randint(0,len(m_Points.container)-1)
            letter = m_Points.container[letterCode]
            index = randint(0, len(letter) )
            print("#{}. {}".format(item, m_Points.getPoint(letterCode, index) ))
        except:
            print("No more points")
            break

输出：

#0. Four
#1. One
#2. Three
#3. One
#4. Five
#5. Three
#6. Five
#7. Four
#8. Four
#9. Two
OUT OF B
#10. Two
#11. Two
OUT OF A           <--- First time A
#12. One
#13. Five
#14. Four
#15. Three
OUT OF A           <--- A AGAIN?
#16. One
#17. Five
#18. Two
OUT OF A           <--- and again...
#19. Three
No more points

#0。四
#一,
#2.三个
#3.一
#4.五个
#5.三个
#6.5
#7.四个
#8.四个
#9.两个
出自B
#10.两个
#11.两个
出于原因是
在
和
删除
工作的方式

您的困惑可能源于这样一种误解，即

中的

询问特定容器是否包含特定对象，而remove会删除特定对象，因此当您调用（例如，
.remove（self.a）
时，您希望删除
self.a
指向的
列表

但是，实际上，
中的
只是查看容器中是否存在具有特定值的对象，而
remove
删除容器中具有该值的第一个对象。在这两种情况下，都不需要是self.A
，只需要具有相同值的对象

因此，最终我们会有这样的结果：

self.A = ['First']
self.container = [['First'], ['First'], ['First']]

# ...check and remove goes here

在这种情况下，由于
self.container
确实包含一个
列表
，其值等于
self.a
，并且
self.a
不是空的，因此第一个检查通过，然后到达
print（'OUT OF a'）
。然后，删除第一个
列表
，但在下一次迭代中该条件仍然为真，因为所有剩余的
列表
都具有相同的值
 原因是
在
和
删除
工作的方式

您的困惑可能源于这样一种误解，即

中的

询问特定容器是否包含特定对象，而remove会删除特定对象，因此当您调用（例如，
.remove（self.a）
时，您希望删除
self.a
指向的
列表

但是，实际上，
中的
只是查看容器中是否存在具有特定值的对象，而
remove
删除容器中具有该值的第一个对象。在这两种情况下，都不需要是self.A
，只需要具有相同值的对象

因此，最终我们会有这样的结果：

self.A = ['First']
self.container = [['First'], ['First'], ['First']]

# ...check and remove goes here

在这种情况下，由于
self.container
确实包含一个
列表
，其值等于
self.a
，并且
self.a
不是空的，因此第一个检查通过，然后到达
print（'OUT OF a'）
。然后，删除第一个
列表
，但在下一次迭代中该条件仍然为真，因为所有剩余的
列表
都具有相同的值
 “入”和“出”的工作是平等的，而不是身份。因此，只有一些空列表被删除，而不一定是所需的列表。“in”和“remove”是平等的，而不是等同的。因此，只删除一些空列表，而不一定是所需的列表。