# How to deep copy a list?

I have some problem with a List copy:

So After I got `E0` from `'get_edge'`, I make a copy of `E0` by calling `'E0_copy = list(E0)'`. Here I guess `E0_copy` is a deep copy of `E0`, and I pass `E0_copy` into `'karger(E)'`. But in the main function.
Why does the result of `'print E0[1:10]'` before the for loop is not the same with that after the for loop?

Below is my code:

```    def get_graph():
f=open('kargerMinCut.txt')
G={}
for line in f:
ints = [int(x) for x in line.split()]
G[ints]=ints[1:len(ints)]
return G

def get_edge(G):
E=[]
for i in range(1,201):
for v in G[i]:
if v>i:
E.append([i,v])
print id(E)
return E

def karger(E):
import random
count=200
while 1:
if count == 2:
break
edge = random.randint(0,len(E)-1)
v0=E[edge]
v1=E[edge]
E.pop(edge)
if v0 != v1:
count -= 1
i=0
while 1:
if i == len(E):
break
if E[i] == v1:
E[i] = v0
if E[i] == v1:
E[i] = v0
if E[i] == E[i]:
E.pop(i)
i-=1
i+=1

mincut=len(E)
return mincut

if __name__=="__main__":
import copy
G = get_graph()
results=[]
E0 = get_edge(G)
print E0[1:10]               ## this result is not equal to print2
for k in range(1,5):
E0_copy=list(E0)         ## I guess here E0_coypy is a deep copy of E0
results.append(karger(E0_copy))
#print "the result is %d" %min(results)
print E0[1:10]               ## this is print2
```

`E0_copy` is not a deep copy. You don't make a deep copy using `list()` (Both `list(...)` and `testList[:]` are shallow copies).

You use `copy.deepcopy(...)` for deep copying a list.

```    deepcopy(x, memo=None, _nil=[])
Deep copy operation on arbitrary Python objects.
```

See the following snippet -

```    >>> a = [[1, 2, 3], [4, 5, 6]]
>>> b = list(a)
>>> a
[[1, 2, 3], [4, 5, 6]]
>>> b
[[1, 2, 3], [4, 5, 6]]
>>> a = 10
>>> a
[[1, 10, 3], [4, 5, 6]]
>>> b   # b changes too -> Not a deepcopy.
[[1, 10, 3], [4, 5, 6]]
```

Now see the `deepcopy` operation

```    >>> import copy
>>> b = copy.deepcopy(a)
>>> a
[[1, 10, 3], [4, 5, 6]]
>>> b
[[1, 10, 3], [4, 5, 6]]
>>> a = 9
>>> a
[[1, 9, 3], [4, 5, 6]]
>>> b    # b doesn't change -> Deep Copy
[[1, 10, 3], [4, 5, 6]]
```

From: stackoverflow.com/q/17873384

Back to homepage or read more recommendations: