python如何复制内存数据 python 内存拷贝函数

简述

在使用Python语言，通常都会面临对象赋值、参数传递的使用，为了更深入理解它们的底层原理。Python也像其他语言如Java一样引入了浅考本和深拷贝的概念。

首先我们要明确一下：变量存储在栈内存，对象存储在堆内存。

Python数据类型分为可变数据类型和不可变数据类型。

• 可变数据类型包括：List（列表）、Dictionary（字典）、Set（集合）
• 不可变数据类型包括：String（字符串）、Number（数字）、Tuple（元组）

• 浅拷贝：

• （1）不拷贝子对象的内容，只拷贝子对象的引用
• （2）可以使用Python内置函数copy()

• 深拷贝：

• （1）会连子对象的内存全部拷贝一份，对子对象的修改不会影响源对象
• （2）可以使用Python内置函数deepcopy()

本次内容大纲如下：

1.浅拷贝

浅拷贝只对源对象的引用进行拷贝，对象的内容不进行操作，详情请阅读后面的内容。

1.1 单层浅拷贝原理

• 对于源对象是可变数据类型，在堆内存中创建新空间
• 对于源对象是不可变数据类型，则拷贝其引用

1.1.1 源对象是可变数据类型

# 单层浅拷贝-源对象是可变数据类型
import copy
a = [1,2]
c = copy.copy(a)

print(id(a),id(c))  # 地址不相同

4378970048 4378968448

 

所以对于源对象是可变数据类型，在堆内存中创建新空间

1.1.2 源对象是不可变数据类型

# 单层浅拷贝-源对象是不可变数据类型
import copy
a = 1
b = (1, 2)
c = copy.copy(a)
d = copy.copy(b)

print(id(a),id(c)) # 地址相同
print(id(b),id(d)) # 地址相同

4334741024 4334741024
4338220672 4338220672

 

1.2 嵌套浅拷贝原理

• 对于源对象是可变数据类型，

• （1）在堆内存中创建新空间
• （2）与源对象里元素同时指向同一地址

• 对于源对象是不可变数据类型，则拷贝其引用

1.2.1 源对象是可变数据类型

# 嵌套浅拷贝原理-源对象是可变数据类型
a = [(1,2),[3,4]]

c = copy.copy(a)

print(id(a),id(c)) # 地址不相同

print(id(a[0]),id(c[0])) # 嵌套元组地址是一样的

print(id(a[1]),id(c[1])) # 嵌套列表地址是一样的

4385812736 4385904064
4383866432 4383866432
4385814336 4385814336

 

1.2.2 源对象是不可变数据类型

# 嵌套浅拷贝原理-源对象是不可变数据类型
a = ((1, 2), [3, 4])

c = copy.copy(a)

print(id(a), id(c)) # 地址相同

print(id(a[0]), id(c[0])) # 嵌套元组地址是一样的

print(id(a[1]), id(c[1])) # 嵌套列表地址是一样的

4344786560 4344786560
4343430784 4343430784
4345395264 4345395264

2.深拷贝

2.1 单层深拷贝原理

单层深拷贝：

• 对于源对象是可变数据类型，在堆内存中创建内存空间
• 对于源对象是不可变数据类型，拷贝引用地址

2.1.1 源对象是可变数据类型

# 单层深拷贝-源对象是可变数据类型

a = [1, 2]

c = copy.deepcopy(a)

print(id(a), id(c))  # 地址不相同

4386003008 4386001472

 

2.1.2 源对象是不可变数据类型

# 单层深拷贝-源对象是不可变数据类型

a = 1
b = (1, 2, 3)
c = copy.deepcopy(a)
d = copy.deepcopy(b)
print(id(a), id(c))  # 地址相同
print(id(b), id(d))  # 地址相同

4368295456 4368295456

2.2 嵌套深拷贝原理

嵌套深拷贝：

• 对于源对象是可变数据类型

• （1）在堆内存中创建内存空间
• （2）如果源对象里的元素是不可变数据类型，则直接拷贝其引用地址
• （3）如果源对象里的元素是可变数据类型，则进行递归创建新空间

• 对于源对象是不可变数据类型

• （1）如果源对象里的元素是不可变数据类型，则直接拷贝其引用地址
• （2）如果源对象里的元素是可变数据类型，则递归创建新空间

2.2.1 源对象是可变数据类型

# 嵌套深拷贝原理-源对象是可变数据类型
a = [(1, 2), [3, 4]]

c = copy.deepcopy(a)

print(id(a), id(c)) # 地址不相同

print(id(a[0]), id(c[0])) # 嵌套元组地址是一样的

print(id(a[1]), id(c[1])) # 嵌套列表地址是不一样的

4339122816 4339209984
4337221184 4337221184
4339124352 4339209344

2.2.2 源对象是不可变数据类型

# 嵌套深拷贝原理-源对象是不可变数据类型
a = ((1, 2), (3, 4))

c = copy.deepcopy(a)

print(id(a), id(c))  # 地址相同

print(id(a[0]), id(c[0]))  # 嵌套元组地址是一样的

print(id(a[1]), id(c[1]))  # 嵌套列表地址是一样的

4304431872 4304431872
4303879808 4303879808
4304432576 4304432576

3.赋值和浅拷贝与深拷贝的区别

赋值：

• 当旧变量赋值给新变量，其实这个过程都是栈内存发生的。
• 两个变量都指向栈内存中同一个对象的存储空间。
• 当任何一个变量发生变化，都是指向堆内存对象地址的变化，两个变量是同步的。

# 赋值和浅拷贝与深拷贝的区别
a = 1
b = a
print(id(a), id(b))

4303791648 4303791648

• 1）在堆内存中重新创建空间
• （2）只拷贝源对象顶层的内存空间
• （3）与源对象里的元素指向同一地址
• （4）对于新或源对象内部元素变化时，会相互影响

• 对于源对象是不可变数据类型，则拷贝其引用

深拷贝：

• 对于源对象是可变数据类型

• （1）在堆内存中重新创建空间
• （2）做递归拷贝其可变元素
• （3）对于新或源对象内部元素变化时，不会相互影响

• 对于源对象是不可变数据类型，则会递归判断元素数据类型，如果可变则创建新的地址，不变则拷贝引用

4.总结

浅拷贝与深拷贝，其实就是对源对象的复制。

如果源对象只有单层的话，源做任何改动，都不影响深浅拷贝的对象

如果源对象嵌套可变数据类型，源做任何改动，只会影响浅拷贝，不会影响深拷贝