首页 > 文章 > python教程

Python传参方式详解：值传递与引用传递

时间：2025-10-23 22:49:55 363浏览收藏

偷偷努力，悄无声息地变强，然后惊艳所有人！哈哈，小伙伴们又来学习啦~今天我将给大家介绍《Python值传递与引用传递详解》，这篇文章主要会讲到等等知识点，不知道大家对其都有多少了解，下面我们就一起来看一吧！当然，非常希望大家能多多评论，给出合理的建议，我们一起学习，一起进步！

Python采用“传对象引用”机制，即传递对象引用的副本。对于不可变对象（如整数、字符串），函数内部修改会创建新对象，不影响外部变量；对于可变对象（如列表、字典），函数内部的就地修改会影响外部对象，但重新绑定则不影响。因此，理解可变与不可变对象的行为差异是掌握Python参数传递的关键。

Python中的值传递和引用传递是怎样的？

Python中的“值传递”和“引用传递”并不是像C++或Java那样泾渭分明的概念。实际上，Python采用的是一种被称为“传对象引用”（pass-by-object-reference）的机制。这意味着当你将一个参数传递给函数时，实际上是将一个指向该对象的引用（或者说，是该引用的一个副本）传递给了函数。函数内部的参数名会成为原始对象的一个新别名。这个核心点，是理解Python参数传递的关键。

解决方案

要深入理解Python的参数传递，我们得从它的核心机制——“传对象引用”说起。想象一下，Python里的所有东西都是对象，变量名就像是贴在这些对象上的标签。当你把一个变量传给函数时，你并不是把标签本身（变量名）传过去，也不是把标签指向的对象复制一份传过去（除非你显式地做了复制），而是给函数内部的参数也贴上一个一模一样的标签，让它也指向同一个对象。

这个机制带来的实际效果，就取决于你传递的这个对象是“可变”的（mutable）还是“不可变”的（immutable）。

不可变对象（如整数、浮点数、字符串、元组）：当你将一个不可变对象传递给函数，并在函数内部尝试“修改”它时，实际上发生的是对函数内部那个新标签的“重新绑定”。也就是说，函数内部的参数名会指向一个新的对象，而外部的原始对象丝毫不受影响。

def modify_immutable(num):
    print(f"函数内部：原始num的ID是 {id(num)}")
    num = num + 10  # 这里不是修改原始num，而是将num这个局部变量重新绑定到一个新对象
    print(f"函数内部：修改后num的ID是 {id(num)}")
    print(f"函数内部：num的值是 {num}")

my_number = 5
print(f"函数外部：调用前my_number的ID是 {id(my_number)}")
modify_immutable(my_number)
print(f"函数外部：调用后my_number的值是 {my_number}")
print(f"函数外部：调用后my_number的ID是 {id(my_number)}")

你会发现，my_number 的 id 在函数调用前后没有变，值也没有变。函数内部的 num 在被重新赋值后，它的 id 变了，说明它指向了一个全新的整数对象。

可变对象（如列表、字典、集合）：当你将一个可变对象传递给函数，并在函数内部通过这个新标签对对象进行“就地修改”（in-place modification，比如列表的 append()、pop()，字典的 update()），那么这些修改会直接反映在函数外部的原始对象上，因为它们指向的是同一个对象。

def modify_mutable(my_list):
    print(f"函数内部：原始my_list的ID是 {id(my_list)}")
    my_list.append(4)  # 就地修改，原始列表会受影响
    print(f"函数内部：修改后my_list的ID是 {id(my_list)}")
    print(f"函数内部：my_list的值是 {my_list}")

my_data = [1, 2, 3]
print(f"函数外部：调用前my_data的ID是 {id(my_data)}")
modify_mutable(my_data)
print(f"函数外部：调用后my_data的值是 {my_data}")
print(f"函数外部：调用后my_data的ID是 {id(my_data)}")

在这里，my_data 的 id 在函数调用前后是相同的，而且它的值也被修改了。

但如果函数内部对可变对象参数进行“重新绑定”，那效果就和不可变对象一样了：

