python的=拷贝、浅拷贝copy和deepcopy深拷贝

当你a=1000的时候a指向一个新的类，内容为1000，而b仍然指向原来指向的内容，因为你没有叫它指向其他内容。你使用=符号，使得a和b指向同一个内容，而copy则是将b的内容复制后让c指向这个拷贝的内容上了。看下面图种运行的结果。b=a，使用a改变"age"，b和a中的都改变了。而c采用copy，不受影响。

等会儿画个图补充上来就更容易理解了。

C从来没有改变过。c中age的值一直保持在copy时获得的那个10，只有a和b在后面age变成了11。

这个是个浅拷贝的事例，下面举个深拷贝的事例，并结合浅拷贝，

c采用浅拷贝，d采用深拷贝，修改a中age的值，a和b的都改变了，c和d的没有改变，但是修改a中“d”里的list，则导致abc中list都改变，d中是深拷贝的则没有改变。

详细看最下补充的图：

 
   
        a  
        =  
        { 
        "d" 
        : [ 
        "a" 
        ,  
        "1" 
        ],  
        "age" 
        :  
        10 
        } 
       
 
        b  
        =  
        a  
       
 
        c  
        =  
        a.copy() 
       
 
        from  
        copy  
        import  
        deepcopy 
       
 
        d  
        =  
        deepcopy(a) 
       
 
        print  
        "before:" 
       
 
        print  
        "a:" 
        , a 
       
 
        print  
        "b:" 
        , b 
       
 
        print  
        "c:" 
        , c 
       
 
        print  
        "d:" 
        , d 
       
 
        a[ 
        "d" 
        ].append( 
        "c" 
        ) 
       
 
        a[ 
        "age" 
        ]  
        =  
        11 
       
 
        print  
        "after:" 
       
 
        print  
        "a:" 
        , a 
       
 
        print  
        "b:" 
        , b 
       
 
        print  
        "c:" 
        , c 
       
 
        print  
        "d:" 
        , d 
       

           
       

           
       
 
        #=>结果 
       
 
        before: 
       
 
        a: { 
        'age' 
        :  
        10 
        ,  
        'd' 
        : [ 
        'a' 
        ,  
        '1' 
        ]} 
       
 
        b: { 
        'age' 
        :  
        10 
        ,  
        'd' 
        : [ 
        'a' 
        ,  
        '1' 
        ]} 
       
 
        c: { 
        'age' 
        :  
        10 
        ,  
        'd' 
        : [ 
        'a' 
        ,  
        '1' 
        ]} 
       
 
        d: { 
        'age' 
        :  
        10 
        ,  
        'd' 
        : [ 
        'a' 
        ,  
        '1' 
        ]} 
       
 
        after: 
       
 
        a: { 
        'age' 
        :  
        11 
        ,  
        'd' 
        : [ 
        'a' 
        ,  
        '1' 
        ,  
        'c' 
        ]} 
       
 
        b: { 
        'age' 
        :  
        11 
        ,  
        'd' 
        : [ 
        'a' 
        ,  
        '1' 
        ,  
        'c' 
        ]} 
       
 
        c: { 
        'age' 
        :  
        10 
        ,  
        'd' 
        : [ 
        'a' 
        ,  
        '1' 
        ,  
        'c' 
        ]} 
       
 
        d: { 
        'age' 
        :  
        10 
        ,  
        'd' 
        : [ 
        'a' 
        ,  
        '1' 
        ]} 
       
 
 

ython中的对象之间赋值时是按引用传递的，如果需要拷贝对象，需要使用标准库中的copy模块。

1. copy.copy 浅拷贝只拷贝父对象，不会拷贝对象的内部的子对象。通俗易懂的讲，外面的对象不拷贝，而若是原来对象中还有子对象，那么该自对象是拷贝的。
2. copy.deepcopy 深拷贝拷贝对象及其子对象与原对象的关系最不紧密，一旦实现深拷贝，那么你就是你，我就是我，你我之间没有任何关系。
一个很好的例子：

 
   
        import  
        copy 
       
 
        a  
        =  
        [ 
        1 
        ,  
        2 
        ,  
        3 
        ,  
        4 
        , [ 
        'a' 
        ,  
        'b' 
        ]]   
        #原始对象 
       

           
       
 
        b  
        =  
        a   
        #赋值，传对象的引用 
       
 
        c  
        =  
        copy.copy(a)   
        #对象拷贝，浅拷贝 
       
 
        d  
        =  
        copy.deepcopy(a)   
        #对象拷贝，深拷贝 
       

           
       
 
        a.append( 
        5 
        )   
        #修改对象a 
       
 
        a[ 
        4 
        ].append( 
        'c' 
        )   
        #修改对象a中的['a', 'b']数组对象 
       

           
       
 
        print  
        'a = ' 
        , a 
       
 
        print  
        'b = ' 
        , b 
       
 
        print  
        'c = ' 
        , c 
       
 
        print  
        'd = ' 
        , d 
       
 
 