**Python 的参数怎么传递？核心结论是：Python 采用“对象引用传递”（call by object reference）机制，函数接收的是对象的引用副本，而不是对象本身的拷贝。** 这意味着在函数内部是否会影响外部变量，取决于对象是否可变，以及是否在函数中重新绑定变量名。理解这一点，是掌握 Python 参数传递机制、函数调用逻辑与内存模型的关键。本文将系统解析 Python 参数传递方式、可变与不可变对象的影响、默认参数陷阱、关键字参数与可变参数机制，并结合真实示例深入讲解。

## 一、Python 参数传递的本质机制

在讨论“Python 的参数怎么传递”之前，必须明确一个核心概念：**Python 既不是传统意义上的“值传递”，也不是“引用传递”，而是“对象引用传递”**。在函数调用时，实参对象的引用会被复制一份传入函数内部，函数中的形参只是指向同一个对象的新的变量名。

根据 Python 官方文档《Python Language Reference》（Python Software Foundation, 2023），函数调用时实参与形参之间通过对象引用绑定，而不是对象复制。这意味着函数内部与外部变量可以指向同一对象，但变量名本身是独立的。

举例说明：

```python
def modify(x):
    x.append(4)

a = [1, 2, 3]
modify(a)
print(a)
```

输出结果为：

```
[1, 2, 3, 4]
```

这是因为列表是可变对象，函数内部通过引用修改了原始对象。**理解“变量名是标签，对象才是真实数据”这一模型，是理解 Python 参数传递方式的关键。**

## 二、可变对象与不可变对象的区别

Python 参数传递行为是否“影响外部变量”，核心在于对象是否可变。Python 中常见对象类型可分为可变对象与不可变对象两类。

下表列出常见类型的可变性对比：

| 类型 | 是否可变 | 示例 | 函数中修改是否影响外部 |
|------|----------|------|------------------------|
| int | 不可变 | 10 | 否 |
| float | 不可变 | 3.14 | 否 |
| str | 不可变 | "abc" | 否 |
| tuple | 不可变 | (1,2) | 否 |
| list | 可变 | [1,2] | 是 |
| dict | 可变 | {"a":1} | 是 |
| set | 可变 | {1,2} | 是 |

例如：

```python
def change(x):
    x = x + 1

a = 10
change(a)
print(a)
```

输出仍为 10。因为整数是不可变对象，`x = x + 1` 实际上是创建了一个新对象并重新绑定变量。

而对于可变对象：

```python
def change(lst):
    lst.append(4)

a = [1,2,3]
change(a)
print(a)
```

输出为 `[1,2,3,4]`，因为列表是可变对象。

**因此，Python 参数传递的关键不是“传值还是传引用”，而是“对象是否可变”。**

## 三、函数内部重新绑定变量的影响

很多初学者误以为函数内部对参数重新赋值会改变外部变量，但事实并非如此。

```python
def change(lst):
    lst = [4,5,6]

a = [1,2,3]
change(a)
print(a)
```

输出仍为 `[1,2,3]`。

原因是：**在函数内部执行 `lst = [4,5,6]` 时，只是让形参指向了新对象，并没有改变原始对象。**

我们可以用 id() 函数观察对象地址：

```python
def change(x):
    print(id(x))
    x = 20
    print(id(x))

a = 10
print(id(a))
change(a)
```

你会发现函数内外 id 变化说明重新绑定发生。

**总结：修改对象内容会影响外部；重新绑定变量名不会影响外部。**

## 四、默认参数的常见陷阱

在讨论 Python 参数传递机制时，默认参数是一个经典陷阱。Python 的默认参数在函数定义时计算，而不是在调用时计算。

例如：

```python
def add_item(item, lst=[]):
    lst.append(item)
    return lst

print(add_item(1))
print(add_item(2))
```

输出结果为：

```
[1]
[1,2]
```

这是因为默认参数 `lst=[]` 只创建一次，之后调用共享同一个列表对象。

根据《Fluent Python》（Luciano Ramalho, O’Reilly, 2015）中的解释，默认参数在函数对象创建时就绑定到对象上。

正确写法：

```python
def add_item(item, lst=None):
    if lst is None:
        lst = []
    lst.append(item)
    return lst
```

**理解默认参数的执行时机，是掌握 Python 函数参数机制的重要环节。**

## 五、位置参数与关键字参数

在 Python 参数传递方式中，参数的声明形式同样重要。Python 支持位置参数与关键字参数两种基本形式。

示例：

```python
def greet(name, age):
    print(name, age)

greet("Tom", 18)
greet(age=18, name="Tom")
```

位置参数按照顺序匹配；关键字参数根据名称匹配。

对比如下：

| 参数类型 | 传递方式 | 是否依赖顺序 | 可读性 |
|----------|----------|--------------|--------|
| 位置参数 | 按顺序 | 是 | 一般 |
| 关键字参数 | 按名称 | 否 | 高 |

**在复杂函数调用中，关键字参数可以显著提升代码可读性与维护性。**

## 六、可变参数 *args 与 **kwargs

Python 还支持可变数量参数，这是其函数参数传递机制的高级特性。

示例：

```python
def func(*args):
    print(args)

func(1,2,3)
```

输出为 `(1,2,3)`。

而：

```python
def func(**kwargs):
    print(kwargs)

func(a=1,b=2)
```

输出为 `{'a':1,'b':2}`。

对比说明：

| 语法 | 类型 | 接收形式 |
|------|------|----------|
| *args | 元组 | 位置参数 |
| **kwargs | 字典 | 关键字参数 |

**在框架开发与接口封装中，*args 与 **kwargs 是实现灵活参数传递的核心机制。**

## 七、参数解包与高级用法

Python 支持在函数调用时进行参数解包。

```python
lst = [1,2,3]
func(*lst)

d = {"a":1,"b":2}
func(**d)
```

这种参数传递方式在数据处理、配置管理和接口调用中非常常见。

同时，Python 3 引入了“仅限关键字参数”：

```python
def func(a, *, b):
    pass
```

这意味着 b 必须通过关键字传递。

这种设计增强了 API 的明确性和安全性，是 Python 参数设计进化的重要体现。

## 八、参数传递与内存模型的关系

Python 的参数传递机制与其内存模型密切相关。Python 采用引用计数为主的垃圾回收机制（Python 官方文档，Memory Management, 2023）。

当函数被调用时：

1. 创建新的局部命名空间
2. 形参与对象引用绑定
3. 函数结束后释放局部变量引用

这说明函数调用本质是命名空间的创建与销毁，而非数据复制。

理解这一点可以帮助优化性能。例如，大型列表或字典传递给函数时不会发生复制，性能开销很小。

## 九、总结与未来趋势

综合来看，**Python 的参数传递本质是对象引用传递机制，是否影响外部变量取决于对象是否可变以及是否重新绑定变量名。** 位置参数、关键字参数、默认参数、可变参数与解包机制共同构成了完整的 Python 函数参数体系。

在未来版本中，Python 在函数参数设计上将更强调类型提示与静态分析支持，例如 PEP 484 类型注解已成为主流实践。这意味着参数传递不仅仅是运行时行为，更逐渐成为静态类型工具优化的重要基础。

掌握 Python 参数传递机制，不仅能避免常见错误，还能在框架开发、接口设计与性能优化中发挥关键作用。理解对象模型，是写出高质量 Python 代码的核心前提。

参考与资料来源  
Python Software Foundation. Python Language Reference, 2023.  
Luciano Ramalho. Fluent Python. O’Reilly Media, 2015.

Python 函数参数主要通过传值和传引用的组合方式实现。对于不可变对象，如整数、字符串，传递的是对象的值；而对于可变对象，如列表、字典，传递的是引用，因此在函数内部修改可变对象会影响到外部。

Python 函数参数的传递方式

我想了解 Python 函数中的参数是如何被传递的，有哪些不同的传递方式？

Python 中函数参数有哪些传递方式？

在定义函数时，可以为参数指定默认值，例如 def func(a, b=10):。调用 func(5) 只传一个参数时，b 会自动使用默认的 10。默认参数应该放在参数列表的末尾，避免调用时产生歧义。

设置 Python 函数的默认参数

我想给 Python 函数的某些参数设置默认值，使得调用时可以省略这些参数，应该怎么做？

如何给 Python 函数传递默认参数？

定义函数时，可以使用 *args 来接收任意数量的位置参数，使用 **kwargs 来接收任意数量的关键字参数。例如 def func(*args, **kwargs):，这样就能灵活处理不同数量和类型的传入参数。

使用 *args 和 **kwargs 传递可变数量参数

我想创建一个函数，可以接受不定数量的位置参数或关键字参数，Python 怎么实现？

Python 中如何传递可变数量的参数？

PingCodeDocs

Python 的参数传递采用对象引用传递机制，函数接收的是对象引用的副本，而非值拷贝。是否影响外部变量取决于对象是否可变以及函数内是否重新绑定变量名。可变对象在函数中被修改会影响外部，不可变对象则不会。默认参数在定义时计算，可能带来共享陷阱。位置参数、关键字参数、可变参数与参数解包共同构成完整参数体系。理解对象模型和命名空间机制，是掌握函数调用原理与避免常见错误的关键。

python 的参数怎么传递

用户关注问题