Python参数传递机制详解：传值、传址与对象引用

云舒

发布时间：2026-10-13 | 6人浏览过

原创

本文深入解析Python中的参数传递机制，澄清传值与传址的概念。Python采用“传对象引用”策略，根据参数是可变（如列表、字典）还是不可变（如数字、元组）对象，表现出类似传址或传值的行为。文章通过id函数、copy与deepcopy示例，详细演示内存地址变化及拷贝深度差异，帮助开发者准确理解变量引用与内存分配逻辑。

1. 传值与传址的区别

传值是指将参数的具体数值副本传入函数，而传址则是将参数在内存中的地址（即指针）传入。两者的核心区别在于：若函数内部对传入参数重新赋值，函数外部的全局变量是否随之改变。采用传值方式时，函数外部的变量保持不变；采用传址方式时，函数外部的变量会相应发生变化。

def a(n):
  n[2] = 100
  print(n)
  return None
def b(n):
  n += 100
  print(n)
  return None
an = [1,2,3,4,5]
bn = 10
print(an)
a(an)
print(an)
print(bn)
b(bn)
print(bn)
[1, 2, 3, 4, 5]
[1, 2, 100, 4, 5]
[1, 2, 100, 4, 5]
10
110
10

以上述代码为例，an是一个列表（list），将其作为实参传入函数a中，函数a对其第三个元素进行了修改。当函数a执行结束后再次打印an，发现其中的元素确实发生了变化，这体现了传址操作的特征。bn代表一个整数，将其传入函数b并进行修改，函数b执行结束后再次打印bn，发现其值未变，这体现了传值操作的特征。

2. Python中传值与传址的规律

Python不允许程序员显式选择采用传值还是传址。Python参数传递采用的是“传对象引用”（Pass Object Reference）的方式，实际上，这种方式相当于传值和传址的一种综合体现。

如果函数接收到的是一个可变对象（例如字典或列表）的引用，就能修改该对象的原始值——这相当于传址。如果函数接收到的是一个不可变对象（例如数字、字符串或元组）的引用，就不能直接修改原始对象——这相当于传值。因此，Python中传值和传址的行为取决于传入参数的类型。

传值的参数类型包括：数字、字符串、元组。

传址的参数类型包括：列表、字典。

3. 内置函数id

内置函数id用于显示变量或数据在内存中的地址，有时可用于检测所使用的对象是否为同一个，从而帮助区分传值与传址操作。

但是id在有些情况下比较特殊，注意下面的例子。

a = 100
b = 200 
print(id(a))
print(id(b))
c = a
print(id(c))
print(a is c)
a += 300
print(a)
print(c)
print(a is c)
print(id(a))
print(id(c))
1549495552
1549498752
1549495552
True
400
100
False
93638128
1549495552

为了提高内存利用效率，对于一些简单的对象，如一些数值较小的int对象，Python采取重用对象内存的办法。例如指向a=100，c=100时，由于100作为简单的int类型且数值小，Python不会两次为其分配内存，而是只分配一次，然后将a与c同时指向已分配的对象。但是当a的值发生变化时，会单独为a重新分配一个新的内存。

4. list传值与传址

List类型使用简单的赋值操作，表现为传址。

a = [1,2,3,4,5]
b = a
print(a)
b[2] = 333
print(a)
print(b)
print(id(a))
print(id(b))
[1, 2, 3, 4, 5]
[1, 2, 333, 4, 5]
[1, 2, 333, 4, 5]
96142472
96142472

copy函数是浅拷贝，表现为传值。在Python 2中，需要import copy模块，在Python 3中可直接使用。

a = [1,2,3,4,5]
b = a.copy()
print(a)
b[2] = 333
print(a)
print(b)
print(id(a))
print(id(b))
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]
[1, 2, 333, 4, 5]
92990536
96202632

由于copy是浅拷贝，只拷贝一层的内容，当遇到下列情况时，copy不能实现完全的传值操作。

a = [1,2,3,[10,20,30]]
b = a.copy()
print(id(a))
print(id(b))
print(id(a[3]))
print(id(b[3]))
a[3][2] = 666
print(a)
print(b)
96141704
93355400
96141768
96141768
[1, 2, 3, [10, 20, 666]]
[1, 2, 3, [10, 20, 666]]

要解决这个问题，需要使用deepcopy。在Python 3中，直接可以使用copy（）方法，但deepcopy（）还是需要导入copy模块。

import copy
a = [1,2,3,[10,20,30]]
b = copy.deepcopy(a)
print(id(a))
print(id(b))
print(id(a[3]))
print(id(b[3]))
a[3][2] = 666
print(a)
print(b)
96503944
93002376
96886024
93352712
[1, 2, 3, [10, 20, 666]]
[1, 2, 3, [10, 20, 30]]

5. tuple操作

Tuple元组是不可修改的，指的是其元组内容不可更改。

t1 = (1,2,3)
t1[1] = 100
---------------------------------------------------------------------------
TypeError                 Traceback (most recent call last)
<ipython-input-19-9caf76a526a9> in <module>()
   1 t1 = (1,2,3)
----> 2 t1[1] = 100
TypeError: 'tuple' object does not support item assignment

但是其所指向的内存地址是可变的。

t1 = (1,2,3)
t2 = (5,6,7)
print(id(t1))
t1 += t2
print(t1)
print(id(t1))
print(id(t2))
t2 *= 3
print(t2)
print(id(t2))
96151520
(1, 2, 3, 5, 6, 7)
93048552
94080672
(5, 6, 7, 5, 6, 7, 5, 6, 7)
93656912

并不是起初的t1和t2所指向的元组内容发生了变化，而是新分配了两个元组内存，t1和t2所指向的内存地址发生改变。

总结