Python变量大多很容易理解，但有一种情况一直让我苦恼。如果我想将我的变量指向一个新的内存地址，我该怎么做？或者说，如果Python默认这样做（将变量视为指针），那么如何将一个新变量的值文字上赋给旧变量的内存地址?
例如，如果我键入：
a=1
b=2
c=a
c=b
c的值是多少？它指向什么？这个语句是将指针c->a替换为指针c->b还是获取b的值，并将a用b的值覆盖掉？c=b是含糊不清的。
换句话说，如果您从这里开始：
a -> 1 <- c
b -> 2
这是否像这样重新指向c：
a -> 1 _c
b -> 2 <-/
或者像这样复制b？
a -> 2 <- c
b -> 2
a -> 0xfffa9600 -> 1
b -> 0xfffa9608 -> 2
在您进行c = a赋值后，它将会变成这样:
a -> 0xfffa9600 -> 1
b -> 0xfffa9608 -> 2
c -> 0xfffa9600 -> 1
c完全独立于a。当你运行 c = b时，它会用与b关联的指针替换符号表中与c关联的指针，但a不受影响。a -> 0xfffa9600 -> 1
b -> 0xfffa9608 -> 2
c -> 0xfffa9608 -> 2
在这种情况下，由于所涉及的对象即整数常量1和2是不可变的，因此基本上就是这样了。但是，如果您使用可变对象，则它们会开始有些像指针，因为将对象存储在一个变量中时对对象进行的更改会反映在引用同一对象的其他变量中。例如，请考虑以下代码示例：
x = {'a': 1, 'b': 2}
y = x
在这里，符号表可能看起来像这样：
x -> 0xffdc1040 -> {'a': 1, 'b': 2}
y -> 0xffdc1040 -> {'a': 1, 'b': 2}
如果你现在运行
y['b'] = y['a']
那么它实际上不会改变符号表中与y相关联的指针，但它确实会改变该指针所指向的对象，因此你最终会得到
x -> 0xffdc1040 -> {'a': 1, 'b': 1}
y -> 0xffdc1040 -> {'a': 1, 'b': 1}
你会发现对 y['b'] 的赋值也影响了 x。与此形成对比的是:
y['b'] has affected x as well. Contrast this withy = {'a': 1, 'b': 2}
实际上有几个符号表，对应不同的作用域，Python 有一种检查它们的顺序，但这个细节在这里并不特别相关。
2这实际上使 y 指向一个完全不同的对象，更类似于您之前使用 a、b 和 c 的方式。
c -> a 时，在我的脑海中，我正在将 a 解析为存储值为1的物理内存位置。似乎Python有一个额外的解析层。我的C++背景在Python中引起了困惑。 - Ryanid()确实会给出内存地址。其他Python解释器(或CPython的未来版本)可能会有所不同。 - David Zc并不是指向a或者b，而是指向1或者2对象。
>>> a = 1
>>> b = 2
>>> c = a
>>> c
1
>>> c = b
>>> c
2
>>> b = 3
>>> c
2
这可以通过 id() 得到证明 - b 和 c 指向同一个 "thing"：
>>> b = 2
>>> c = b
>>> id(b)
42766656
>>> id(c)
42766656
c分离的对象至关重要。c是一个包含指向另一个内存位置（称为1）的指针的内存位置，但在C++中，c是包含数据1的内存位置。 - Ryanid()。希望这能帮助你更好地理解底层发生了什么。>>> a=1
>>> b=2
>>> print(id(a))
1574071312 # this is the address of a
>>> print(id(b))
1574071344 # this is the address of b
>>>c=a # assignment of a to c
>>> print(c)
1 # c will contain now the value of a
>>> print(id(c))
1574071312 # this is the address of c which is same as a
>>> c=b # re-assignment of b to c
>>> print(c)
2 # c wil contain now the value of b
>>> print(id(c))
1574071344 # this the address of c now which is same as b
在这个例子中，如果c指向a，它们看起来指向相同的值，但实际上并不是。例如，如果你指向...
a = 2
c = a
c 的值也将更改为 3 。
想象一下那些变量值 [2] [3] 在盒子中，变量 a，b，c 只是指向那些盒子。
如果一个变量 a 指向一个盒子，而另一个变量 c 指向变量 a 指向的盒子 [2] ，则最后一个变量 c 只是跟随第一个变量 a ，而不是值 [2] ，希望这个解释让你满意。
First, we create a value.
[value obj]
Note: [ ] denotes a physical memory location. This means the value has its own unique memory address.
Next, we create a label.
[Label obj] -> nothing
Last, we assign the label to its value.
[Label obj] -> [value obj]
a = 1
是等同于
[memorylocation containing "a"] -> [memorylocation containing 1]
并且
c = b
与
是相同的。[memorylocation containing "c"] -> "b" resolved to [memorylocation containing 2]
如果你从对象和它们的值的角度思考，并使用在 Python 中，赋值语句不会复制对象，它们只是在目标和对象之间创建绑定关系。
is 运算符 和 id() 内置函数，你可以观察到它是如何工作的。>>> a=1
>>> b=2
>>> c=a
>>> a is c
True
>>> id(a), id(c)
(10932288, 10932288)
>>> id(a), id(c)
除此之外，你还可以通过引用计数来精确地验证相同之处：
>>> import sys
>>> a=1
>>> b=2
>>> sys.getrefcount(a)
803
>>> sys.getrefcount(b)
97
>>> c=a
>>> sys.getrefcount(c)
804
>>> sys.getrefcount(a)
804
>>> c=b
>>> sys.getrefcount(a)
803
>>> sys.getrefcount(b)
98
>>>
>>> import copy
>>> id(b),id(c)
(10932320, 10932320)
>>> c = copy.deepcopy(b)
>>> id(b),id(c)
(10932320, 10932320)
然而，如果您尝试分配元组或列表，情况就不同了：
>>> a = [1,2,3]
>>> b = [3,2,1]
>>> c = a
>>> id(a),id(c)
(139967175260872, 139967175260872)
>>> c = copy.deepcopy(a)
>>> id(a),id(c)
(139967175260872, 139967175315656)
>>> id(c),id(a)
(139967175260872, 139967175260872)
>>> a.append(25)
>>> id(c),id(a)
(139967175260872, 139967175260872)
>>> c
[1, 2, 3, 25]
>>>
当你想要保留原始数据时，这可能是不切实际的。当你想要最初拥有两个相同的对象，但随后让它们以自己的方式改变 - 这就是你想要只为对象本身进行浅复制或为包含在对象中的所有对象进行深复制的地方：
>>> c = copy.deepcopy(a)
>>> a.append(35)
>>> a
[1, 2, 3, 25, 35]
>>> c
[1, 2, 3, 25]
仅供演示目的，浅复制：
>>> c = a
>>> a.append([9,8,7])
>>> a
[1, 2, 3, 25, 35, [9, 8, 7]]
>>> c = a
>>> id(a), id(c), id(a[-1])
(139967175260872, 139967175260872, 139967175315656)
>>> c = copy.copy(a)
>>> id(a), id(c), id(a[-1])
(139967175260872, 139967175315528, 139967175315656)
同一主题下更好的例子请参见grc的精彩回答。
基本上，在第四行，将c变量被b的值覆盖。由于这是最后一条语句，c将保存值2。
好的，在你的代码中：
a=1
b=2
c=a
c=b
在将 c 分配给 b 的值之前，以及将 c 分配给 a 的值之后，c 将是 a。
然后，在代码的结尾处，c 将是 b，因为您正在重新分配变量。
第二个赋值基本上创建了一个新变量，不知道变量已经存在，所以它只会这样做，但无法访问先前保存的变量值。
c分配给b”时，C++开发人员会看到这并认为它是反向的。他们会“将b分配给c”，因为赋值运算符是一个非常低级别的操作，具有数据的隐含流/方向（检索b的值，malloc到内存堆，并将CPU寄存器转储到c处的内存位置）。 - Ryanc将是a"这样的话，但事实上c并不是a；相反，c与a恰好是同一个值。c和a之间没有关系，除了在程序执行的某个特定点上它们碰巧同时引用了相同的值。如果这个解释真的帮助你理解Python的工作方式，那很好，但我认为它有可能会像你提出问题时一样，混淆其他人的思维。 - David Za和b解析为它们实际的内存位置。只有对非C程序员来说才会有误导哈哈。 - Ryan
print（id（c）== id（b））和print（id（c）== id（a））来验证。现在，c和a之间的任何相似之处都被抹去了。关于名称，请参阅：https://docs.python.org/3/reference/executionmodel.html。我相信在SO上有更详细的答案关于这个话题。 - Anton vBR