V tomto článku se dozvíte o mělkých kopiích a hlubokých kopiích v Pythonu pomocí příkladů.
Zkopírujte objekt v Pythonu
V Pythonu používáme =operátor k vytvoření kopie objektu. Možná si myslíte, že se tím vytvoří nový objekt; není. Vytvoří pouze novou proměnnou, která sdílí odkaz na původní objekt.
Vezměme si příklad, kde vytvoříme seznam s názvem old_list a předáme odkaz na objekt new_list pomocí =operátoru.
Příklad 1: Kopírování pomocí operátoru =
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))
Když spustíme nad programem, výstup bude:
Starý seznam: (((1, 2, 3), (4, 5, 6), (7, 8, 9)) ID starého seznamu: 140673303268168 Nový seznam: ((1, 2, 3), (4, 5 , 6), (7, 8, 9)) ID nového seznamu: 140673303268168
Jak vidíte z výstupu, obě proměnné old_list a new_list sdílejí stejné ID, tj 140673303268168.
Pokud tedy chcete upravit jakékoli hodnoty v new_list nebo old_list, změna je viditelná v obou.
V zásadě někdy možná budete chtít mít původní hodnoty beze změny a upravit pouze nové hodnoty nebo naopak. V Pythonu existují dva způsoby, jak vytvořit kopie:
- Mělká kopie
- Deep Copy
Aby tyto kopie fungovaly, používáme copymodul.
Kopírovat modul
copyModul Pythonu používáme pro operace mělkého a hlubokého kopírování. Předpokládejme, že musíte zkopírovat složený seznam, řekněme x. Například:
import copy copy.copy (x) copy.deepcopy (x)
Zde se copy()vrací mělká kopie x. Podobně deepcopy()vraťte hlubokou kopii x.
Mělká kopie
Mělká kopie vytvoří nový objekt, který uloží odkaz na původní prvky.
Mělká kopie tedy nevytvoří kopii vnořených objektů, místo toho pouze zkopíruje odkaz vnořených objektů. To znamená, že proces kopírování se neopakuje ani sám nevytváří kopie vnořených objektů.
Příklad 2: Vytvořte kopii pomocí mělké kopie
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)
Když spustíme program, výstup bude:
Starý seznam: ((1, 2, 3), (4, 5, 6), (7, 8, 9) Nový seznam: ((1, 2, 3), (4, 5, 6), (7 , 8, 9))
Ve výše uvedeném programu jsme vytvořili vnořený seznam a poté ho mělkou kopií pomocí copy()metody.
To znamená, že vytvoří nový a nezávislý objekt se stejným obsahem. Abychom to ověřili, vytiskneme seznam old_list i new_list.
Abychom potvrdili, že new_list se liší od old_list, pokusíme se přidat nový vnořený objekt do originálu a zkontrolovat jej.
Příklad 3: Přidání (4, 4, 4) do old_list pomocí mělké kopie
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)
Když spustíme program, bude mít výstup:
Starý seznam: (((1, 1, 1), (2, 2, 2), (3, 3, 3), (4, 4, 4)) Nový seznam: ((1, 1, 1), (2 , 2, 2), (3, 3, 3))
Ve výše uvedeném programu jsme vytvořili mělkou kopii old_list. New_list obsahuje odkazy na původní vnořené objekty uložené v old_list. Poté přidáme nový seznam, tj. (4, 4, 4)Do old_list. Tento nový podseznam nebyl zkopírován do seznamu new_list.
Když však změníte vnořené objekty v old_list, změny se objeví v new_list.
Příklad 4: Přidání nového vnořeného objektu pomocí mělké kopie
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)
Když spustíme program, bude mít výstup:
Starý seznam: ((1, 1, 1), (2, 'AA', 2), (3, 3, 3)) Nový seznam: ((1, 1, 1), (2, 'AA', 2 ), (3, 3, 3))
Ve výše uvedeném programu jsme provedli změny old_list, tj old_list(1)(1) = 'AA'. (1)(1)Byly upraveny podlisty old_list i new_list v indexu . Důvodem je, že oba seznamy sdílejí odkaz na stejné vnořené objekty.
Deep Copy
Hluboká kopie vytvoří nový objekt a rekurzivně přidá kopie vnořených objektů přítomných v původních prvcích.
Pokračujme příkladem 2. Budeme však vytvářet hlubokou kopii pomocí deepcopy()funkce přítomné v copymodulu. Hluboká kopie vytváří nezávislou kopii původního objektu a všech jeho vnořených objektů.
Příklad 5: Kopírování seznamu pomocí 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)
Když spustíme program, bude mít výstup:
Starý seznam: (((1, 1, 1), (2, 2, 2), (3, 3, 3)) Nový seznam: ((1, 1, 1), (2, 2, 2), (3 , 3, 3))
Ve výše uvedeném programu používáme deepcopy()funkci k vytvoření kopie, která vypadá podobně.
Pokud však provedete změny v jakýchkoli vnořených objektech v původním objektu old_list, v kopii new_list neuvidíte žádné změny.
Příklad 6: Přidání nového vnořeného objektu do seznamu pomocí funkce Hluboká kopie
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)
Když spustíme program, bude mít výstup:
Starý seznam: ((1, 1, 1), ('BB', 2, 2), (3, 3, 3)) Nový seznam: ((1, 1, 1), (2, 2, 2), (3, 3, 3))
Když ve výše uvedeném programu přiřadíme old_list novou hodnotu, uvidíme, že je upraven pouze old_list. To znamená, že old_list i new_list jsou nezávislé. Je to proto, že old_list byl rekurzivně zkopírován, což platí pro všechny vnořené objekty.
