引言

初学Python的新手，对变量这个概念的理解似乎是第一个门槛。其实，不光是Python，学习任何一门高级编程语言，比如C/C++、Java等，也是同样的问题。

变量按照其存储的内容的类型，分为整型、浮点型、字符型、集合型等；
变量按照是否可变（这点最奇怪，新手估计要挣扎好久），又可以分为值类型（也叫不可变类型）和引用类型（也叫可变类型）。

Python作为一门动态类型语言，一个变量可以一会儿是整型，一会儿是字符串型，一会儿又变成集合类型，新手也会有所困惑……

其实，不光是新手，熟练使用Python多年的老手，对变量的真正细节，也不敢说全都知道，只是会用、唯手熟尔。

这篇文章，通过分析代码的执行过程，结合内存的存储结构及字节码指令的执行，希望能帮助Python爱好者们，真正搞懂“变量”。

准备知识

一切皆对象

Python是一门面向对象的编程语言。对面向对象暂时不太清楚的，可以简单理解为，对象就是把数据和数据处理方法封装在一起的一个数据结构。新手的话，想要学习面向对象语法的可以随便找本教材学一下或者问下ChatGPT，我这里帮你们问了一下：

说实话，新手看了估计更晕，现在脑海里有个对象的概念吧。
一切皆对象，一个整数是一个对象，一个字符串是一个对象，一个函数是一个对象，一个集合也是一个对象。

对象的身份标识id()

如同我们每个人都有一个身份证或者护照，能够唯一标识我们自己。在Python的世界中，每一个对象也有一个唯一标识。我们可以通过id()这个函数，获取一个对象的唯一标识。

x = 3
print(id(x))
print(id(3))

上述代码中，我们定义了一个变量x，并将其赋值为3。然后，我们分别将变量名x和数字3作为对象传给id()函数，获取这两个对象的id。输出的id应该是相同的，也就是x和3其实是同一个对象。

有的教材中，或者Python大神说，id()函数返回一个对象在内存中的地址，其实是不严谨的，id()就是返回一个对象的身份标识，这个身份标识，可以是对象在内存中的地址，也可以不是。

我们可以通过id()函数的定义来，更清楚的了解到这一点：

def id(*args, **kwargs): # real signature unknown
    """
    Return the identity of an object.
    
    This is guaranteed to be unique among simultaneously existing objects.
    (CPython uses the object's memory address.)
    """
    pass

从id()函数的定义描述中，可以看出id函数所要返回的是一个对象的唯一身份标识，确保在对象的整个生命周期内都是可以被唯一标识的。
而在CPython这个虚拟机实现中，将对象在内存中的地址作为对象的唯一身份标识。

怎么在PyCharm中快速查看函数id()的定义，可以参考前面的文章，或者自行百度，也可以通过help()函数来查看：

help(id)

输出结果：

注意：如果终端一直没有结束，可以试着敲键盘上的Q键返回，quit的意思。

程序执行中的内存结构

程序执行大概得内存结构如下所示：

只是一个大概的示意，并不准确，但是这个大致的结构，在所有的编程语言中，应该都是相通的，大同小异的。

栈内存

程序执行之初，会申请一块内存，作为程序执行过程、函数调用的上下文存储的结构，比如存储字节码命令的操作数、函数的参数，函数返回值等，作为一个栈。
对栈的操作，是后进先出的。把数据存储到栈中，叫做入栈，也称为压栈；把栈顶部的数据取出来，叫出栈。

堆内存

堆内存，用于存储对象的。
常量池、变量池的叫法不一定严谨，只是演示，不同的Python虚拟机实现细节不太一样。
我们暂且粗糙的这样理解：

• 变量存放在变量池，变量池可以理解为是一个列表，每一个元素对应一个变量，元素中存放的是变量对应对象的id
• 常量存放在常量池，常量中存放的也是对象，但是是不可变的

准备知识到此为止，都是干活，建议好好消化一下，或者自行找材料再扩充一下。

实例分析

接下来，我们通过几行简单的变量赋值的代码，来看变量在内存中的实际存储的动态变化，从而更加清晰地理解变量的变与不变。

首先，需要说明的是，Python代码在编译执行的时候，会首先把代码中所有出现的字面量，比如数字3、字符串"hello world"等都先在常量池中构建出对应的不可变对象。

整型变量的赋值

