像 Python、JavaScript 这类的动态语言，基本上都是使用引用赋值的，不管是基本数据类型，还是复杂的数据类型，都是按照引用传值。

引用赋值

在引用赋值中，变量名和变量的真实值是分开保存的，变量名中保存的是真实值的一个指针，对变量赋值时，也是将这个指针赋值给新变量。我们在使用变量的时候，不必关心它们的指针指向哪里，语言内部在实现的时候会帮助我们找到真实值，感觉上变量名和变量的真实值是保存在一起的，实际上他们是保存在不同的内存空间。
在 Python 语言中，无论什么数据类型，都是按照引用进行赋值的。
使用 id 方法可以查看变量的真实值在内存空间中的地址（复杂数据类型为首地址）：

# 定义基本数据类型
a = 100
b = a
print(id(a),id(b))

# 定义复杂数据类型
arr1 = [1,2,3]
arr2 = arr1

print(id(arr1),id(arr2))

运行结果：

506224448 506224448
27666752 27666752

a 和 b，arr1 和 arr2 中都指向了同一份内存地址。示意图如下：

引用赋值图解.png

注：上图中的列表 [1,2,3] 应该是保存在一片内存空间中的，示意图给简化了。

赋值操作

初始操作下，a 和 b、arr1 和 arr2 都指向了同一份内存空间，此时如果再对这些变量进行赋值操作，其就会指向新的内存空间。
如下代码：

# 定义基本数据类型
a = 100
b = a
b = 1001
print(id(a),id(b))

# 定义复杂数据类型
arr1 = [1,2,3]
arr2 = arr1
arr2 = [1,2,3,1]

print(id(arr1),id(arr2))

运行结果为：

495673152 25390400
29763904 29736272

可见，在使用 = 重新赋值后，原来的“引用”断开了，变量重新引用了新的内存地址，示意图如下：

重新引用.png

可变类型与不可变类型

Python 中有下面几种不可变类型：

• 数值型
• 字符串型
• 元组

除了不可变类型，其余的都是可变类型，如：

• 列表
• 字典

不可变类型，就是无法修改的类型，我们无法在内存中直接修改这个变量（如 100，"student"），如果我们尝试对不可变类型进行修改，就会断开原始的引用，重新分配内存地址。
可变类型，就是可以进行修改的类型，修改可变类型的值不会断开原始引用。
看下如下代码：

# 定义不可变类型
a = 100
print(id(a))
# 尝试修改不可变类型的值
a += 1;
print(id(a))

# 定义可变类型
arr = [1,2,3]
print(id(arr))
# 尝试修改可变类型的值
arr.append(4)
print(id(arr))

代码执行结果如下：

503603008
503603024
18622784
18622784

我们尝试修改不可变类型的值，原先的引用断开，重新分配新的引用。 当我们尝试修改可变类型的值时，原始的引用并不会断开。
解释器在运行代码时，会根据变量是否是可变类型来决定在原始值上进行修改还是重新引用，因此下面的代码理解起来就很简单了：

# 定义不可变类型
# 定义不可变类型
a = 100
b = a
a += 1
print(id(a),id(b))
print(a,b)

# 定义可变类型
arr1 = [1,2,3]
arr2 = arr1
arr1.remove(2)
print(id(arr1),id(arr2))
print(arr1,arr2)```
运行结果如下：

492330832 492330816
101 100
25962816 25962816
[1, 3] [1, 3]

修改可变类型时，是直接在原始值上进行修改，因此这些和原始值有引用关系的变量的“值”都被修改了。尝试修改不可变类型时，由于不可变类型的值是无法进行修改的，因此会断开原始的引用，重新分配新的引用，由于原始的值没有被修改，因此和原始值有引用关系的变量的“值”保持不变。
## 解释器对不可变类型的优化
前面说到，在使用 = 进行赋值时，会断开原先的引用，重新开辟一块内存，让变量指向新的内存的地址。在实际情况下，解释器对我们常用的一些值（数字、较短的字符串）进行了优化，只要将某个值赋值给变量，这些变量的的引用地址都是一样的，并不会重新开辟内存。
对于可变类型的值，仍会重新开启内存。
看下下面的代码：

定义不可变类型

a = 100
b = 100
c = 100
print(id(a),id(b),id(c))

定义可变类型

arr1 = [1,2]
arr2 = [1,2]
arr3 = [1,2]
print(id(arr1),id(arr2),id(arr3))

运行结果如下：

490626880 490626880 490626880
22489408 22461776 22499736

## 参数引用传递
除了赋值，函数的参数也是引用传递：

定义不可变类型

a = 100

定义可变类型

arr = [1,2,3]

def modify(v):
v += v

修改 a 的值

modify(100)
print(a)

修改 arr 的值

modify(arr)
print(arr)

运行结果如下：

100
[1, 2, 3, 1, 2, 3]

**在函数调用时，传递给函数的参数中保存的仍然是变量的引用（真实值的地址）**，函数参数是一个局部变量，初始时，参数和函数外部的值指向同一份内存地址。如果需要在函数内部对参数进行修改，同样遵循上面的规则：
- 如果参数是不可变类型，则断开原始引用，重新进行新的引用，函数外部的值不受影响
- 如果参数是可变类型，直接修改原始值，函数外部的值同步变化

## 总结
本文学习了 Python 中的引用，总结以下几点：
- 所有的变量赋值、参数传递等都是引用传递
- 修改变量值时，解释器根据变量是否可变决定是修改原始值还是重新进行引用
- 如果变量是可变类型，则所有和原始值有引用关系的变量都会受到影响
- 如果变量是不可变类型，则所有和原始值有引用关系的变量不受影响
- 解释器对常用的不可变类型进行了优化，把常用的数值、短字符串赋值给某些变量时，这些变量都指向相同的内存地址

完。