python standard library copy
2014 年 4 月 7 日
源码
源代码: Lib/copy.py
类层次结构
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 字典作为第二个参数。
实例
字典拷贝
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()
结果
-------- 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]
列表拷贝
浅拷贝
使用 = 赋值运算符
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 浅拷贝
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 深拷贝
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)
类拷贝
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)
一个深入的例子
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]' (!)
参考文档
最后
最近学到一个新词: 共克时艰 翻译成 英文 We are suffering ,希望和朋友们共勉。
我们都是蝴蝶翅膀上的那粒灰尘，被裹挟在龙卷风里，谁都晕头转向
About The Author
