Keywords: Python Lists | Reference Passing | Shallow Copy | Deep Copy | Object Copying
Abstract: This article provides a comprehensive examination of Python's reference passing mechanism for lists, analyzing data sharing issues caused by direct assignment. Through comparative experiments with slice operations, list() constructor, and copy module, it details shallow and deep copy implementations. Complete code examples and memory analysis help developers thoroughly understand Python object copying mechanisms and avoid common reference pitfalls.
Reference Mechanism of Python Lists
In Python programming, lists as mutable objects employ reference passing in assignment operations. When executing b = a, variable b actually points to the same underlying data object as a, rather than creating a new independent copy.
Problem Phenomenon Analysis
Consider the following typical scenario:
a = ['help', 'copyright', 'credits', 'license']
b = a
b.append('XYZ')
print('b:', b) # Output: ['help', 'copyright', 'credits', 'license', 'XYZ']
print('a:', a) # Output: ['help', 'copyright', 'credits', 'license', 'XYZ']Both variables point to the same memory object, so any modification through b will be reflected in a. While this design improves memory efficiency, it may cause unexpected behavior in scenarios requiring independent copies.
Shallow Copy Solutions
Python provides multiple methods for creating list copies:
Slice Operation Method
Using full slice [:] to create a new list:
a = ['help', 'copyright', 'credits', 'license']
b = a[:] # Create shallow copy of a
b.append('XYZ')
print('b:', b) # Output: ['help', 'copyright', 'credits', 'license', 'XYZ']
print('a:', a) # Output: ['help', 'copyright', 'credits', 'license']Constructor Method
Using list() constructor:
a = ['help', 'copyright', 'credits', 'license']
b = list(a) # Create new list object
b.append('XYZ')
print('b:', b) # Output includes new element
print('a:', a) # Original list remains unchangedLimitations of Shallow Copy
When lists contain nested mutable objects, shallow copy only duplicates outer references:
a = [[1, 2], [3], [4]]
b = a[:] # Shallow copy
c = list(a) # Shallow copy
# Modify nested list
c[0].append(9)
print('a:', a) # Output: [[1, 2, 9], [3], [4]]
print('b:', b) # Output: [[1, 2, 9], [3], [4]]
print('c:', c) # Output: [[1, 2, 9], [3], [4]]All copies share the same nested list objects, so modifying any nested element affects all related lists.
Deep Copy Solution
For structures containing nested mutable objects, use copy.deepcopy():
from copy import deepcopy
a = [[1, 2], [3], [4]]
b = a[:] # Shallow copy
c = deepcopy(a) # Deep copy
# Modify deep copy's nested list
c[0].append(9)
print('a:', a) # Output: [[1, 2], [3], [4]]
print('b:', b) # Output: [[1, 2], [3], [4]]
print('c:', c) # Output: [[1, 2, 9], [3], [4]]Deep copy recursively duplicates all nested objects, creating completely independent copy structures.
Performance and Application Scenarios
Shallow copy operations (slicing, list()) have O(n) time complexity, suitable for simple list structures. Deep copy complexity depends on nesting depth and object count, appropriate for complex nested structures. In practical development, choose the appropriate copying strategy based on data structure complexity.
Conclusion
Python manages mutable objects through reference mechanisms, and understanding this characteristic is crucial for writing correct programs. Shallow copy suits simple list separation, while deep copy addresses complete independence requirements for nested structures. Developers should select appropriate copying strategies based on specific scenarios to ensure expected data operation behavior.