Python Shallow Copy and Deep Copy

1. Introduction

In Python, copying is one of the most frequently used operations. Sometimes we need to copy the values of one object to another to operate on them independently or avoid modifying the original object. Python provides two methods for achieving this: shallow and deep copies. This article will detail the concepts, usage, and practical application scenarios of shallow and deep copies.

2. The Concept of Copying

In computer programming, copying refers to copying the data of one object to another so that both objects have the same value. Copying is useful in many situations. For example, when multiple objects need to reference the same data, copying can create an independent copy to avoid modifying the original data.

3. Shallow Copy in Python

3.1 Concept

A shallow copy creates a new object whose contents are references to the original object. In other words, a shallow copy only copies the reference to the original object’s data, not the data itself.

3.2 Usage

In Python, we can use the following methods to perform shallow copies:

• Use the slice operator [:] to copy
• Use the copy() function to copy
• Use built-in functions such as list(), dict(), and set() to copy

3.3 Code Example

# Use the slice operator to perform shallow copies
list1 = [1, 2, 3]
list2 = list1[:]
print("list1:", list1) # Output: list1: [1, 2, 3]
print("list2:", list2) # Output: list2: [1, 2, 3] 3]
print("list1 is list2:", list1 is list2) # Output: list1 is list2: False

# Use the copy() function to make a shallow copy
import copy

list3 = [4, 5, 6]
list4 = copy.copy(list3)
print("list3:", list3) # Output: list3: [4, 5, 6]
print("list4:", list4) # Output: list4: [4, 5, 6]
print("list3 is list4:", list3 is list4) # Output: list3 is list4: False

3.4 Characteristics of Shallow Copy

Shallow copy has the following characteristics:

• When making a shallow copy, only the first level of data is copied; deeper levels of data remain referenced.
• The original object and the shallow copy are two independent objects. Modifying the data in one object does not affect the data in the other.
• For mutable objects (such as lists, dictionaries, and sets), data modifications affect both the original object and the shallow copy.

4. Deep Copying in Python

4.1 Concept

A deep copy creates a new object whose contents are completely independent of the original object and have no reference to it. In other words, a deep copy not only copies the reference to the original object’s data, but also copies the data itself.

4.2 Usage

In Python, we can use the following methods to perform a deep copy:
– Use the copy.deepcopy() function to copy

4.3 Code Example

import copy

# Use the deepcopy() function to perform a deep copy
list1 = [[1, 2, 3], [4, 5, 6]]
list2 = copy.deepcopy(list1)
print("list1:", list1) # Output: list1: [[1, 2, 3], [4, 5, 6]]
print("list2:", list2) # Output: list2: [[1, 2, 3], [4, 5, 6]]
print("list1 is list2:", list1 is list2) # Output: list1 is list2: False
print("list1[0] is list2[0]:", list1[0] is list2[0]) # Output: list1[0] is list2[0]: False

4.4 Characteristics of Deep Copy

Deep copy has the following characteristics:

• A deep copy copies all the data of the original object, including multi-level data structures.
• The original object and the deep copy are completely independent objects. Modifying the data of one object will not affect the data of the other object.

5. Application Scenarios of Copy

5.1 Application Scenarios of Shallow Copy

Shallow copy is suitable for the following scenarios:

• When you need to create a copy of the original object so that it can be operated independently.
• When you need to copy the contents of a mutable object (such as a list, dictionary, or set) to another object to avoid modifying the original object.

5.2 Application Scenarios for Deep Copying

Deep copying is suitable for the following scenarios:

• When you need to create a completely independent copy of the original object for independent operations.
• When you need to copy the contents of a multi-level mutable object (such as a nested list, dictionary, or set) to another object to avoid modifying the original object and its subobjects.

6. Summary

This article detailed the concepts, usage, and practical application scenarios of shallow and deep copying in Python. Shallow copying only copies a reference to the original object’s data, while deep copying not only copies the reference but also the data itself. Depending on your needs, you can choose between shallow and deep copying to create independent objects for easy manipulation. Mastering the use of shallow and deep copies is crucial for correctly handling object copies and avoiding modifications to the original objects.