W tym artykule nauczysz się kopiowania płytkiego i głębokiego w Pythonie na podstawie przykładów.
Skopiuj obiekt w Pythonie
W Pythonie używamy =operatora do tworzenia kopii obiektu. Możesz pomyśleć, że tworzy to nowy obiekt; tak nie jest. Tworzy tylko nową zmienną, która ma wspólne odniesienie do oryginalnego obiektu.
Weźmy przykład, w którym tworzymy listę o nazwie old_list i przekazujemy odniesienie do obiektu do new_list przy użyciu =operatora.
Przykład 1: Kopiuj za pomocą operatora =
old_list = ((1, 2, 3), (4, 5, 6), (7, 8, 'a')) new_list = old_list new_list(2)(2) = 9 print('Old List:', old_list) print('ID of Old List:', id(old_list)) print('New List:', new_list) print('ID of New List:', id(new_list))
Kiedy uruchomimy powyższy program, wynik będzie:
Stara lista: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) ID starej listy: 140673303268168 Nowa lista: ((1, 2, 3), (4, 5 , 6), (7, 8, 9)) ID nowej listy: 140673303268168
Jak widać z danych wyjściowych, obie zmienne stara_lista i nowa_lista mają ten sam identyfikator, tj 140673303268168.
Tak więc, jeśli chcesz zmodyfikować jakiekolwiek wartości w new_list lub old_list, zmiana jest widoczna w obu.
Zasadniczo czasami możesz chcieć pozostawić oryginalne wartości bez zmian i zmodyfikować tylko nowe wartości lub odwrotnie. W Pythonie istnieją dwa sposoby tworzenia kopii:
- Płytka kopia
- Głęboka kopia
Aby te kopie działały, używamy copymodułu.
Kopiuj moduł
Używamy copymodułu Pythona do operacji kopiowania płytkiego i głębokiego. Załóżmy, że musisz skopiować listę złożoną, powiedz x. Na przykład:
import copy copy.copy (x) copy.deepcopy (x)
Tutaj copy()zwraca płytką kopię x. Podobnie deepcopy()zwróć głęboką kopię x.
Płytka kopia
Płytka kopia tworzy nowy obiekt, który przechowuje odniesienia do oryginalnych elementów.
Tak więc płytka kopia nie tworzy kopii zagnieżdżonych obiektów, zamiast tego po prostu kopiuje odniesienie do zagnieżdżonych obiektów. Oznacza to, że sam proces kopiowania nie powtarza się ani nie tworzy kopii zagnieżdżonych obiektów.
Przykład 2: Utwórz kopię używając płytkiej kopii
import copy old_list = ((1, 2, 3), (4, 5, 6), (7, 8, 9)) new_list = copy.copy(old_list) print("Old list:", old_list) print("New list:", new_list)
Kiedy uruchomimy program, wynik będzie:
Stara lista: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) Nowa lista: ((1, 2, 3), (4, 5, 6), (7 8, 9))
W powyższym programie utworzyliśmy zagnieżdżoną listę, a następnie płytko ją skopiowaliśmy copy()metodą.
Oznacza to, że utworzy nowy i niezależny obiekt o tej samej zawartości. Aby to zweryfikować, drukujemy zarówno old_list, jak i new_list.
Aby potwierdzić, że new_list różni się od old_list, próbujemy dodać nowy zagnieżdżony obiekt do oryginału i sprawdzić go.
Przykład 3: Dodanie (4, 4, 4) do old_list przy użyciu płytkiej kopii
import copy old_list = ((1, 1, 1), (2, 2, 2), (3, 3, 3)) new_list = copy.copy(old_list) old_list.append((4, 4, 4)) print("Old list:", old_list) print("New list:", new_list)
Kiedy uruchomimy program, wyświetli:
Stara lista: ((1, 1, 1), (2, 2, 2), (3, 3, 3), (4, 4, 4)) Nowa lista: ((1, 1, 1), (2 , 2, 2), (3, 3, 3))
W powyższym programie stworzyliśmy płytką kopię old_list. Nowa_lista zawiera odniesienia do oryginalnych zagnieżdżonych obiektów przechowywanych w old_list. Następnie dodajemy nową listę, tj. (4, 4, 4)Do starej_listy. Ta nowa lista podrzędna nie została skopiowana do nowej_listy.
Jednak po zmianie jakichkolwiek zagnieżdżonych obiektów w old_list, zmiany pojawią się w new_list.
Przykład 4: Dodawanie nowego zagnieżdżonego obiektu przy użyciu płytkiej kopii
import copy old_list = ((1, 1, 1), (2, 2, 2), (3, 3, 3)) new_list = copy.copy(old_list) old_list(1)(1) = 'AA' print("Old list:", old_list) print("New list:", new_list)
Kiedy uruchomimy program, wyświetli:
Stara lista: ((1, 1, 1), (2, 'AA', 2), (3, 3, 3)) Nowa lista: ((1, 1, 1), (2, 'AA', 2 ), (3, 3, 3))
W powyższym programie dokonaliśmy zmian w old_list ie old_list(1)(1) = 'AA'. Obie podlisty old_list i new_list w indeksie (1)(1)zostały zmodyfikowane. Dzieje się tak, ponieważ obie listy współużytkują odniesienia do tych samych zagnieżdżonych obiektów.
Głęboka kopia
Głęboka kopia tworzy nowy obiekt i rekurencyjnie dodaje kopie zagnieżdżonych obiektów obecnych w oryginalnych elementach.
Kontynuujmy przykład 2. Jednak utworzymy głęboką kopię za pomocą deepcopy()funkcji obecnej w copymodule. Głęboka kopia tworzy niezależną kopię oryginalnego obiektu i wszystkich jego zagnieżdżonych obiektów.
Przykład 5: Kopiowanie listy przy użyciu funkcji deepcopy ()
import copy old_list = ((1, 1, 1), (2, 2, 2), (3, 3, 3)) new_list = copy.deepcopy(old_list) print("Old list:", old_list) print("New list:", new_list)
Kiedy uruchomimy program, wyświetli:
Stara lista: ((1, 1, 1), (2, 2, 2), (3, 3, 3)) Nowa lista: ((1, 1, 1), (2, 2, 2), (3 , 3, 3))
W powyższym programie używamy deepcopy()funkcji do stworzenia kopii, która wygląda podobnie.
Jeśli jednak dokonasz zmian w jakimkolwiek zagnieżdżonym obiekcie w oryginalnym obiekcie stara_lista, nie zobaczysz żadnych zmian w kopii new_list.
Przykład 6: Dodanie nowego zagnieżdżonego obiektu do listy przy użyciu funkcji Deep copy
import copy old_list = ((1, 1, 1), (2, 2, 2), (3, 3, 3)) new_list = copy.deepcopy(old_list) old_list(1)(0) = 'BB' print("Old list:", old_list) print("New list:", new_list)
Kiedy uruchomimy program, wyświetli:
Stara lista: ((1, 1, 1), ('BB', 2, 2), (3, 3, 3)) Nowa lista: ((1, 1, 1), (2, 2, 2), (3, 3, 3))
W powyższym programie, kiedy przypisujemy nową wartość do old_list, widzimy, że modyfikowana jest tylko stara_lista. Oznacza to, że zarówno stara, jak i nowa lista są niezależne. Dzieje się tak, ponieważ old_list została skopiowana rekurencyjnie, co jest prawdą dla wszystkich jej zagnieżdżonych obiektów.