def rebind_mutable(my_list):
    print(f"函数内部：原始my_list的ID是 {id(my_list)}")
    my_list = [5, 6, 7]  # 重新绑定，my_list指向了一个新列表对象
    print(f"函数内部：重新绑定后my_list的ID是 {id(my_list)}")
    print(f"函数内部：my_list的值是 {my_list}")

my_data_rebind = [1, 2, 3]
print(f"函数外部：调用前my_data_rebind的ID是 {id(my_data_rebind)}")
rebind_mutable(my_data_rebind)
print(f"函数外部：调用后my_data_rebind的值是 {my_data_rebind}")
print(f"函数外部：调用后my_data_rebind的ID是 {id(my_data_rebind)}")

这里，my_data_rebind 的 id 和值在函数调用后都没有改变，因为函数内部的 my_list 只是被重新绑定到了一个全新的列表对象，并没有影响到外部的 my_data_rebind 所指向的原始对象。

所以，与其纠结于传统的“值传递”和“引用传递”哪个更贴切，不如直接理解Python的“传对象引用”模型，并区分可变对象和不可变对象在函数内部行为上的差异。这能帮你避免很多潜在的bug。

Python参数传递机制：为什么它不是简单的传值或传引用？

从我个人的经验来看，很多人初学Python时都会被这个问题困扰，因为它不像C++那样有指针和引用，也不像Java那样对原始类型和对象类型有明确区分。Python的这种“传对象引用”机制，其实是一种更高级的抽象。

传统意义上的“传值”（pass-by-value）意味着函数接收的是参数值的一个副本。函数对这个副本的任何修改都不会影响到原始值。比如在C语言里，你把一个 int 传给函数，函数内部改了这个 int，外部的变量是不会变的。

而“传引用”（pass-by-reference）则意味着函数接收的是参数的内存地址（或者说，是对原始变量的一个直接引用）。函数内部对这个引用的操作，会直接作用到原始变量上。C++的引用和指针可以实现这种效果。

Python的“传对象引用”介于两者之间，但又有所不同。它传递的是对象引用的一个副本。这个副本和原始引用都指向内存中的同一个对象。

如果这个对象是不可变的，那么你不能“改变”它，只能让引用指向另一个新的对象。当你在函数内部对参数进行赋值操作时，你实际上是让函数内部的局部引用指向了一个新对象，这不影响外部的原始引用。
如果这个对象是可变的，你可以通过这个副本引用直接修改对象的内容（比如往列表里添加元素）。这些修改会影响到外部通过原始引用访问到的对象。

这种设计哲学，我认为体现了Python的“一切皆对象”原则。变量名只是对象的标签，而函数参数则是这些标签的临时副本，同样指向同一个对象。理解这一点，就能拨开迷雾，看清Python参数传递的本质。

可变对象与不可变对象在函数参数传递中的行为差异

正是这种可变性（mutability）的差异，导致了我们经常遇到的“奇怪”行为。对我来说，这不仅仅是语法规则，更是一种编程思维的考量。什么时候我需要一个函数修改传入的数据，什么时候我希望它保持数据的纯洁性？Python的机制直接影响了我的设计选择。

不可变对象：

特性：一旦创建，其值就不能改变。每次“修改”都会创建一个新对象。
传递行为：函数内部对参数的赋值操作，只会重新绑定函数内部的局部变量名，使其指向一个新的对象。外部的原始变量保持不变。这使得处理不可变对象时，你通常不需要担心函数会意外地修改你的原始数据。
例子：int, float, str, tuple, frozenset。
实际应用：当你需要一个函数对数字进行计算，或对字符串进行处理并返回结果时，你通常会返回一个新的值，而不是修改传入的原始值。这符合函数式编程中“纯函数”的理念，即不产生副作用。

可变对象：

特性：创建后，其内容可以被修改。
传递行为：函数内部可以直接通过参数修改对象的内部状态（例如，list.append(), dict.update()）。这些修改会直接反映到函数外部的原始对象上，因为它们共享同一个内存地址。然而，如果函数内部对参数进行重新赋值（param = new_object），则只会重新绑定函数内部的局部变量，不会影响外部。
例子：list, dict, set。
实际应用：这既是便利，也是陷阱。便利在于，你可以通过函数直接更新一个大的数据结构，避免不必要的复制和返回。陷阱在于，如果你不小心，可能会在函数内部对传入的列表或字典进行了不希望的修改，导致难以追踪的bug。比如，一个函数本意是读取配置，结果却不小心改了全局配置字典，那就麻烦了。

