在Python编程中，函数参数的传递机制是初学者最容易混淆的知识点之一。很多刚入门的朋友都会问：“Python是值传递还是引用传递？”、“为什么传进去的列表变了，外面也跟着变？”、“而整数却不会？”

本文将从底层原理、实际行为和代码示例三个方面，深入剖析 Python函数参数的传递机制，帮助你彻底理解：

• 值传递（Pass by Value）
• 引用传递（Pass by Reference）
• Python中的真实情况：对象引用传递（Pass by Object Reference）

并通过大量实战案例讲解其使用方法与适用场景。

一、什么是参数传递？

函数调用时，我们通常会把数据通过参数传入函数内部进行处理。这个过程就叫做“参数传递”。

常见语言的参数传递方式：

注意：

• “值传递”和“引用传递”是理论上的概念。
• Python并不严格属于其中任何一种，而是采用了一种独特的机制——对象引用传递（Pass by Object Reference）。

二、Python函数参数传递的本质：对象引用传递

在Python中，一切皆对象，变量只是指向某个对象的标签。因此，函数参数的传递本质上是将对象的引用复制给函数内的形参。

我们可以这样理解：

• 如果你传的是一个不可变对象（如整数、字符串、元组），函数内修改不会影响外部。
• 如果你传的是一个可变对象（如列表、字典、集合），函数内修改会影响外部。

示例1：不可变对象的参数传递

def change(x):
    x += 100
    print("函数内x =", x)

a = 5
change(a)
print("函数外a =", a)

输出：

函数内x = 105
函数外a = 5

分析：

• a 是一个整数（不可变对象），它被赋值给 x。
• x += 100 创建了一个新的整数对象 105，原对象 5 没有变化。

示例2：可变对象的参数传递

def modify(lst):
    lst.append(100)
    print("函数内lst =", lst)

my_list = [1, 2, 3]
modify(my_list)
print("函数外my_list =", my_list)

输出：

函数内lst = [1, 2, 3, 100]
函数外my_list = [1, 2, 3, 100]

分析：

• my_list 是一个列表（可变对象），它被赋值给 lst。
• lst.append(100) 修改了同一个对象，所以外部也能看到变化。

三、Python参数传递的分类说明

四、参数传递的实际行为分析

1. 整数、字符串、布尔值等不可变类型

这些类型的对象一旦创建就不能改变，函数内部对它们的操作不会影响外部。

def update_name(name):
    name = "Tom"
    print("函数内name =", name)

user = "Alice"
update_name(user)
print("函数外user =", user)

输出：

函数内name = Tom
函数外user = Alice

2. 列表、字典、集合等可变类型

这些对象可以在函数内部被修改，并且这种修改会反映到外部。

def add_item(d):
    d["new_key"] = "new_value"

data = {"a": 1}
add_item(data)
print(data)  
# 输出：{'a': 1, 'new_key': 'new_value'}

3. 元组虽然是不可变类型，但嵌套可变对象时仍可能被“间接修改”

虽然元组本身不能被修改，但如果元组中包含可变对象（如列表），该对象是可以被修改的。

示例：

def modify_tuple(t):
    t[0].append(100)
    print("函数内t =", t)

tpl = ([1, 2], 3)
modify_tuple(tpl)
print("函数外tpl =", tpl)

输出：

函数内t = ([1, 2, 100], 3)
函数外tpl = ([1, 2, 100], 3)

五、函数参数传递的常见误区

误区1：认为Python是“引用传递”

很多人误以为Python是像C++一样的“引用传递”，其实不然。Python是对象引用传递，即传递的是对象的引用值（内存地址的副本），而不是真正的指针。

误区2：认为所有变量都是引用

变量名只是一个标签，不是真正的引用。例如：

a = [1, 2, 3]
b = a
a = [4, 5, 6]  
# 这里 a 被重新赋值，指向新对象
print(b)       
# 输出 [1, 2, 3]，说明 b 仍然指向旧对象

六、如何避免函数内部修改外部数据？

如果你希望函数不改变外部传入的数据，可以手动复制一份对象再操作。

方法1：使用切片复制列表

def safe_modify(lst):
    new_lst = lst[:]
    new_lst.append(100)
    print("函数内new_lst =", new_lst)

original = [1, 2, 3]
safe_modify(original)
print("函数外original =", original)

输出：

函数内new_lst = [1, 2, 3, 100]
函数外original = [1, 2, 3]

方法2：使用copy模块深拷贝复杂结构

import copy

def deep_modify(d):
    copied = copy.deepcopy(d)
    copied["new"] = "value"
    print("函数内copied =", copied)

data = {"a": 1}
deep_modify(data)
print("函数外data =", data)

七、参数传递的实际应用场景

场景1：数据统计函数（无需修改原始数据）

def calculate_stats(numbers):
    total = sum(numbers)
    average = total / len(numbers)
    return {"total": total, "average": average}

scores = [85, 90, 78]
result = calculate_stats(scores)
print(result)

特点：只读取数据，不修改原数据，安全可靠。

场景2：配置更新函数（需修改原始数据）

def update_config(config, key, value):
    config[key] = value

settings = {"theme": "light"}
update_config(settings, "theme", "dark")
print(settings)  # 输出 {'theme': 'dark'}

特点：直接修改外部数据，适用于状态同步、配置管理等场景。

场景3：日志记录器（接收任意数量的关键字参数）

def log_event(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

log_event(user="admin", action="login", 
          timestamp="2025-06-03T10:00:00")

特点：灵活接收参数，适用于通用工具函数、日志系统等。

八、注意事项与最佳实践

九、总结

Python函数的参数传递机制既不是纯粹的“值传递”，也不是“引用传递”，而是一种独特的机制——对象引用传递。

关键结论如下：

• 不可变对象（如整数、字符串）在函数内部修改不会影响外部。
• 可变对象（如列表、字典）在函数内部修改会影响外部。
• Python参数传递的本质是将对象的引用复制给形参。
• 理解对象的可变性与不可变性是掌握参数传递的关键。

作为Python初学者，建议你在练习中多动手写代码，尝试不同类型的参数传递方式，理解它们的行为差异。随着学习的深入，你会发现参数传递机制在实际开发中的强大作用。

希望本文能帮助你全面掌握Python函数参数的传递机制，并在今后的编程实践中灵活运用！