python standard library copy

python 标准库 copy

源码

源代码: Lib/copy.py

类层次结构

1
2
3
4
Interface summary:
import copy
x = copy.copy(y) # make a shallow copy of y
x = copy.deepcopy(y) # make a deep copy of y

Python 中赋值语句不复制对象,而是在目标和对象之间创建绑定 (bindings) 关系。对于自身可变或者包含可变项的集合对象,开发者有时会需要生成其副本用于改变操作,进而避免改变原对象。本模块提供了通用的浅层复制和深层复制操作(如下所述)。

接口摘要:

  • copy.copy(x)

    返回 x 的浅层复制。

  • copy.deepcopy(x[, memo])

    返回 x 的深层复制。

  • exception copy.error

    针对模块特定错误引发。

浅层复制和深层复制之间的区别仅与复合对象 (即包含其他对象的对象,如列表或类的实例) 相关:

  • 一个 浅层复制 会构造一个新的复合对象,然后(在可能的范围内)将原对象中找到的 引用 插入其中。
  • 一个 深层复制 会构造一个新的复合对象,然后递归地将原始对象中所找到的对象的 副本 插入。

深度复制操作通常存在两个问题, 而浅层复制操作并不存在这些问题:

  • 递归对象 (直接或间接包含对自身引用的复合对象) 可能会导致递归循环。
  • 由于深层复制会复制所有内容,因此可能会过多复制(例如本应该在副本之间共享的数据)。

The deepcopy() function avoids these problems by:

  • 保留在当前复制过程中已复制的对象的 “备忘录” (memo) 字典;以及
  • 允许用户定义的类重载复制操作或复制的组件集合。

该模块不复制模块、方法、栈追踪(stack trace)、栈帧(stack frame)、文件、套接字、窗口、数组以及任何类似的类型。它通过不改变地返回原始对象来(浅层或深层地)“复制”函数和类;这与 pickle 模块处理这类问题的方式是相似的。

制作字典的浅层复制可以使用 dict.copy() 方法,而制作列表的浅层复制可以通过赋值整个列表的切片完成,例如,copied_list = original_list[:]

类可以使用与控制序列化(pickling)操作相同的接口来控制复制操作,关于这些方法的描述信息请参考 pickle 模块。实际上,copy 模块使用的正是从 copyreg 模块中注册的 pickle 函数。

想要给一个类定义它自己的拷贝操作实现,可以通过定义特殊方法 __copy__()__deepcopy__()。 调用前者以实现浅层拷贝操作,该方法不用传入额外参数。 调用后者以实现深层拷贝操作;它应传入一个参数即 memo 字典。 如果 __deepcopy__() 实现需要创建一个组件的深层拷贝,它应当调用 deepcopy() 函数并以该组件作为第一个参数,而将 memo 字典作为第二个参数。

实例

字典拷贝

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
import copy


def displayList(text, dictOfElements) :
print("--------")
print(text)
for key , value in dictOfElements.items():
print(key, " :: ", value)

def main():

# Dictionary of strings and ints
wordsDict = {
"Hello": 56,
"at" : 23 ,
"test" : 43,
"this" : 43,
"who" : [56, 34, 44]
}

'''
Shallow Copying dictionaries using dict.copy()
'''
print("***** Shallow Copy *********")

displayList("Original Dictionary : " , wordsDict)

# create a Shallow copy the original dictionary
newDict = wordsDict.copy()

# Modify the value of key in new dictionary
newDict["at"] = 200

print("Contents of copied dictionary changed")

displayList("Modified copied dictionary : " , newDict)

displayList("Original Dictionary : " , wordsDict)

'''
Modify the contents of list object in shallow copied dictionary will
modify the contents of original dictionary too because its a shallow copy.
'''
newDict["who"].append(222)

print("Contents of list in copied dictionary changed")

displayList("Modified copied dictionary : " , newDict)

displayList("Original Dictionary : " , wordsDict)

print("***** Deep Copy *******")

displayList("Original Dictionary : " , wordsDict)

# Create a deep copy of the dictionary
otherDict = copy.deepcopy(wordsDict)

displayList("Deep copy of Dictionary : " , otherDict)

'''
Modify the contents of list object in deep copied dictionary will
have no impact on original dictionary because its a deep copy.
'''
newDict["who"].append(100)

displayList("Modified Deep copy of Dictionary : " , otherDict)
displayList("Original Dictionary : " , wordsDict)

if __name__ == '__main__':
main()

