Python对象传递机制与Copy模块详解：深拷贝与浅拷贝的区别

栗子

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

原创

本文深入解析Python中的对象传递机制，阐明赋值操作实为引用拷贝。通过对比数字、字符串等不可变类型与列表、字典等可变类型的内存ID变化，揭示变量赋值的底层逻辑。重点讲解copy模块中浅拷贝与深拷贝的区别：浅拷贝仅复制顶层对象，子对象仍共享引用；深拷贝则递归复制所有层级，实现完全独立。掌握这些概念有助于避免数据意外修改，提升代码安全性。

Python对象传递机制概述

1、对象引用的传值或者传引用

在Python中，变量赋值本质上是建立对象引用的过程。当将一个对象赋值给另一个变量时，Python并不会创建该对象的副本，而是复制其引用地址。这种机制结合了值传递与引用传递的特点：若函数接收的是可变对象（如字典或列表）的引用，则可以通过该引用修改原始对象，表现为“引用传递”的效果；若接收的是不可变变量（如整数、字符串或元组）的引用，则无法直接修改原始对象，表现为“值传递”的效果。

不可变对象的传递行为

先看一个数字传递的例子：


>>> def test(a):
...     print id(a)
...     a = a + 1
...     print id(a)
...     return a
...
>>> b =19
>>> id(b)
38896272
>>> c = test(b)
38896272
38896260
>>> id(b)
38896272
>>> b
19

id函数可以获得对象的内存地址.

从上述示例可以看出，将变量b作为参数传递给test函数时，传递的是b的引用，即b的内存地址。因此，在函数内部获取的变量a的地址与变量b的地址相同。然而，在函数内部对a执行赋值运算（a = a + 1）后，a的值从19变为20。此时，19和20在内存中均存在，赋值操作使a指向了存储20的新内存区域，而b仍指向存储19的原始内存区域。因此，后续打印b时，其值仍为19。

另外，关于整数变量的id，所有在[-5,256]范围内的整数，python是提前分配好空间放在数组里初始化好的，所以两个变量如果是相同的小整数，对象都是最开始初始化的那一个，所以两个变量的id是一样的。

所有在[-5,256]范围外的整数的话，每次都会新建一个的，所以id会改变


>>> a = 256
>>> id(a)
43340980
>>> b = 256
>>> id(b)
43340980   # a和b的id相同
>>> a = 257
>>> id(a)
44621040
>>> b = 257
>>> id(b)
44620908   # a和b的id不同
>>> a = -5
>>> id(a)
43338160
>>> b = -5
>>> id(b)
43338160
>>> a = -6
>>> id(a)
44621184
>>> b = -6
>>> id(b)
44621112

可变对象的传递行为

再看一个列表传递的例子：


>>> def test(a):
...   print id(a)
...   a[0] = 100
...   print id(a)
...   return a
...
>>> b = [7,8,9,10]
>>> id(b)
46408088
>>> c = test(b)
46408088
46408088
>>> id(b)
46408088
>>> b
[100, 8, 9, 10]

从上述示例可以看出，将变量b作为参数传递给test函数时，传递的是b的引用，即b的内存地址。因此，在函数内部获取的变量a的地址与变量b的地址相同。但在函数内部对a执行赋值运算（a[0] = 100）时，a的id并未发生变化，仍与变量b的地址一致。因此，后续打印b时，b[0]的值也从7变为100，体现了可变对象在函数调用中的引用传递特性。

可变与不可变变量的区别

2、关于可变变量和不可变变量：

这里的可变不可变，是指内存中的那块内容（value）是否可以被改变

不可变变量：

number: int, float, str, 元组。--指它的部分（比如element,attribute不能改变）不能改变；并不是整体不可变。另外，Python所有变量皆对象。int也是一个对象。


>>> a = 10000
>>> id(a)
46573412
>>> a = 10000000
>>> id(a)
46573460   #数字变量重新赋值后，id发生了变化
>>> s = 'abc'
>>> s[1] = d   #字符串变量中的某一个元素不能进行改变
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>> id(s)
39103328
>>> s = 'ttt'
>>> id(s)    #字符串变量进行重新赋值后，id发生了变化
46425368

从上面的例子中可以看出，数字变量、字符变量在重新赋值后，id都会发生变化，这是因为不可变变量的赋值是通过在内存中新申请一块区域，把新的值存储到该区域，然后改变不可变变量的引用，指向新的内存区域，从而改变了不可变变量的值。

可变变量

class, class instance;列表，dict,

例1.可变变量中元素的赋值


>>> list = [1,2,3]
>>> id(list)
45486568
>>> for i in list:
...   print id(i)
40207208
40207196
40207184
>>> list[0] = 0
>>> id(list)
45486568   # 变量的id并没有发生改变
>>> for i in list:
...   print id(i)
40207220    # 该元素的id发生了改变
40207196
40207184
例2.可变变量的赋值
>>> list = [1,2,3]
>>> id(list)
43783392
>>> list =[2,3,5] 
>>> id(list)  # 该变量的id发生了改变
44454296

从上面的例子可以看出，列表中的元素重新赋值，整个列表的id不会发生改变，但是该元素的id会发生该生。因为列表中存储的其实是对各个元素的引用，所以对该元素赋值的结果就是元素的引用发生了改变。

总之，无论是可变变量还是不可变变量，只要对整个变量进行赋值，Python都在内存中新申请一块区域，把新的值存储到该区域，然后改变不可变变量的引用，指向新的内存区域；如果可变变量中的元素进行赋值，支队导致该元素的变化，不会导致父对象的变化。

深拷贝与浅拷贝原理

3、深拷贝 Vs 浅拷贝

copy.copy() 浅拷贝

copy.deepcopy() 深拷贝

浅拷贝是新创建了一个跟原对象一样的类型，但是其内容是对原对象元素的引用。这个拷贝的对象本身是新的，但内容不是。如果原对象的元素包含不是基本数据结构，而是list、dict或者对象的话，那么原对象或者拷贝对象改变list、dict或者对象里面的内容的话，会导致二者同时发生改变。

深拷贝则是对原对象的完全拷贝，包含对象里面的子对象的拷贝，因此拷贝对象和原对象二者是完全独立，任何一方的改变对另外一方都不会产生任何的影响。


>>> import copy
>>> list = [1, 2, [3, 4]]
>>> copy_list = copy.copy(list)
>>> deepcopy_list = copy.deepcopy(list)
>>>
>>> id(list)
44454296
>>> id(copy_list)
44515736
>>> id(deepcopy_list)
44455736
>>>
>>> for k in list:
...   print id(k)
43338088 43338076 44430120
>>> for k in copy_list:
...   print id(k)
43338088 43338076 44430120  # copy对象的内容和原对象完全一样
>>> for k in deepcopy_list:
...   print id(k)
43338088 43338076 44457456  # deepcopy对象的内容和原对象有区别:列表元素的id不一样；数字元素id一样,原因是所有相同数字的变量的引用都是一样的。
>>> 
>>> list[2][0] = 30
>>> list
[1, 2, [30, 4]]
>>> copy_list
[1, 2, [30, 4]]   # 原对象的子对象中的元素发生改变后，会导致copy对象发生同样的改变  
>>> deepcopy_list
[1, 2, [3, 4]]    #原对象的子对象中的元素发生改变后，不会导致deepcopy对象发生同样的改变

以上这篇Python的对象传递与Copy函数使用详解就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持本站。