在python中定义a=b=class_name（value1）b=class_name（value2）后，两个值是相同和不同的

在以下代码中，我了解到

树

（在代码中命名）和

父项

（在代码中命名）的打印不应相同。但是我不明白，为什么

树总是根据
父项的更新而更新？
（此问题继续最后一个问题）

代码：

在代码中，很明显，
父级
在循环中每次都会重新初始化，但根据我的理解，当
父级
正在更新时，
树
不应该相应地更新。因为一旦在循环中重新初始化了
父级
，它就不再具有与
树
相同的id（可能是地址），那么
树
将不会根据
父级
进行更改

问题：

为什么
树
仍然根据
父项
更新，即使
id（父项）
在循环中每次都会更改


树
如何链接到循环内的父级
？e、 例如，
节点[1]
，
节点[2]
（更新）


感谢您的任何评论或解释，提前感谢
 我认为这是因为树总是指向根节点，而父节点指向下一个节点

让我们定义一些术语：


节点[0]：创建的第一个节点
节点[1]：创建的第二个节点
ref（节点[X]）：对节点X的引用
ref（节点[0]）->ref（节点[1]）：引用节点0，该节点的子节点为节点1

步骤0

tree = parent = node(list_0[0])

tree is pointing to ref(node[0])

parent is pointing to ref(node[0])

步骤1（while循环内）

步骤n

tree still pointing to ref(node[0]) -> ref(node[1]) -> .... -> ref(node[n])

parent is pointing to ref(node[n])

更形象地解释这一点：

# Step 0
tree, parent  ->  node[0]

# Step 1
tree   ->         node[0]
                    |
parent ->         node[1]

# Step 2
tree   ->         node[0]
                    |
                  node[1]
                    |
parent ->         node[2]

# Step n
tree   ->         node[0]
                    |
                  node[1]
                    |
                   ...
                    |
parent ->         node[n]

正在添加一个节点作为此行中另一个节点的子节点：

parent.add(current_node)

所以树总是指向树的根元素，父元素总是指向树的最后一个元素。这就是ID不同的原因

我希望我已经为你提供了有用的信息
 新的
父项
仍然是上一个
父项
的子项，因此向其添加子项会将“孙子”添加到上一个。因此，原始树一直在增长。感谢@schwobasegll，如果它是如您所述的，即“循环中的
父项
是
父项
的
子项
，为什么
打印（父项）
（最后一行）与
打印（树）
没有相同的结果？最后一个
父项
是“原始
父项
”（在循环上方）还是
子项/孙项
？谢谢循环不会在python中打开新的作用域（或命名空间）。循环后的
父绑定是循环最后一次迭代中的绑定。Thanks@AlbertFX91这是很清楚的。还有一个问题：在“步骤1”中，如何实现仍然指向ref（节点[0]）->ref（节点[1]）
的
树？为什么
ref（节点[0]）
可以引用
ref（节点[1]）
？不客气！在步骤0中，创建节点[0]，但不包含子节点。节点[0]被分配给变量树和父节点。在下一步中，将在前一个节点上添加一个新节点，因此节点[0]有一个新的子节点[1]。树仍指向节点[0]，但父节点指向节点[1]！我修改了答案，增加了一个更生动的解释方式！您好，谢谢，我现在看到了，我想知道您的“步骤1”，即
树（节点[0]）如何链接到
节点[1]
。现在我看到这是因为
parent.add（当前_节点）
，此时
parent
还不是一个新的
节点（节点[1]）。它指向
父节点=当前节点
之后的新
节点
（节点[1]）。非常感谢：）不客气！！：）
tree still pointing to ref(node[0]) -> ref(node[1]) -> .... -> ref(node[n])

parent is pointing to ref(node[n])

# Step 0
tree, parent  ->  node[0]

# Step 1
tree   ->         node[0]
                    |
parent ->         node[1]

# Step 2
tree   ->         node[0]
                    |
                  node[1]
                    |
parent ->         node[2]

# Step n
tree   ->         node[0]
                    |
                  node[1]
                    |
                   ...
                    |
parent ->         node[n]

parent.add(current_node)