copy.copy：浅复制

copy.deepcopy：深复制

直接赋值：简单地拷贝对象的引用，两个对象的id相同。就是对象的引用（别名），就是给当前内存中的对象增加一个“标签”而已。通过使用内置函数 id() ，可以看出指向内存中同一个对象。

浅拷贝(copy)：拷贝父对象，不会拷贝对象的内部的子对象。即浅复制只复制对象本身，没有复制该对象所引用的对象。A shallow copy constructs a new compound object and then (to the extentpossible) inserts references into it to the objects found in the original.

深拷贝(deepcopy)： copy 模块的 deepcopy 方法，完全拷贝了父对象及其子对象。即创建一个新的组合对象，同时递归地拷贝所有子对象，新的组合对象与原对象没有任何关联。虽然实际上会共享不可变的子对象，但不影响它们的相互独立性。A deep copy constructs a new compound object and then, recursively, insertscopies into it of the objects found in the original.

浅拷贝和深拷贝的不同仅仅是对组合对象来说，所谓的组合对象就是包含了其它对象的对象，如列表，类实例。而对于数字、字符串以及其它“原子”类型，没有拷贝一说，产生的都是原对象的引用，所以两者就是一样的结果了。

a={1:{1,2,3}}

b=a

print(a is b)

print(a ==b )

True

True

b = a: 赋值引用，a 和 b 都指向同一个对象。

import copy

import functools

@functools.total_ordering

class MyClass:

    def __init__(self, name):

        self.name = name

    def __eq__(self, other):

        return self.name == other.name

    def __gt__(self, other):

        return self.name > other.name

a = MyClass('a')

my_list = [a]

dup = copy.copy(my_list)

print('             my_list:', my_list)

print('                 dup:', dup)

print('      dup is my_list:', (dup is my_list))

print('      dup == my_list:', (dup == my_list))

print('dup[0] is my_list[0]:', (dup[0] is my_list[0]))

print('dup[0] == my_list[0]:', (dup[0] == my_list[0]))

my_list: [<__main__.MyClass object at 0x101f9c160>]

dup: [<__main__.MyClass object at 0x101f9c160>]

dup is my_list: False

dup == my_list: True

dup[0] is my_list[0]: True

dup[0] == my_list[0]: True

b = a.copy(): 浅拷贝, a 和 b 是一个独立的对象，但他们的子对象还是指向统一对象（是引用）。

import copy

import functools

@functools.total_ordering

class MyClass:

    def __init__(self, name):

        self.name = name

    def __eq__(self, other):

        return self.name == other.name

    def __gt__(self, other):

        return self.name > other.name

a = MyClass('a')

my_list = [a]

dup = copy.deepcopy(my_list)

print('             my_list:', my_list)

print('                 dup:', dup)

print('      dup is my_list:', (dup is my_list))

print('      dup == my_list:', (dup == my_list))

print('dup[0] is my_list[0]:', (dup[0] is my_list[0]))

print('dup[0] == my_list[0]:', (dup[0] == my_list[0]))

my_list: [<__main__.MyClass object at 0x101e9c160>]

dup: [<__main__.MyClass object at 0x1044e1f98>]

dup is my_list: False

dup == my_list: True

dup[0] is my_list[0]: False

dup[0] == my_list[0]: True

Customizing Copy Behavior

b = copy.deepcopy(a): 深度拷贝, a 和 b 完全拷贝了父对象及其子对象，两者是完全独立的。

import copy

import functools

@functools.total_ordering

class MyClass:

　　def __init__(self, name):

　　　　self.name = name

　　def __eq__(self, other):

　　　　return self.name == other.name

　　def __gt__(self, other):

　　　　return self.name > other.name

　　def __copy__(self):

　　　　print('__copy__()')

　　　　return MyClass(self.name)

　　def __deepcopy__(self, memo):

　　　　print('__deepcopy__({})'.format(memo))

　　　　return MyClass(copy.deepcopy(self.name, memo))

a = MyClass('a')

sc = copy.copy(a)

dc = copy.deepcopy(a)

__copy__()

__deepcopy__({})