hopeless-dream

导航

Python中的深拷贝和浅拷贝

变量、对象、引用之间的关系

  1. 变量是一个系统表的元素,拥有指向对象的连接的空间
  2. 对象是被分配的一块内存,存储其所代表的值
  3. 引用是自动形成的从变量到对象的指针

类型属于对象,不是变量

对象

Python中一切皆对象,如:1,'a',[1,2,3],(1,),{'a':4}

变量

a=3,a就是一个变量

引用

a=3,a引用了对象3

深、浅拷贝

深拷贝和浅拷贝分别对应copy模块的两个方法:deepcopy()和copy()

浅拷贝:只拷贝顶级的对象,或者说:父级对象          a=copy.copy(b)

深拷贝:拷贝所有对象,顶级对象及其嵌套对象。或者说:父级对象及其子对象       a=copy.deepcopy(b)

字典中只有顶级对象

In [38]: dict1={'name':'tom','age':18}                                                                                    

In [39]: import copy                                                                                                      

In [40]: dict2=copy.copy(dict1)                                                                                           

In [41]: dict3=copy.deepcopy(dict1)         

In [45]: dict2                                                                                                            
Out[45]: {'age': 18, 'name': 'tom'}

In [46]: dict3                                                                                                            
Out[46]: {'age': 18, 'name': 'tom'}

In [52]: id(dict1)                                                                                                        
Out[52]: 140466748386440

In [53]: id(dict2)                                                                                                        
Out[53]: 140466741274952

In [54]: id(dict3)                                                                                                        
Out[54]: 140466749401864

In [47]: dict1['age']=22                                                                                                  

In [48]: dict2                                                                                                            
Out[48]: {'age': 18, 'name': 'tom'}

In [49]: dict3                                                                                                            
Out[49]: {'age': 18, 'name': 'tom'}

In [50]: dict1                                                                                                            
Out[50]: {'age': 22, 'name': 'tom'}    ## 可以看到源字典dict1变了,而深、浅拷贝都没有变

字典中有嵌套对象

In [55]: dict1={'name':{'first':'tom','second':'jerry'},'city':['NY','LA']}                                               

In [56]: import copy                                                                                                      

In [57]: dict2=copy.copy(dict1)                                                                                           

In [58]: dict3=copy.deepcopy(dict1)                                                                                       

In [59]: id(dict1)                                                                                                        
Out[59]: 140466746666568

In [60]: id(dict2)                                                                                                        
Out[60]: 140466746816072

In [61]: id(dict3)                                                                                                        
Out[61]: 140466746724296

In [62]: dict1                                                                                                            
Out[62]: {'city': ['NY', 'LA'], 'name': {'first': 'tom', 'second': 'jerry'}}

In [63]: dict2                                                                                                            
Out[63]: {'city': ['NY', 'LA'], 'name': {'first': 'tom', 'second': 'jerry'}}

In [64]: dict3                                                                                                            
Out[64]: {'city': ['NY', 'LA'], 'name': {'first': 'tom', 'second': 'jerry'}}

In [65]: dict1['name']['first']='john'                                                                                    

In [66]: dict2                                                                                                            
Out[66]: {'city': ['NY', 'LA'], 'name': {'first': 'john', 'second': 'jerry'}}

In [67]: dict3                                                                                                            
Out[67]: {'city': ['NY', 'LA'], 'name': {'first': 'tom', 'second': 'jerry'}}

In [68]: dict1                                                                                                            
Out[68]: {'city': ['NY', 'LA'], 'name': {'first': 'john', 'second': 'jerry'}}

所以:

  • 深浅拷贝都是对源对象的复制,占用不同的内存空间
  • 如果源对象只有一级目录的话,源做任何改动,不影响深浅拷贝对象
  • 如果源对象不止一级目录的话,源做任何改动,都要影响浅拷贝,但不影响深拷贝
  • 序列对象的切片其实是浅拷贝,即只拷贝顶级的对象

 

posted on 2020-07-20 23:42  hopeless-dream  阅读(189)  评论(0编辑  收藏  举报