Python中的不可变对象类型与可变对象类型

1. 对象类型

不可变(immutable)对象类型
int
float
decimal
complex
bool
str
tuple
range
frozenset
bytes
可变(mutable)对象类型
list
dict
set
bytearray
user-defined classes (unless specifically made immutable)

2. 变量

Python中的变量都是指针，这确实和之前学过的强类型语言是有不同的。 因为变量是指针，所以 所有的变量无类型限制，可以指向任意对象 。指针的内存空间大小是与类型无关的，其内存空间只是保存了所指向数据的内存地址。

Python 的所有变量其实都是指向内存中的对象的一个指针，所有的变量都是！

此外， 对象还分两类：一类是可修改的，一类是不可修改的。 我的理解是把可修改(mutable)的类型叫做值类型，不可修改(immutable)类型叫做引用类型。

3. 对象

对象=确定内存空间+存储在这块内存空间中的值。

Java中，对象是分配在堆上的，存储真正的数据，而引用是在栈中 开辟的内存空间用于引用某一个对象（值类型的变量也是存储到栈上）。

4. 值类型（不可变对象）

在Python中，数值（整型，浮点型），布尔型，字符串，元组属于值类型， 本身不允许被修改 （不可变类型）， 数值的修改实际上是让变量指向了一个新的对象 （新创建的对象），所以不会发生共享内存问题。这种方式同Java的不可变对象（String）实现方式相同。 原始对象被Python的GC回收。

a = 1
b = a
a = 2
print(b)  #输出的结果是1 修改值类型的值，只是让它指向一个新的内存地址，并不会改变变量b的值。

 1 >>> x = 1
 2 >>> id(x)
 3 31106520
 4 >>> y = 1
 5 >>> id(y)
 6 31106520
 7 >>> x = 2
 8 >>> id(x)
 9 31106508
10 >>> y = 2
11 >>> id(y)
12 31106508
13 >>> z = y
14 >>> id(z)
15 31106508
16 >>> x += 2
17 >>> id(x)
18 31106484

对不可变数据类型中的int类型的操作 ，id()查看的是当前变量的地址值。

x = 1和y = 1两个操作的结果，从上面的输出可以看到x和y在此时的地址值是一样的，也就是说x和y其实是引用了同一个对象，即1， 也就是说内存中对于1只占用了一个地址 ，而不管有多少个引用指向了它，都只有一个地址值，只是 有一个引用计数会记录指向这个地址的引用到底有几个 而已。

当我们进行x = 2赋值时，发现x的地址值变了，虽然还是x这个引用，但是其地址值却变化了，后面的y = 2以及z = y，使得x、y和z都引用了同一个对象，即2，所以地址值都是一样的。

当x和y都被赋值2后， 1这个对象已经没有引用指向它了，所以1这个对象占用的内存 ，即31106520地址要被 “垃圾回收” ，即1这个对象在内存中已经不存在了。

最后，x进行了加2的操作，所以 创建了新的对象4，x引用了这个新的对象，而不再引用2这个对象 。

那么为什么称之为不可变数据类型呢？

这里的不可变大家可以理解为 x引用的地址处的值是不能被改变的，也就是31106520地址处的值在没被垃圾回收之前一直都是1，不能改变 ，如果要把x赋值为2，那么只能将x引用的地址从31106520变为31106508，相当于x = 2这个赋值又创建了一个对象，即2这个对象，然后x、y、z都引用了这个对象，所以int这个数据类型是不可变的， 如果想对int类型的变量再次赋值，在内存中相当于又创建了一个新的对象，而不再是之前的对象。 从下图中就可以看到上面程序的过程。

备注：图片中错误。x=2，y=2，z=y。

从上面的过程可以看出，不可变数据类型的优点就是内存中 不管有多少个引用，相同的对象只占用了一块内存 ，但是它的缺点就是当需要对变量进行运算从而改变变量引用的对象的值时，由于是不可变的数据类型，所以必须创建新的对象，这样就会使得一次次的改变创建了一个个新的对象，不过不再使用的内存会被垃圾回收器回收。

5. 引用类型（可变类型）

在Python中， 列表，集合，字典 是引用类型，本身允许修改（ 可变类型 ）。

1 list_a = [1,2]
2 list_b = list_a
3 list_a[0] = 3
4 print(list_b)  #此时的输出结果是[3,2]

修改引用类型的值，因为list_b的地址和list_a的一致，所以也会被修改。

 1 >>> a = [1, 2, 3]
 2 >>> id(a)
 3 41568816
 4 >>> a = [1, 2, 3]
 5 >>> id(a)
 6 41575088
 7 >>> a.append(4)
 8 >>> id(a)
 9 41575088
