Python中模块之copy的功能介绍

                                             模块之copy的功能介绍

copy主要分两种：

1.浅拷贝
2.深拷贝

赋值：

在python中赋值算特殊的拷贝，其实赋值可以理解为同一个对象有两个名字，所以当其中一个发生变化，另一个也跟着会变化。

1.浅拷贝

1. 创建

   格式：copy.copy(x)
   例如：n1 = 123
        print(copy.copy(n1))
    >>> 123
   返回值：obj
   #对于浅拷贝可以调用copy模块，当然也可以直接使用copy函数来执行，实际中直接使用copy函数比较常见。
   

2. int拷贝

   例如：n1 = 123
        n2 = copy.copy(n1)
        print(id(n1))
        print(id(n1))
    >>> 1356861712
    >>> 1356861712
   #对于数值类型的拷贝，拷贝前后id一样，说明该拷贝的内存地址是一样的。
   

3. str拷贝

   例如：n1 = 'abc'
        n2 = copy.copy(n1)
        print(id(n1))
        print(id(n1))
    >>> 16618528
    >>> 16618528
   #对于字符串类型的拷贝，拷贝前后id一样，说明该拷贝的内存地址是一样的。
   

4. list拷贝

   例如：n1 = [1,2,'a','b',]
        n2 = copy.copy(n1)
        print(id(n1))
        print(id(n2))
    >>> 18118472
    >>> 27291208
        print(id(n1[1]))
        print(id(n2[1]))
    >>> 1356857840
    >>> 1356857840
   #该拷贝说明两个列表指向的内存地址并不是一样的,单元素指向的内存地址仍然是一样的。
   例如：n1 = [1,2,'a','b',[1,3,5]]
        n2 = copy.copy(n1)
        print(id(n1[-1]))
        print(id(n2[-1]))
    >>> 27291400
    >>> 27291400
   #拷贝前后列表元素中的列表指向内存地址是一样的。说明拷贝列表的时候，元素中如果是列表，则列表不进行拷贝，直接引用拷贝前列表中的内存地址。
   例如：n1 = [1,2,'a','b',[1,3,5],(2,4,6)]
        n2 = copy.copy(n1)
        print(id(n1[-1]))
        print(id(n2[-1]))
    >>> 26827872
    >>> 26827872
   #对于浅拷贝，当列表中的元素为列表或者元祖等对象时，都是直接引用拷贝前该对象的内存地址。
   

5. tuple拷贝

   例如：n1 = (1,2,'a','b',)
        n2 = copy.copy(n1)
        print(id(n1))
        print(id(n2))
    >>> 26736424
    >>> 26736424
   #拷贝前后两个元祖的内存地址是一样，说明拷贝元祖时，是直接引用拷贝前元祖的内存地址。
   例如：n1 = (1,2,'a','b',(1,3,5))
        n2 = copy.copy(n1)
        print(id(n1[-1]))
        print(id(n2[-1]))
    >>> 26827872
    >>> 26827872
   #当有元祖的元素为元祖时，在拷贝时，也是直接引用拷贝前元祖中元素的内存地址。
   

6. dict拷贝

   例如：n1 = {'k1':'v1','k2':'v2'}
        n2 = copy.copy(n1)
        print(id(n1))
        print(id(n2))
    >>> 16773512
    >>> 19730504
   #拷贝字典时，拷贝前后的内存地址不一样，说明字典的拷贝并不是直接引用拷贝前的内存地址。
   例如：n1 = {'k1':'v1','k2':'v2','k3':{'kx1':'vx1','kx2':'vx2'}}
        n2 = copy.copy(n1)
        print(id(n1['k3']))
        print(id(n2['k3']))
    >>> 19730504
    >>> 19730504
   #当字典中的key对于的value为字典时，进行浅拷贝时，直接引用其拷贝前的内存地址。
   

7. set拷贝

   例如：n1 = {1,2,'a','b'}
        n2 = copy.copy(n1)
        print(id(n1))
        print(id(n2))
    >>> 18151016
    >>> 18150792
   #集合的浅拷贝，拷贝前后的内存地址并不是一样的。
   

8. collections.Counter拷贝

   由于字典计数器是对字典的扩展，而且返回值仍是一个字典，因此该对象的浅拷贝，参考字典的浅拷贝即可。
   

9. collections.OrderedDict拷贝

   由于有序字典也是对字典的扩展，但该返回值为列表，因此该对象的浅拷贝，参考列表浅拷贝的第三种例子即可。
   

10. collections.defaultdict拷贝

    由于默认字典也是对字典的扩展，而且返回值属于字典类型，因此该对象的浅拷贝，参考字典的浅拷贝即可。
    

11. collections.namedtuple拷贝

    由于可命名元祖是对元祖的扩展，但返回值属于元祖类型，因此该对象的浅拷贝，参考元祖的浅拷贝即可。
    

12. collections.deque拷贝

    由于双向队列返回值属于列表类型，因此该对象的浅拷贝，参考列表的浅拷贝即可。
    

