Why does python append to all lists instead one when using one line list declaration(this: a = b = c = [])?

Question

Python appends to all lists(like they are different pointer for the same memory address) when decalred with one line syntax(this: a = b = c []) but no such case with non-iterables or seperate declaration.

Same thing was causing a bug in my program when I used append()
and after some(a lot) debugging I found that this was causing the bug.

Example code with output:

a = b = c = []
a.append(1)
b.append(2)

print("1st", a, b, c)
# Output: 1st [1, 2] [1, 2] [1, 2]

# But not with some other types or when reassigned
# Reassigning list
a = b = c = []
a = [1, 2, 3]

print("2nd", a, b, c)
# Output:2nd [1, 2, 3] [] []

# Multi-line for control
a = []
b = []
c = []
a.append(1)
b.apend(2)

print("3rd", a, b, c)
# Output:3rd [1] [2] []

Seperate output of program

Output:
1st [1, 2] [1, 2] [1, 2]
2nd [1, 2, 3] [] []
3rd [1] [2] []

Are the lists something like different references but to the same memory address when assigned with one line syntax.

There aren't three lists, there's one list with three names. — hobbs, May 16 '19 at 19:00
Lists are references. Your variables all reference one list. — mVChr, May 16 '19 at 19:02
@Amiy: It happens with integers too. There's just no way to modify an integer, so you don't notice. — user2357112, May 16 '19 at 19:03
@mVChr no they are *lists*. *All variables* act like references in Python, regardless of the type of object they *happen* to be referring to. — juanpa.arrivillaga, May 16 '19 at 19:03
Yes, that's what I said. Lists are references. Your variables all reference one list. — mVChr, May 16 '19 at 19:04
If you will *replace* the reference to the list like you do it with an integer it would work as well. But you are *modifying` the list. — Klaus D., May 16 '19 at 19:04
@mVChr *no*, `list` objects **are not references**. They *are lists*. — juanpa.arrivillaga, May 16 '19 at 19:05
Read the following: https://nedbatchelder.com/text/names.html — juanpa.arrivillaga, May 16 '19 at 19:12

Christopher Nuccio · Accepted Answer · 2019-05-16T19:08:58.380

2

a = b = c = []  # a, b, and c are assigned to the same list

The first is assigning those 3 variable names to the same list. Both appends are appending to the same list.

a = [1, 2, 3]  # a is assigned to a new list

In the second, a is getting assigned to a new list [1,2,3].

a = []  # a gets its own list
b = []  # b gets its own list
c = []  # c gets its own list

In the third, a b c are each assigned to their own lists.

edited May 16 '19 at 19:08

answered May 16 '19 at 19:03

Christopher Nuccio

596
1
9
21

Thanks, I was thinking something similar that all lists point to same object when assigned with in line. – AVX-42 May 16 '19 at 19:10
You're welcome! :) – Christopher Nuccio May 16 '19 at 19:10

score 1 · Answer 2 · answered May 16 '19 at 19:12

1

like they are different pointer for the same memory address

They are, that is how python works in this instance.

answered May 16 '19 at 19:12

Zac Wimer

89
5

score -2 · Answer 3 · answered May 16 '19 at 19:03

-2

list instances are mutable, so the line

a = b = c = []

creates one list which is accessible through 3 different names.

This is not the case with non-mutable data structures (tuple, int, str).

answered May 16 '19 at 19:03

Ralf

16,086
4
44
68

3

Mutability is totally irrelevant. All Python objects have exactly the same semantics when it comes to assignment. Immutable types *simply don't expose mutator methods*. – juanpa.arrivillaga May 16 '19 at 19:04

Why does python append to all lists instead one when using one line list declaration(this: a = b = c = [])?

3 Answers3