我的经验是，当你处理可变对象时，尤其要小心。我常常会问自己：这个函数是应该修改传入的数据，还是应该返回一个修改后的新数据？如果答案是后者，我就会采取一些防御性编程措施。

如何避免或控制函数参数传递带来的意外副作用？

作为一名开发者，我深知这种副作用的潜在危害。调试一个因为函数意外修改了外部数据而产生的bug，往往比编写功能本身要耗时得多。所以，我总结了一些实践方法来应对。

明确函数意图：在设计函数时，首先要明确它的职责。这个函数是用来修改传入数据的（in-place modification），还是仅仅读取数据并返回一个新结果？在函数文档字符串（docstring）中清晰地说明这一点，对团队协作和未来的维护至关重要。

防御性复制可变对象：如果你传入的是一个可变对象，但你不希望函数修改原始数据，那么在函数内部或调用函数时，显式地创建一份副本。

在函数内部复制：

def process_data(data_list):
    local_list = list(data_list)  # 创建列表副本
    # 或者 local_list = data_list[:]
    local_list.append('processed')
    return local_list

my_original_list = ['raw']
new_list = process_data(my_original_list)
print(my_original_list) # ['raw'] - 原始列表未变
print(new_list)        # ['raw', 'processed']

在调用时复制：

def process_data_no_copy_inside(data_list):
    data_list.append('processed') # 直接修改传入的列表
    return data_list

my_original_list = ['raw']
# 传入副本
processed_list = process_data_no_copy_inside(list(my_original_list))
print(my_original_list) # ['raw']
print(processed_list)   # ['raw', 'processed']

选择哪种方式取决于你的设计偏好。如果函数总是需要一个独立的副本，那么在函数内部复制更合理；如果偶尔需要，在调用时复制更灵活。

返回新对象而非就地修改：对于许多操作，尤其是涉及到数据转换或过滤时，我更倾向于让函数返回一个全新的、修改后的对象，而不是直接修改传入的对象。这使得函数更“纯粹”，更容易理解和测试。
```
def filter_even_numbers(numbers):
    return [num for num in numbers if num % 2 == 0]

original_numbers = [1, 2, 3, 4, 5]
even_numbers = filter_even_numbers(original_numbers)
print(original_numbers) # [1, 2, 3, 4, 5] - 原始列表未变
print(even_numbers)    # [2, 4]
```

警惕默认可变参数：这是一个Python新手常踩的坑。在函数定义中，如果使用可变对象作为默认参数，那么这个默认对象只会在函数定义时创建一次，后续每次调用函数且不传入该参数时，都会使用同一个对象。

def add_item(item, item_list=[]): # 错误示范！item_list是可变默认参数
    item_list.append(item)
    return item_list

print(add_item(1)) # [1]
print(add_item(2)) # [1, 2] - 意料之外！
print(add_item(3, [])) # [3] - 传入新列表时正常

正确的做法是使用 None 作为默认值，然后在函数内部检查并创建新的可变对象：

def add_item_correct(item, item_list=None):
    if item_list is None:
        item_list = [] # 每次调用都创建一个新的列表
    item_list.append(item)
    return item_list

print(add_item_correct(1)) # [1]
print(add_item_correct(2)) # [2] - 正常了

类型提示（Type Hinting）：虽然不能直接阻止副作用，但良好的类型提示可以帮助开发者更好地理解函数预期的输入和输出，以及它是否可能修改传入的数据结构。例如，def process(data: list) -> list: 可能会暗示返回一个新列表，而 def update(data: list) -> None: 则可能暗示就地修改。

这些方法并非孤立，而是相互配合，共同构建健壮、可维护的代码。在Python的世界里，理解“传对象引用”的细微之处，是迈向高级编程的重要一步。

以上就是《Python传参方式详解：值传递与引用传递》的详细内容，更多关于Python,参数传递,不可变对象,可变对象,传对象引用的资料请关注golang学习网公众号！

Python 参数传递不可变对象可变对象传对象引用