10 >>> a += [2]
11 >>> id(a)
12 41575088
13 >>> a
14 [1, 2, 3, 4, 2]

从上面的程序中可以看出，进行两次a = [1, 2, 3]操作，两次a引用的地址值是不同的，也就是说其实创建了两个不同的对象，这一点明显不同于不可变数据类型，所以 对于可变数据类型来说 ，具有同样值的对象是不同的对象，即在 内存中保存了多个同样值的对象，地址值不同。

我们对列表进行添加操作，分别a.append(4)和a += [2]，发现这两个操作使得a引用的对象值变成了上面的最终结果，但是a引用的地址依旧是41575088，也就是说对a进行的操作不会改变a引用的地址值，只是在地址后面又扩充了新的地址，改变了地址里面存放的值，所以可变数据类型的意思就是说对一个变量进行操作时，其值是可变的， 值的变化并不会引起新建对象，即地址是不会变的 ，只是地址中的内容变化了或者地址得到了扩充。

可变数据类型是允许同一对象的内容，即值可以变化，但是地址是不会变化的。但是需要注意一点， 对可变数据类型的操作不能是直接进行新的赋值操作 ，比如说a = [1, 2, 3, 4, 5, 6, 7]， 这样的操作就不是改变值了，而是新建了一个新的对象 ，这里的可变只是对于类似于append、+=等这种操作。

6. 不可变的例外

并非所有的不可变对象都是不可变的。

如前所述，Python容器比如元组，是不可变的。这意味着一个tuple的值在创建后无法更改。但是元组的“值”实际上是一系列名称，它们与对象的绑定是不可改变的。关键点是要注意绑定是不可改变的，而不是它们绑定的对象。

让我们考虑一个元组t =（'holberton'，[1，2，3]）

上面的元组t包含不同数据类型的元素，第一个元素是一个不可变的字符串，第二个元素是一个可变列表。元组本身不可变。即它没有任何改变其内容的方法。同样，字符串是不可变的，因为字符串没有任何可变方法。但是列表对象确实有可变方法，所以可以改变它。这是一个微妙的点，但是非常重要： 不可变对象的“值” 不能改变，但它的组成对象是能做到改变的。

其实主要原因是元组内保存的是变量（也就是内存地址）。所以 当变量指向对象发生变化时，如果导致变量发生变化（即不可变类型），此时元组保证该不可变类型不能修改 。而 如果当变量指向对象发生变化时，如果不会导致变量发生变化（即可变类型），此时元组中存储的该可变类型可以修改（因为变量本身并无变化） 。

7. 总结

python中的不可变数据类型，不允许变量的值发生变化，如果改变了变量的值，相当于是新建了一个对象，而对于相同的值的对象，在内存中则只有一个对象，内部会有一个引用计数来记录有多少个变量引用这个对象；

可变数据类型，允许变量的值发生变化，即如果对变量进行append、+=等这种操作后，只是改变了变量的值，而不会新建一个对象，变量引用的对象的地址也不会变化，不过对于相同的值的不同对象，在内存中则会存在不同的对象，即每个对象都有自己的地址，相当于内存中对于同值的对象保存了多份，这里不存在引用计数，是实实在在的对象。

8. 参数传递

C++中是传值和传引用（指针）。c语言加上*号传递指针就是引用传递，而直接传递变量名就是值传递)

Java是传值（传值和传引用，只不过引用就是内存地址，所以也是值）。Java里区分值和引用，是因为值存储在栈里，而引用对象存储在堆里（引用本身在栈里）。

而Python所有的都是对象，都是引用，所以所谓的值类型都是不可变类型。类似于Java的字符串类型。

所以 Python中的参数传递都是传递引用 ，也就是传递的是内存地址。只不过对于不可变类型，传递引用和传递值没什么区别。而对于可变类型，传递引用是真的传递内存的地址。

听说 python只允许引用传递是为方便内存管理，因为python使用的内存回收机制是计数器回收 ，就是每块内存上有一个计数器，表示当前有多少个对象指向该内存。每当一个变量不再使用时，就让该计数器-1，有新对象指向该内存时就让计数器+1，当计时器为0时，就可以收回这块内存了。当然还有其他的GC方法，否则计数器回收，无法解决循环引用的问题。

值传递: 表示直接传递变量的值，把传递过来的变量的值复制到形参中，这样在函数内部的操作不会影响到外部的变量。

引用传递: 把引用理解为变量（标识符）与数据之间的引用关系，标识符通过引用指向某块内存地址。而引用传递，传递过来的就是这个关系，当你修改内容的时候，就是修改这个标识符所指向的内存地址中的内容，因为外部也是指向这个内存中的内容的，所以，在函数内部修改就会影响函数外部的内容。

另外：列表，字典，集合是容器类型，嵌套引用。