# int 类型变量
x = 1
y = 1
print(id(x))
print(id(y))

x = 1，虽然只是一个赋值操作，实际上会转换为两条字节码指令执行，上面前两行赋值语句对应的字节码指令会是如下的格式：

  2           2 LOAD_CONST               0 (1)
              4 STORE_NAME               0 (x)
  3           6 LOAD_CONST               0 (1)
              8 STORE_NAME               1 (y)

最左侧的2、3，是字节码指令所翻译的源代码对应的代码行号；
第二列的2、4、6、8，是字节码指令在字节码文件中指令序列的偏移，这两种字节码指令均是2个字节的长度；
第三列是字节码指令的名称，第四列是指令的操作数，()中是操作数的实际内容：

• LOAD_CONST：表示将常量池中的对象的id压栈；
• STORE_NAME：表示将栈顶的值取出，并存储到变量池中的变量中
  每一个变量赋值操作，都是由这样的指令对组成。

上面代码执行完成后，内存的示意图如下：

接下来，添加几行代码，我们改变x的值：

# int 类型变量
x = 1
y = 1
print(id(x))
print(id(y))
x = 3
print(id(x))
print(id(3))
print(id(y))
print(id(1))

执行完成后，内存中会发生改变：

执行后，常量池中会多1个对象3，x存储对象3的id，y仍然不变。

字符串、元组类型的变量，也是属于值类型的变量，其赋值修改过程，都是类似于整型变量的上述过程，都是先在常量池中构建对象，然后变量中存储对象的id，修改变量值，其实就是创建新的对象，变量存储新的对象的id的过程。

列表的赋值与更新操作

列表属于可变对象，属于引用类型，其赋值、更新操作会与前面的值类型操作有所不同。
首先看赋值的代码：

a = [1, 2, 3]
b = [1, 2, 3]
c = (1, 2, 3)
d = c
print(id(a))
print(id(b))
print(id(c))
print(id(d))
print(id((1, 2, 3)))

同样，我们看下列表赋值的代码的对应的字节码指令：

1           2 BUILD_LIST               0
              4 LOAD_CONST               0 ((1, 2, 3))
              6 LIST_EXTEND              1
              8 STORE_NAME               0 (a)

  2          10 BUILD_LIST               0
             12 LOAD_CONST               0 ((1, 2, 3))
             14 LIST_EXTEND              1
             16 STORE_NAME               1 (b)

  3          18 LOAD_CONST               0 ((1, 2, 3))
             20 STORE_NAME               2 (c)

  4          22 LOAD_NAME                2 (c)
             24 STORE_NAME               3 (d)

第一行：a = [1, 2, 3]，被翻译为了4条字节码指令：

• BUILD_LIST：表示在内存空间构造一个空的list对象；
• LOAD_CONST：表示将常量池中的元组对象(1,2,3)的id压栈；
• LIST_EXTEND：利用栈中的id对应的元组对象扩展第一步构造的空列表对象；
• STORE_NAME：将构造的列表对象的id，存储到变量a中

所以，从字节码的执行可知：列表的赋值，首先还是会先构造一个元组对象(1,2,3)放到常量池中，然后基于元组对象填充列表对象。

代码输出如下：

4309145728
4309246144
4309883968
4309883968
4309883968

以上代码执行完成后，对应的内存示意图如下：

接下来，我们添加改变变量值的代码：

a = [1, 2, 3]
b = [1, 2, 3]
c = (1, 2, 3)
d = c
# print(id(a))
# print(id(b))
# print(id(c))
# print(id(d))
# print(id((1, 2, 3)))
# 以下为本次新增代码
b = a 
b[0] = 100
print(id(a))
print(id(b))
print(a)
print(b)

上述新增代码执行完成，内存结构将发生变化：

通过示意图，我们就能清楚的理解，为什么b[0]发生变化，a[0]也跟着变化了。因为a与b已经存储了同一个对象的id值。

以上，就是这篇文章所要传递的所有内容了。
需要说明：关于字节码指令，不理解也没有关系，只是为了演示一下一行代码的执行其实也是要分几个步骤来完成的。
后续有时间的话，会再写一篇关于Python字节码的文章，感兴趣的后面可以关注一下。
内存结构的示意图，虽然不够严谨，但是大体上应该能够对变量的底层细节有更加清晰的认知。