Làm thế nào để sao chép sâu một danh sách?

Tôi có một số vấn đề với một bản sao Danh sách:

Vì vậy, Sau khi tôi nhận được E0từ 'get_edge', tôi thực hiện một bản sao của E0bằng cách gọi 'E0_copy = list(E0)'. Ở đây tôi đoán E0_copylà một bản sao sâu sắc E0, và tôi truyền E0_copyvào 'karger(E)'. Nhưng trong chức năng chính.
Tại sao kết quả 'print E0[1:10]'trước vòng lặp for không giống với kết quả sau vòng lặp for?

Dưới đây là mã của tôi:

def get_graph():
    f=open('kargerMinCut.txt')
    G={}
    for line in f:
        ints = [int(x) for x in line.split()]
        G[ints[0]]=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][0]
        v1=E[edge][1]                   
        E.pop(edge)
        if v0 != v1:
            count -= 1
            i=0
            while 1:
                if i == len(E):
                    break
                if E[i][0] == v1:
                    E[i][0] = v0
                if E[i][1] == v1:
                    E[i][1] = v0
                if E[i][0] == E[i][1]:
                    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_copykhông phải là một bản sao sâu sắc. Bạn không tạo một bản sao sâu bằng cách sử dụng list()(Cả hai list(...)và testList[:]là bản sao nông).

Bạn sử dụng copy.deepcopy(...)để sao chép sâu một danh sách.

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

Xem đoạn trích sau -

>>> 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[0][1] = 10
>>> a
[[1, 10, 3], [4, 5, 6]]
>>> b   # b changes too -> Not a deepcopy.
[[1, 10, 3], [4, 5, 6]]

Bây giờ xem deepcopyhoạt động

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

Tôi tin rằng rất nhiều lập trình viên đã gặp phải một hoặc hai vấn đề phỏng vấn khi họ được yêu cầu sao chép sâu một danh sách liên kết, tuy nhiên vấn đề này khó hơn âm thanh!

trong python, có một mô-đun gọi là "sao chép" với hai chức năng hữu ích

import copy
copy.copy()
copy.deepcopy()

copy () là một hàm sao chép nông, nếu đối số đã cho là cấu trúc dữ liệu hỗn hợp, ví dụ như một danh sách , thì python sẽ tạo một đối tượng khác cùng loại (trong trường hợp này là danh sách mới ) nhưng cho mọi thứ trong danh sách cũ, chỉ có tài liệu tham khảo của họ được sao chép

# think of it like
newList = [elem for elem in oldlist]

Theo trực giác, chúng ta có thể giả định rằng deepcopy () sẽ theo cùng một mô hình, và sự khác biệt duy nhất là với mỗi elem , chúng ta sẽ gọi đệ quy deepcopy , (giống như câu trả lời của mbcoder)

nhưng điều này là sai!

deepcopy () thực sự bảo tồn cấu trúc đồ họa của dữ liệu ghép gốc:

a = [1,2]
b = [a,a] # there's only 1 object a
c = deepcopy(b)

# check the result
c[0] is a # return False, a new object a' is created
c[0] is c[1] # return True, c is [a',a'] not [a',a'']

Đây là phần khó khăn, trong quá trình deepcopy (), một hashtable (từ điển trong python) được sử dụng để ánh xạ: "old_object ref vào new_object ref", điều này ngăn chặn các bản sao không cần thiết và do đó bảo tồn cấu trúc của dữ liệu ghép được sao chép

tài liệu chính thức

Nếu nội dung của danh sách là các kiểu dữ liệu nguyên thủy, bạn có thể sử dụng cách hiểu

new_list = [i for i in old_list]

Bạn có thể lồng nó cho các danh sách đa chiều như:

new_grid = [[i for i in row] for row in grid]

Nếu list elementslà của bạn immutable objectsthì bạn có thể sử dụng cái này, nếu không bạn phải sử dụng deepcopytừ copymodule.

bạn cũng có thể sử dụng cách ngắn nhất để sao chép sâu listnhư thế này.

a = [0,1,2,3,4,5,6,7,8,9,10]
b = a[:] #deep copying the list a and assigning it to b
print id(a)
20983280
print id(b)
12967208

a[2] = 20
print a
[0, 1, 20, 3, 4, 5, 6, 7, 8, 9,10]
print b
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10]

chỉ là một chức năng sao chép sâu đệ quy.

def deepcopy(A):
    rt = []
    for elem in A:
        if isinstance(elem,list):
            rt.append(deepcopy(elem))
        else:
            rt.append(elem)
    return rt

Chỉnh sửa: Như Cfreak đã đề cập, điều này đã được thực hiện trong copymô-đun.

Về danh sách dưới dạng cây, deep_copy trong python có thể được viết gọn nhất là

def deep_copy(x):
    if not isinstance(x, list): return x
    else: return map(deep_copy, x)

Đây là một ví dụ về cách sao chép sâu một danh sách:

  b = [x[:] for x in a]

Đây là nhiều pythonic

my_list = [0, 1, 2, 3, 4, 5]  # some list
my_list_copy = list(my_list)  # my_list_copy and my_list does not share reference now.

LƯU Ý: Điều này không an toàn với danh sách các đối tượng được tham chiếu