一文读懂 Python 值传递和引用传递

前言

• 在编程语言中，值传递（pass by value）和引用传递（pass by reference）是两个重要的概念。它们涉及到变量在函数调用中的传递方式，对于理解函数调用和参数传递的机制至关重要。在本文中，我们将深入探讨 Python 中的值传递和引用传递，并通过代码示例进行说明。

形参和实参

• 我们先了解一点前置知识，形参和实参，先说概念：形参出现在函数定义中，在整个函数体内都可使用，离开函数体则不可使用。实参出现在主调函数中，进入被调函数后，不能使用。

def func(param):
    # 这里 param 为形参
    print(param)


if __name__ == "__main__":
    # 这里的 a 就是实参
    a = 1
    func(a)

复制运行

值传递和引用传递

• 我们先了解一下值传递和引用传递的概念：值传递是指在调用方式时，将实参的值拷贝一份给形参，对形参的修改不影响实参。引用传递也叫地址传递，指在调用方法时将实参的地址传递给形参，对形参的修改将影响实参的值，即传递的是实参的内存地址。

Python 变量存储

• 对于python而言，python的一切变量都是对象，变量的存储采用了引用语义的方式，存储的只是一个变量的值所在的内存地址，而不是这个变量的只本身。
• 

• 代码实测：

a = 1
print(f"变量a的地址：{id(a)}")

b = 1
print(f"变量b的地址：{id(b)}")

b = 2
print(f"变量b的地址：{id(b)}")

复制运行

• 上面实例输出如下：

变量a的地址：2483649669424
变量b的地址：2483649669424
变量b的地址：2483649669456

复制

• 从实际用例我们可以看出，a、b = 1 时，这里底层为了性能考虑指向相同的内存，当 b 发生改变时，发生写时复制，b 指向了新的内存地址。

值语义和引用语义

值语义

• 值语义是指将变量赋值为另一个变量时，会复制变量的值，而不是引用原始值所在的内存地址。如 Java 的基本数据类型。

引用语义

• 引用语义是指将变量赋值为另一个变量时，实际上是将变量指向同一个对象的内存地址，而不是复制对象的值。如 Java 的引用数据类型、Python 值存储。

探讨 Python 值传递和引用传递

• 了解完上面的一些基本概念后，我们从可变（mutable）和不可变（immutable）两种类型来探讨 Python 值传递和引用传递：

不可变（immutable）类型

• 不可变变量的值一旦创建，就不能被修改。如果你尝试修改一个不可变对象的值，Python 将会创建一个新的对象。Python 中的不可变对象包括整数（int）、浮点数（float）、字符串（str）、元组（tuple）等。
• 先简单看一个下面的例子：

def modify_value(x):
    print(f"变量x修改前地址：{id(x)}")
    x = x + 10
    print(f"变量x修改后地址：{id(x)}")
    print("函数内部修改后的值为:", x)


# 调用函数
value = 5
print(f"变量value地址：{id(value)}")
modify_value(value)
print("函数外部原始值为:", value)

复制运行

• 在这个示例中，我们定义了一个函数 modify_value，它接受一个参数 x。在函数内部，我们对 x 的值进行修改，并打印出修改后的值。然后我们调用函数，传递了一个值为 5 的参数 value。运行以上代码，将会输出：

变量value地址：1886976960944
变量x修改前地址：1886976960944
变量x修改后地址：1886976961264
函数内部修改后的值为: 15
函数外部原始值为: 5

复制

• 可以看到，尽管在函数内部修改了形式参数 x 的值，但并没有影响到函数外部实际参数 value 的值，而发生了写时复制。

可变（mutable）类型

• 可变变量的值可以在原地修改，而不会创建一个新的对象。Python 中的可变对象包括列表（list）、字典（dict）、集合（set）等。
• 我们以 list 类型为例：

案例一

def modify_list(list):
    print(f"变量list地址：{id(list)}")
    list[2] = 4
    print(f"变量list修改地址：{id(list)}")
    print("函数内部修改后的列表为:", list)


# 调用函数
my_list = [1, 2, 3]
print(f"变量my_list地址：{id(my_list)}")
modify_list(my_list)
print("函数外部原始列表为:", my_list)

复制运行

• 输出如下：

变量my_list地址：2115249727936
变量list地址：2115249727936
变量list修改地址：2115249727936
函数内部修改后的列表为: [1, 2, 4]
函数外部原始列表为: [1, 2, 4]

复制

案例二

def modify_list(list):
    print(f"变量list地址：{id(list)}")
    list = [6, 6, 6]
    print(f"变量list修改地址：{id(list)}")
    print("函数内部修改后的列表为:", list)


# 调用函数
my_list = [1, 2, 3]
print(f"变量my_list地址：{id(my_list)}")
modify_list(my_list)
print("函数外部原始列表为:", my_list)

复制运行

• 输出如下：

变量my_list地址：2141908331136
变量list地址：2141908331136
变量list修改地址：2141908181248
函数内部修改后的列表为: [6, 6, 6]
函数外部原始列表为: [1, 2, 3]

复制

• 看完上面的两个案例你是否有些许疑惑，案例一修改了函数外的原始值，案例二未修改函数外的原始值，下面我们用图解来解释一下上面发生了什么：
• 
• 

• 从图解中我们可以清晰的看到，在案例一和案例二中函数传递了 my_list 地址的拷贝值，案例一中持有数组的内存地址，因此成功修改了原数组元素，案例二中 list 的内存地址修改为新的数组内存地址，并没有修改原数组的值。
• 通过对可变（mutable）和不可变（immutable）两种类型的函数传递的分析，我们可以知道由于 Python 中一切皆对象的特性，实际传递给函数的都是内存地址的拷贝，从表现上来说，我们可以说 Python 中都是值传递，了解过 Java 的同学会发现这里和 Java 的引用类型原理一致。

拓展：不可变类型真的不可变？

• 上面我们提到了可变类型和不可变类型，不可变类型真的是不可变的？我们来看下面的案例：

arr = (1, 2, [4, 4])

print(f"元组修改前：{arr}")
arr[2][0] = 2
print(f"元组修改后：{arr}")

复制运行

• 输出结果：

元组修改前：(1, 2, [4, 4])
元组修改后：(1, 2, [2, 4])

复制

• 上面的案例中不可变类型出现了变化，这个是 bug ? 其实并不是，不可变类型的不可变指的是组成的元素是不可变的，在上面的案例 arr 元组中存储的是对应的内存地址，而不可变指的是内存地址和指向无法改变，但如果内存地址指向的是可变类型，比如数组，那么元素内部是可变的。

总结

• 本文以值传递、引用传递的基本概念、以及 Python 变量存储为基础，从可变（mutable）和不可变（immutable）两种类型来分析 Python 值传递和引用传递的真相，通过充足的案例分析我们发现，Python变量 和 Java 引用类型类似，只存在值传递。