2.深拷贝

1. 创建

   格式：copy.deepcopy(x,memo=None)
   例如：n1 = 123
        print(copy.deepcopy(n1))
    >>> 123
   返回值：obj
   #深拷贝的创建只能调用copy模块来执行。
   

2. int拷贝

   例如：n1 = 123
        n2 = copy.deepcopy(n1)
        print(id(n1))
        print(id(n2))
    >>> 1356861712
    >>> 1356861712
   #对于数值类型的拷贝，拷贝前后id一样，说明该拷贝的内存地址是一样的。
   

3. str拷贝

   例如：n1 = 'abc'
        n2 = copy.deepcopy(n1)
        print(id(n1))
        print(id(n1))
    >>> 16618528
    >>> 16618528
   #对于字符串类型的拷贝，拷贝前后id一样，说明该拷贝的内存地址是一样的。
   

4. list拷贝

   例如：n1 = [1,2,'a','b',]
        n2 = copy.deepcopy(n1)
        print(id(n1))
        print(id(n2))
    >>> 27291336
    >>> 27276808
        print(id(n1[1]))
        print(id(n2[1]))
    >>> 1356857840
    >>> 1356857840
   #该拷贝说明两个列表指向的内存地址并不是一样的,单元素指向的内存地址仍然是一样的。
   例如：n1 = [1,2,'a','b',[1,3,5]]
        n2 = copy.deepcopy(n1)
        print(id(n1[-1]))
        print(id(n2[-1]))
    >>> 27291464
    >>> 27291272
   #拷贝前后列表元素中的列表指向内存地址也是不一样的。说明拷贝列表的时候，元素中如果是列表，则列表也进行拷贝，不再引用拷贝前列表中的内存地址。
   例如：n1 = [1,2,'a','b',[1,3,5],(2,4,6)]
        n2 = copy.deepcopy(n1)
        print(id(n1[-1]))
        print(id(n2[-1]))
    >>> 26827872
    >>> 26827872
   #对于深拷贝，拷贝对象为元祖时，都是直接引用拷贝前的内存地址。
   

5. tuple拷贝

   例如：n1 = (1,2,'a','b',)
        n2 = copy.deepcopy(n1)
        print(id(n1))
        print(id(n2))
    >>> 26736424
    >>> 26736424
   #拷贝前后两个元祖的内存地址是一样，说明拷贝元祖时，是直接引用拷贝前元祖的内存地址。
   例如：n1 = (1,2,'a','b',(1,3,5))
        n2 = copy.deepcopy(n1)
        print(id(n1[-1]))
        print(id(n2[-1]))
    >>> 26827872
    >>> 26827872
   #当有元祖的元素为元祖时，在拷贝时，也是直接引用拷贝前元祖中元素的内存地址。
   

   注：由于在python中数值、字符串和元祖，属于不可改变的对象，因此在深浅拷贝中，都是直接引用拷贝前的内存地址，并非重新开辟一块内存地址。

6. dict拷贝

   例如：n1 = {'k1':'v1','k2':'v2'}
        n2 = copy.deepcopy(n1)
        print(id(n1))
        print(id(n2))
    >>> 16773512
    >>> 27253512
   #拷贝字典时，拷贝前后的内存地址不一样，说明字典的拷贝并不是直接引用拷贝前的内存地址。
   例如：n1 = {'k1':'v1','k2':'v2','k3':{'kx1':'vx1','kx2':'vx2'}}
        n2 = copy.deepcopy(n1)
        print(id(n1['k3']))
        print(id(n2['k3']))
    >>> 19730504
    >>> 26819016
   #深拷贝中，当字典中key对应的value为字典时，进行拷贝时，并不是直接引用其拷贝前的内存地址。
   

7. set拷贝

   例如：n1 = {1,2,'a','b'}
        n2 = copy.deepcopy(n1)
        print(id(n1))
        print(id(n2))
    >>> 18151016
    >>> 27225672
   #集合的深拷贝，拷贝前后的内存地址并不是一样的。
   

   注：由于集合中不能包含集合，这里不再多举例说明。

8. collections.Counter拷贝

   由于字典计数器是对字典的扩展，而且返回值仍是一个字典，因此该对象的深拷贝，参考字典的深拷贝即可。
   

9. collections.OrderedDict拷贝

   由于有序字典也是对字典的扩展，但该返回值为列表，因此该对象的深拷贝，参考列表浅拷贝的第三种例子即可。
   

10. collections.defaultdict拷贝

    由于默认字典也是对字典的扩展，而且返回值属于字典类型，因此该对象的深拷贝，参考字典的深拷贝即可。
    

11. collections.namedtuple拷贝

    由于可命名元祖是对元祖的扩展，但返回值属于元祖类型，因此该对象的深拷贝，参考元祖的深拷贝即可。
    

12. collections.deque拷贝

    由于双向队列返回值属于列表类型，因此该对象的深拷贝，参考列表的深拷贝即可。
    

注：由于queue模块中的Queue单项队列没有copy功能，因此这里不作介绍。