Six core methods of Python list assignment

1. Six weapons for list assignment

Direct assignment (reference pass)

a = [1, 2, 3]
b = a  # bandaPoint to the same memory address

• Features: Zero copy, modifying b will affect a
• Applicable scenarios: Temporary operations that require sharing of data

Slicing operation (shallow copy)

a = [1, 2, 3]
b = a[:]  # Create a new list，But the element is a reference to the original list

• Features: Create new list objects, but nested structures are still shared
• Applicable scenarios: Quick copy of single-layer lists

list() constructor

a = [1, 2, 3]
b = list(a)  # Equivalent to slice operation

• Features: It is comparable to slice performance and has better code readability
• Applicable scenario: When it is necessary to express the copy intention explicitly

Copy module shallow copy

import copy
a = [1, 2, 3]
b = (a)  # Explicitly shallow copy

• Features: The same performance as slice/list(), with clearer semantics
• Applicable scenarios: when copying complex objects or maintaining code

List comprehension

a = [1, 2, 3]
b = [x for x in a]  # Create a new list by iterating

• Features: Flexible but slightly slow, suitable for scenarios where elements need to be converted
• Applicable scenarios: Element processing is required during copying

Deepcopy (deepcopy)

import copy
a = [[1,2], [3,4]]
b = (a)  # A completely independent new object

• Features: Completely independent, but large performance overhead
• Applicable scenarios: Complex structures containing nested mutable objects

2. Performance competition: Who is the strongest king?

We use the timeit module to benchmark 10 million operations (Python 3.10 environment):

Key findings:

• Direct assignment is the fastest (but will be shared and modified)
• Slicing/list()/() is close to performance, and it is the first choice for shallow copies.
• List comprehension is suitable for scenarios where elements are processed
• Deep copy performance overhead is significant and should be used with caution

3. The secrets of the memory mechanism: reference and copy

The nature of assignment of Python lists is the management of reference counts:

• Direct assignment: Increase the reference count of the original list
• Shallow copy: Create a new list object, but the element reference remains unchanged
• Deep copy: Recursively create copies of all nested objects

Visualize memory model:

Original list a = [[1,2], [3,4]]
 
Direct assignment：
b → Point to a Memory address
 
After a shallow copy：
b → New list object → 元素仍Point to原嵌套列表
 
After a deep copy：
b → New list object → Each nested list is a new object

4. Scenario-based selection strategy

A completely separate copy is required
➜ Choose deepcopy (note the performance cost)
Handle a list of simple elements
➜ Use slice a[:] or list(a) first
Need to convert element types
➜Use list comprehension: [int(x) for x in a]
Temporary sharing of data
➜ Direct assignment b = a (note side effects)
Processing super-large data sets
➜ Consider generator expression: (x for x in a) (lazy calculation)

5. Practical skills for performance optimization

Avoid duplicate copying in loops

# Inefficient writingfor _ in range(1000):
    new_list = old_list.copy()
    process(new_list)
 
# Efficient writing method (pre-created)new_list = old_list.copy()
for _ in range(1000):
    new_list[:] = old_list  # Modify in place    process(new_list)

Using analysis memory

import sys
a = [1,2,3]
print((a))  # The size of the output list object itself（No elements）

Optimize memory layout with __slots__

class MyList:
    __slots__ = ('data',)
    def __init__(self, data):
         = data

For NumPy arrays, use views instead of copies

import numpy as np
arr = ([1,2,3])
view = arr[::2]  # Create a view（Do not copy data）

6. Common traps and solutions

Accidentally modify the original list

a = [[1,2], [3,4]]
b = a[:]
b[0][0] = 99  # Modified at the same timeaandb

Solution: Use deep copy or immutable data types

Memory leak risk

def process():
    data = [i for i in range(10**6)]
    return data  # Large objects have not been recycled in time

Solution: Use context manager or explicitly delete references

Repeated creation in a loop

result = []
for item in large_list:
    temp = []  # Create a new list every time the loop    # deal with...    (temp)

Solution: Preallocate list size

Conclusion: The balance of art of assignment

The performance selection of list assignment is essentially a ternary balance of time-space-function:

• Requires extreme speed → Direct assignment (note side effects)
• Requires data security → Deep copy (accepts performance loss)
• General Scene → Slice Operation (Optimal Balance Point)

Remember: there is no absolute best method, only the choice that is most suitable for specific scenarios. When writing critical path code, it is recommended:

• Use timeit for actual benchmarking
• Use memory_profiler to analyze memory usage
• Prioritize code readability unless performance becomes a bottleneck

By understanding the underlying mechanisms of these assignment methods, you can make smarter choices in Python programming to make your code efficient and safe.

This is the end of this article about six core methods of Python list assignment. For more related content on Python list assignment, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!