What’s the difference between shallow copy and deep copy in Python? Give an example.

Question

Mayank kumar Verma · Accepted Answer

"Shallow copy ( Quick Duplication )A shallow copy creates a new outer object but it copies the references (memory location ) of the inner, nested object. Result - Changes made to a nested object in the copy will affect the original object and vice versa. They are not fully indipendent Deep copy (full indenpendence )a deep copy creates a new outer object and recursively creates a new copies of all nested objects inside of it. Result - the copy is completely is separate from the origenal . Changes made to any part of the copy wii not affect the original object. Simple Example Imagine original = [[1], [2]]. Action Original List Shallow Copy Deep Copy Initial State [[1], [2]] [[1], [2]] [[1], [2]] Change: original[0][0] = 999 [[999], [2]] [[999], [2]] [[1], [2]] Reason Shallow copy shares the inner list [1] with the original, so the change is seen in both. Deep copy has its own separate inner list, so it remains unchanged. Use copy.copy() for shallow, and copy.deepcopy() for deep."

Mayank kumar Verma · Answer

Shallow copy ( Quick Duplication )A shallow copy creates a new outer object but it copies the references (memory location ) of the inner, nested object. Result - Changes made to a nested object in the copy will affect the original object and vice versa. They are not fully indipendent Deep copy (full indenpendence )a deep copy creates a new outer object and recursively creates a new copies of all nested objects inside of it. Result - the copy is completely is separate from the origenal . Changes made to any part of the copy wii not affect the original object. Simple Example Imagine original = [[1], [2]]. Action Original List Shallow Copy Deep Copy Initial State [[1], [2]] [[1], [2]] [[1], [2]] Change: original[0][0] = 999 [[999], [2]] [[999], [2]] [[1], [2]] Reason Shallow copy shares the inner list [1] with the original, so the change is seen in both. Deep copy has its own separate inner list, so it remains unchanged. Use copy.copy() for shallow, and copy.deepcopy() for deep.

Khushi Singh · Answer

Understanding the difference between shallow and deep copy represents an essential aspect of working with nested lists or dictionaries in the Python programming language. These two types of copying methods create duplicates of objects yet they function in completely different ways regarding nested elements. During a shallow copy operation a single new object emerges yet the original contains entire nested objects which the new object fails to duplicate. The shallow copy process duplicates only the object references but it does not duplicate those nested objects.

The original object along with its shallow copy will share identical references to their mutable types as dictionaries and lists. When using a shallow copy the modifications that occur to the nested objects present in the original object will also affect those nested objects. Deep copies generate an independent object duplicate together with independent instances for all original object nestings.

The recursive element copy process creates a stand-alone duplicated object that disconnects it from its original version. A deep copy of data preserves the original object state since it does not apply alterations made to the nested details. The Python copy module includes two functions: copy() for shallow copying and deepcopy() for deep copying.

Programmers must use deep copy functions when dealing with data because unintended changes in machine learning models can impact their results or behavior.

import copy
original = [[1, 2], [3, 4]]
shallow = copy.copy(original)
deep = copy.deepcopy(original)
shallow[0][0] = 100
deep[1][1] = 200
print("Original:", original)   # Output: [[100, 2], [3, 4]]
print("Shallow:", shallow)     # Output: [[100, 2], [3, 4]]
print("Deep:", deep)           # Output: [[1, 2], [3, 200]]

A shallow copy will maintain identical nested elements whereas deep copy produces independent duplicate versions.

Action	Original List	Shallow Copy	Deep Copy
Initial State	`[[1], [2]]`	`[[1], [2]]`	`[[1], [2]]`
Change: `original[0][0] = 999`	`[[999], [2]]`	`[[999], [2]]`	`[[1], [2]]`
Reason	Shallow copy shares the inner list `[1]` with the original, so the change is seen in both.	Deep copy has its own separate inner list, so it remains unchanged.

forum

What’s the difference between shallow copy and deep copy in Python? Give an example.

Can you answer this question?

2 Answers

Simple Example