Why Does Modifying a Nested List in Python Unexpectedly Affect All Sublists?

Nested List Mutations: Understanding Unexpected Behavior

In Python, mutable data structures such as lists can behave unexpectedly when it comes to nesting. Consider the example where a list of lists is created:

xs = [[1] * 4] * 3

This initializes a nested list structure where each sublist contains four elements set to 1. However, modifying one of these innermost values, as shown below:

xs[0][0] = 5

affects all the first elements of every sublist, resulting in:

[[5, 1, 1, 1], [5, 1, 1, 1], [5, 1, 1, 1]]

Cause of the Unexpected Behavior

The root of the issue lies in how the * operator works when applied to objects. In this case, the line:

[[1] * 4] * 3

creates three references to the same sublist [1] 4, rather than creating three independent copies. This is because operates on the result of evaluating the expression [1] * 4, which is a single sublist. As a result, any changes to this single sublist are reflected across all references.

Resolving the Issue

To create independent sublists, it's necessary to force an evaluation of the [1] * 4 expression for each sublist. This can be achieved using a list comprehension, as seen below:

[[1]*4 for _ in range(3)]

In this case, the [1]*4 expression is evaluated every time, resulting in the creation of three distinct sublists, and any changes to one sublist will only affect that sublist and not the others.

The above is the detailed content of Why Does Modifying a Nested List in Python Unexpectedly Affect All Sublists?. For more information, please follow other related articles on the PHP Chinese website!