0

Today, I uncovered a surprise in using repeat expression to initialize a list of lists. Although the resulted piece of data appeared to be like a list of lists initialized, when I start to modify an element in the data, the modification is duplicated across all lists (rows) that have been repeated. This could result in a nasty bug if one does not watch the actual behavior of the operation!

Here is distilled example code to demonstrate the problem.

When x is constructed as a list of lists and initialized, modifying one of its element only has the effect to that element. 

x = [[0,0],
     [0,0],
     [0,0]]                     # initialized as array of arrays
x0 = x[0]                       # x0 = [0, 0]
x1 = x[1]                       # x1 = [0, 0]
x2 = x[2]                       # x2 = [0, 0]

x[0][0] = 1                     # modify the element at row 0, and column 0
x0 = x[0]                       # x0 = [1, 0]
x1 = x[1]                       # x1 = [0, 0]
x2 = x[2]                       # x2 = [0, 0]

But when a seemingly the same list of lists is constructed using repeat operations, the resulted data is not really a list of lists, but just appeared to be one with the initialized constant. Once modifying one of the element, the modification would be duplicated to all the arrays (rows) of the data. 

x = [[0]*2]*3              # initialized by repeat expression
# appearing of the same values of the above array of arrays
x0 = x[0]                  # x0 = [0, 0]
x1 = x[1]                  # x1 = [0, 0]
x2 = x[2]                  # x2 = [0, 0]

x[0][0] = 1                # modify the element at row 0, and column 0
x0 = x[0]                  # x0 = [1, 0] as expected
x1 = x[1]                  # x1 = [1, 0] not as expected!
x2 = x[2]                  # x2 = [1, 0] not as expected!
# It seems that the repeated expression is of the same copy of storage!
# referred by the same label/address

Furthermore, the behavior for the one-dimensional array would be different:

x = [0]*3
x0 = x[0]                       # x0 = 0
x1 = x[1]                       # x1 = 0
x2 = x[2]                       # x2 = 0
x[0] = 1
x0 = x[0]                       # x0 = 1
x1 = x[1]                       # x1 = 0
x2 = x[2]                       # x2 = 0

It might be a clever optimization.

But the moral of the story that I need to be cautious about Python's lack of consistency. In particular, the repeat expression is only meant for a constant value, never for mutable operations.

I wonder how I can learn more about those exceptional inconsistent nuances in Python?

Yu Shen
  • 2,770
  • 3
  • 33
  • 48
  • 2
    What lack of consistency? Firstly, you are *not* using arrays here, you are using `list` objects, which *do no have dimensions*. Fundamentally, this is all *very consistent* with the actual semantics of Python. It just seems you expect Python to have a different semantics than what it actually has – juanpa.arrivillaga Mar 02 '18 at 00:35
  • Thanks for correcting me. I was expecting x[0][0] = 1 should have the same outcome regardless how x is constructed as long as they have the same value. I argue that it would be much more consistent for programming. – Yu Shen Mar 02 '18 at 00:46
  • I also hope to learn more of any other nuances of Python that may not be intuitive or straightforward. Some pointers would do. – Yu Shen Mar 02 '18 at 00:48
  • It *does* have the same effect, you are simply not understanding how values work in Python. In one case, your values *are all the same list*, in the other, the values ar several *different lists*. Read this: https://nedbatchelder.com/text/names.html – juanpa.arrivillaga Mar 02 '18 at 00:50
  • Thanks for the link! Will study. – Yu Shen Mar 02 '18 at 00:54
  • Note, the way the repetition operator, `*` , works is very consistent. `sub = [x]` then `sub*2` will result in `[x, x]` where x is *the same object*, just as if you would have done `sub + sub` with the concatenation operator. In other words, `sequence*n` is the same as `sequence + sequence + ... + sequence` – juanpa.arrivillaga Mar 02 '18 at 00:56

0 Answers0