结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
--------
Original Dictionary :
at :: 23
this :: 43
Hello :: 56
test :: 43
who :: [56, 34, 44]
Contents of copied dictionary changed
--------
Modified copied dictionary :
at :: 200
this :: 43
Hello :: 56
test :: 43
who :: [56, 34, 44]
--------
Original Dictionary :
at :: 23
this :: 43
Hello :: 56
test :: 43
who :: [56, 34, 44]
Contents of list in copied dictionary changed
--------
Modified copied dictionary :
at :: 200
this :: 43
Hello :: 56
test :: 43
who :: [56, 34, 44, 222]
--------
Original Dictionary :
at :: 23
this :: 43
Hello :: 56
test :: 43
who :: [56, 34, 44, 222]
***** Deep Copy *******
--------
Original Dictionary :
at :: 23
this :: 43
Hello :: 56
test :: 43
who :: [56, 34, 44, 222]
--------
Deep copy of Dictionary :
at :: 23
this :: 43
Hello :: 56
test :: 43
who :: [56, 34, 44, 222]
--------
Modified Deep copy of Dictionary :
at :: 23
this :: 43
Hello :: 56
test :: 43
who :: [56, 34, 44, 222]
--------
Original Dictionary :
at :: 23
this :: 43
Hello :: 56
test :: 43
who :: [56, 34, 44, 222, 100]

列表拷贝

浅拷贝

使用 =赋值运算符

1
2
3
4
5
6
7
8
9
10
old_list = [[1, 2, 3], [4, 5, 6], [7, 8, 'a']]
new_list = old_list

new_list[2][2] = 9

print('Old List:', old_list)
print('ID of Old List:', id(old_list))

print('New List:', new_list)
print('ID of New List:', id(new_list))

使用copy浅拷贝

1
2
3
4
5
6
7
import copy

old_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
new_list = copy.copy(old_list)

print("Old list:", old_list)
print("New list:", new_list)

使用deepcopy 深拷贝

1
2
3
4
5
6
7
import copy

old_list = [[1, 1, 1], [2, 2, 2], [3, 3, 3]]
new_list = copy.deepcopy(old_list)

print("Old list:", old_list)
print("New list:", new_list)

类拷贝

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
import copy

class Point:
def __init__(self, x, y):
self.x = x
self.y = y

def __repr__(self):
return f'Point({self.x!r}, {self.y!r})'

>>> a = Point(23, 42)
>>> b = copy.copy(a)
>>> a
Point(23, 42)
>>> b
Point(23, 42)
>>> a is b
False

## 使用copy模块的copy方法
class Rectangle:
def __init__(self, topleft, bottomright):
self.topleft = topleft
self.bottomright = bottomright

def __repr__(self):
return (f'Rectangle({self.topleft!r}, '
f'{self.bottomright!r})')
rect = Rectangle(Point(0, 1), Point(5, 6))
srect = copy.copy(rect)

>>> rect
Rectangle(Point(0, 1), Point(5, 6))
>>> srect
Rectangle(Point(0, 1), Point(5, 6))
>>> rect is srect
False
>>> rect.topleft.x = 999
>>> rect
Rectangle(Point(999, 1), Point(5, 6))
>>> srect
Rectangle(Point(999, 1), Point(5, 6))
>>> drect = copy.deepcopy(srect)
>>> drect.topleft.x = 222
>>> drect
Rectangle(Point(222, 1), Point(5, 6))
>>> rect
Rectangle(Point(999, 1), Point(5, 6))
>>> srect
Rectangle(Point(999, 1), Point(5, 6))

## 使用copy方法
class Rectangle(object):
def __init__(self, topleft, bottomright):
self.topleft = topleft
self.bottomright = bottomright

def __repr__(self):
return (f'Rectangle({self.topleft!r}, '
f'{self.bottomright!r})')
def copy(self):
return Rectangle(self.topleft, self.bottomright)



r1 = Rectangle(20,30)
r2 =r1.copy()
print("r1:",r1)
print("r2:",r2)

>>> r1: Rectangle(20, 30)
>>> r2: Rectangle(20, 30)

一个深入的例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
class B(object):
x = 3

CopyOfB = type('CopyOfB', B.__bases__, dict(B.__dict__))

b = B()
cob = CopyOfB()

print b.x # Prints '3'
print cob.x # Prints '3'

b.x = 2
cob.x = 4

print b.x # Prints '2'
print cob.x # Prints '4'

class C(object):
x = []

CopyOfC = type('CopyOfC', C.__bases__, dict(C.__dict__))

c = C()
coc = CopyOfC()

c.x.append(1)
coc.x.append(2)

print c.x # Prints '[1, 2]' (!)
print coc.x # Prints '[1, 2]' (!)

参考文档

how to deep copy a list

shallow-deep-copy

how-to-copy-a-python-class

最后

最近学到一个新词:共克时艰 翻译成 英文 We are suffering,希望和朋友们共勉。

我们都是蝴蝶翅膀上的那粒灰尘,被裹挟在龙卷风里,谁都晕头转向

坚持原创技术分享,您的支持将鼓励我继续创作!