python3 赋值和深浅拷贝的区别

1.赋值：

=赋值：数据完全共享（=赋值是在内存中指向同一个对象，是可变(mutable)类型【列表，字典】修改其中一个，另一个必定改变

如果是不可变类型(immutable)【字符串，数字，元祖】修改了其中一个，另一个并不会变

）

可变类型：
a = [[1, 2, 3], 3, 44, 32]  
a1=a                        
print(id(a))                
print(id(a1))               
a1[0][1]="aaaaaa"           
print(id(a))                
print(id(a1))               
print(a)                    
print(a1)                   


#
47894152
47894152
47894152
47894152
[[1, 'aaaaaa', 3], 3, 44, 32]
[[1, 'aaaaaa', 3], 3, 44, 32]

　　

不可变类型：
a = "qwe"         
a1 = a            
print(id(a))      
print(id(a1))     
print(a)          
print(a1)         
a1 = "as"         
print(id(a))      
print(id(a1))     
print(a)          
print(a1)         



#
34066816
34066816
qwe
qwe
34066816
34066760
qwe
as

　2.浅拷贝：

浅拷贝：数据半共享（复制其数据独立内存存放，但是只拷贝成功第一层），对于一个对象的顶层拷贝，通俗的理解就是，拷贝了引用，并没有拷贝内容

【拷贝，修改copy得到的第一层，值会被修改，初始的不变】

【拷贝，修改copy得到的第二层，初始和copy得到的两者同时改变】

拷贝不可变类型有（元祖）根本不会进行浅拷贝，仅仅是指向，原因是：

　　因为元祖是不可变类型，因此copy.copy的时候它会自动判断，如果是元祖它就是指向了它。

修改第一层的value：
a=["sb",11,890,[2221,"sd",333]]  
a1 = a.copy()                    
print(a)                         
print(a1)                        
print(id(a))                     
print(id(a1))                    
a1[0] = "AAAAAAAAAA"             
print(a)                         
print(a1)                        
print(id(a))                     
print(id(a1))                    

#
['sb', 11, 890, [2221, 'sd', 333]]
['sb', 11, 890, [2221, 'sd', 333]]
41104520
41104584
['sb', 11, 890, [2221, 'sd', 333]]
['AAAAAAAAAA', 11, 890, [2221, 'sd', 333]]
41104520
41104584

　

修改第二层的value：
a=["sb",11,890,[2221,"sd",333]]
a1 = a.copy()
print(a)
print(a1)
print(id(a))
print(id(a1))
a1[3][0] = "BBBBBBBBBBBBBBBBBB"
print(a)
print(a1)
print(id(a))
print(id(a1))

#
['sb', 11, 890, [2221, 'sd', 333]]
['sb', 11, 890, [2221, 'sd', 333]]
37605000
37631048
['sb', 11, 890, ['BBBBBBBBBBBBBBBBBB', 'sd', 333]]
['sb', 11, 890, ['BBBBBBBBBBBBBBBBBB', 'sd', 333]]
37605000
37631048

　3.深拷贝：

数据完全不共享（复制其数据完完全全放独立的一个内存，完全拷贝，数据不共享）【不管是第一层还是第二层并不会互相影响，需要import copy】　

import copy                        
a=["sb",11,890,[2221,"sd",333]]    
a1 = copy.deepcopy(a)              
print(a)                           
print(a1)                          
print(id(a))                       
print(id(a1))                      
a1[0]="SBSBSBSBSBSB"               
a1[3][0] = "CCCCCCCC"              
print(a)                           
print(a1)                          
print(id(a))                       
print(id(a1))      


#
['sb', 11, 890, [2221, 'sd', 333]]
['sb', 11, 890, [2221, 'sd', 333]]
41539528
41540232
['sb', 11, 890, [2221, 'sd', 333]]
['SBSBSBSBSBSB', 11, 890, ['CCCCCCCC', 'sd', 333]]
41539528
41540232                

　　使用copy模块的copy功能的时候，它会根据当前拷贝的数据类型是可变还是不可变类型有不同的处理方式。

　　如果是用copy.copy，deepcopy对一个全部都是不可变类型的数据进行拷贝，那么他们结果相同，都是指向引用；

import copy            
c=(11,22,"aa","cc")    
d1=copy.copy(c)        
d2=copy.deepcopy(c)    
print(c,id(c))         
print(d1,id(d1))#  指向  
print(d2,id(d2))#  指向  


####################
(11, 22, 'aa', 'cc') 45670472
(11, 22, 'aa', 'cc') 45670472
(11, 22, 'aa', 'cc') 45670472

 

　　如果拷贝的是一个拥有 不可变类型的数据，也就是元祖是最顶层是，那么deepcopy依然是深拷贝，而copy.copy还是指向。

import copy              
a=[11,22]                
b=["aa","bb"]            
c=(a,b)                  
d1=copy.copy(c)          
d2=copy.deepcopy(c)      
print(c,id(c))           
print(d1,id(d1))#  指向    
print(d2,id(d2))#  深拷贝   


#####################
([11, 22], ['aa', 'bb']) 52653896
([11, 22], ['aa', 'bb']) 52653896
([11, 22], ['aa', 'bb']) 53033608