JSON对象的深拷贝和浅拷贝

Posted 2023-04-27

参考技术A

官网上解释说明的是序列化对象类型（指的将对象转为字符串类型）
直接复制原始对象所有数据，并脱离原始对象；不会对原始对象造成影响；需要注意的事项：以下类型key对象会失丢；

深拷贝的函数方法：

修改原对象数据并掉起深拷贝函数：

这样就解决了JSON.stringify()的局限性

只是单纯的复制原始对象的第一层数据，第二层及以下数据还是原始数据对象的引用，浅拷贝是创建一个新对象，这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型，拷贝的就是基本类型的值，如果属性是引用类型，拷贝的就是内存地址 ，所以如果其中一个对象改变了这个地址，就会影响到另一个对象。

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‘}}

所以：

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