在python中，让B=A后，一个实例A可以被另一个B修改吗？为什么？

Question

在下面的代码中，我创建了链表的头节点。但是我不知道为什么 'head' 的 '.next' 可以通过更新 'tail' 和 'tail.next':

来更新（迭代）

# Node class
class Node(object):
   def __init__(self,x):
     self.val = x
     self.next = None

# For a given list, creat a head node of it
def creat_link_tail(val_list):
   head = Node(val_list[0])
   tail = head
   for ele in val_list[1:]:
     tail.next = Node(ele)
     tail = tail.next
return head

lkt = creat_link_tail([5, 3, 2, 6, 7])  #lkt 5->3->2->6->7

Answer 1

But I don't know why the '.next' of 'head' can be update(iterated) by update 'tail' and 'tail.next':

您在 head 中存储了第一个元素：

head = Node(val_list[0])

然后你赋给它作为初始值tail:

tail = head

现在，tail 和 head 指向内存中完全相同的对象，该对象存储 Node(val_list[0]) 的相同实例。为了形象化这一点，我们可以检查使用的内存。

class Node(object):
   def __init__(self,x):
     self.val = x
     self.next = None

head = Node(0)
tail = head

print(id(head))  # Memory pointed to by head
print(id(tail))  # Memory pointed to by tail
print(head is tail)  # Checks if head is the same as tail

输出

22809434462432
22809434462432
True

如您所见，它们只是指向完全相同的对象。它们是不同的堆栈变量 head 和 tail 但它们的值指向堆中的同一个对象。因此，通过 . 从一个变量访问指向的对象，例如tail.next = Node(ele) 就像间接调用 head.next = Node(ele).

现在让我们尝试更改堆栈变量的值 tail 并将其指向另一个对象。

tail = Node(0)

print(id(head))
print(id(tail))
print(head is tail)

输出

22809434462432
22809434463632
False

现在你可以看到，head 和 tail 指向的对象现在不同了。

在python中，让B=A后，一个实例A可以被另一个B修改吗？为什么？

In python, an instance A can be revised by another one B after you let B=A? Why?

python

linked-list

instance