- 淺拷貝屿愚，拷貝完后，地址一樣:
In [75]: a = [11,22,33]
In [76]: b = a
In [77]: id(a)
Out[77]: 139742502804296
In [78]: id(b)
Out[78]: 139742502804296
Python中都是淺拷貝呛占，內容共享。你修改你的懦趋，我的也跟著變了晾虑。
?
?
-
深拷貝，可以通過
copy模塊進行:
In [82]: import copy
In [83]: a = [11,22,33]
In [84]: b = copy.deepcopy(a)
In [86]: id(a)
Out[86]: 139742502803976
In [87]: id(b)
Out[87]: 139742502835464
復制一份給你仅叫，但內容不共享帜篇。你以后修改了，與我的那份無關诫咱。
copy.deepcopy() 和 copy.copy() 都只會對可變類型進行深拷貝笙隙。
不同的是：
deepcopy() 是會遞歸判斷的深拷貝：如果下一層是可變類型，那么下一層以及下一層之前的層都進行深拷貝坎缭。
In [93]: a = [11,22,33]
In [94]: b = [44,55,66]
In [95]: c = [a,b] #list
In [96]: d = copy.deepcopy(c)
In [97]: a.append(44)
In [98]: c
Out[98]: [[11, 22, 33, 44], [44, 55, 66]]
In [99]: d
Out[99]: [[11, 22, 33], [44, 55, 66]]
In [140]: a = [11,22,33]
In [141]: b = [44,55,66]
In [142]: c = (a,b) #元祖 遞歸判斷
In [143]: d = copy.deepcopy(c)
In [144]: c is d
Out[144]: False
In [145]: a.append(44)
In [146]: c
Out[146]: [[11, 22, 33, 44], [44, 55, 66]]
In [147]: d
Out[147]: [[11, 22, 33], [44, 55, 66]]
In [134]: a = (11,22,33)
In [135]: b = (44,55,66)
In [136]: c = (a,b) #不可變
In [137]: d = copy.deepcopy(c)
In [138]: c is d
Out[138]: True
In [131]: c = (11,22) #不可變
In [132]: d = copy.deepcopy(c)
In [133]: c is d
Out[133]: True
copy.copy() 是非遞歸深拷貝竟痰，只考慮第一層：如果第一層是可變類型，則只對第一層深拷貝掏呼；如果第一層不是可變類型坏快，則進行淺拷貝。
In [106]: a = [11,22,33]
In [107]: b = [44,55,66]
In [108]: c = [a,b] #list 不進行遞歸判斷
In [109]: d = copy.copy(c)
In [110]: id(c)
Out[110]: 139742502712840
In [111]: id(d)
Out[111]: 139742502645512
In [112]: a.append(44)
In [113]: c
Out[113]: [[11, 22, 33, 44], [44, 55, 66]]
In [114]: d
Out[114]: [[11, 22, 33, 44], [44, 55, 66]]
In [146]: a = [11,22,33]
In [147]: b = [44,55,66]
In [148]: c = (a,b) #元祖 不進行遞歸判斷
In [149]: d = copy.copy(c)
In [150]: c is d
Out[150]: True
?
其它語言專場：
?
其它語言憎夷，例如: c莽鸿、Java ：
????????只會對不可變類型進行深拷貝，可變類型都是淺拷貝拾给。
????????函數(shù)傳參的時候可以看出來祥得。
package xxx;
import java.util.List;
import java.util.ArrayList;
class A{
String name = "abc";
@Override
public String toString() {
return "A [name=" + name + "]";
}
}
public class DeepCopy_ShallowCopy {
static void changeA(A a){
a.name += "222";
System.out.println(a);
}
static void changeD(List d){
d.add("222");
System.out.println(d);
}
static void changeB(String b){
b += "222";
System.out.println(b);
}
static void changeC(int c){
c+=222;
System.out.println(c);
}
public static void main(String[] args) {
A a = new A();
List d = new ArrayList();
d.add("aa");
d.add("bb");
d.add("cc");
String b = "bbb";
int c = 333;
System.out.println("函數(shù)里：");
changeA(a);
changeD(d);
changeB(b);
changeC(c);
System.out.println("-------------------");
System.out.println("函數(shù)外：");
System.out.println(a);
System.out.println(d);
System.out.println(b);
System.out.println(c);
}
}
函數(shù)外兔沃，值變了的是淺拷貝，內容共享啃沪。
函數(shù)外粘拾，值沒變的是深拷貝，函數(shù)里操縱的是另一片內存创千。
函數(shù)里：
A [name=abc222]
[aa, bb, cc, 222]
bbb222
555
-------------------
函數(shù)外：
A [name=abc222] #變了
[aa, bb, cc, 222] #變了
bbb #沒變
333 #沒變
