Reference Traps in Python List Initialization: Why [[]]*n Creates Linked Lists

Problem Phenomenon and Background

In Python programming, developers often need to initialize list structures containing multiple empty lists. A seemingly intuitive approach is using the x = [[]] * n syntax, expecting to get n independent empty lists. However, the actual results are surprising:

>>> x = [[]] * 3
>>> x[1].append(0)
>>> x
[[0], [0], [0]]

The developer originally expected [[], [0], []], but all sublists contain the same elements. This phenomenon is quite common among Python beginners, and understanding its underlying mechanism is crucial for writing correct Python code.

Root Cause Analysis

The core of the problem lies in Python's object reference mechanism. When using the [[]] * n syntax, Python does not create n different list objects but creates a list containing n references, all pointing to the same list object.

From a memory perspective, this phenomenon can be verified:

In [20]: x = [[]] * 4
In [21]: [id(i) for i in x]
Out[21]: [164363948, 164363948, 164363948, 164363948]

All sublists have identical id values, confirming they are indeed the same object. This is similar to the following explicit code:

l = []
x = []
for i in range(n):
    x.append(l)

Regardless of which reference is used to modify the list content, the changes will be reflected in all variables referencing that object.

Correct Solution

To create truly independent list instances, list comprehensions should be used:

x = [[] for i in range(3)]

This method creates a new empty list during each iteration, ensuring each sublist is an independent object:

In [22]: x = [[] for i in range(4)]
In [23]: [id(i) for i in x]
Out[23]: [164382060, 164364140, 164363628, 164381292]

Each sublist has a different memory address, proving they are independent instances. This is equivalent to:

x = []
for i in range(n):
    x.append([])

Related Application Scenarios Extension

Similar reference issues also occur in other programming contexts. In web development, particularly in content management system (CMS) configurations, there are frequent needs to manage multiple independent data collections.

Referencing Webflow CMS configuration experiences, when developers attempt to nest the same data source into multiple different collections, they may encounter similar problems. If configured improperly, multiple collections might share the same data references, leading to unexpected data synchronization. The correct approach is to create separate configurations for each occasion requiring independent data instances or use appropriate copying mechanisms.

Similar patterns are also common in JavaScript web development:

// Wrong approach - all instances share the same configuration object
const config = {filters: []};
const instances = Array(3).fill(config);

// Correct approach - each instance has independent configuration
const instances = Array(3).fill().map(() => ({filters: []}));

Best Practice Recommendations

To avoid similar reference traps, developers are advised to:

1. Exercise caution when using multiplication operators to copy mutable objects
2. Prefer comprehensions or explicit loops for situations requiring independent instances
3. Add object identity verification at critical code points, such as using the id() function
4. Clearly define prevention measures for such traps in team coding standards

Understanding Python's reference mechanism not only helps avoid such errors but also enables developers to write more efficient and reliable code. This deep understanding of object references is an important foundation for becoming an advanced Python developer.