We call them references. They work like this

i = 5     # create int(5) instance, bind it to ij = i     # bind j to the same int as ij = 3     # create int(3) instance, bind it to jprint i   # i still bound to the int(5), j bound to the int(3)

Small ints are interned, but that isn't important to this explanation

i = [1,2,3]   # create the list instance, and bind it to ij = i         # bind j to the same list as ii[0] = 5      # change the first item of iprint j       # j is still bound to the same list as i

Variables are not pointers. When you assign to a variable you are binding the name to an object. From that point onwards you can refer to the object by using the name, until that name is rebound.

In your first example the name i is bound to the value 5. Binding different values to the name j does not have any effect on i, so when you later print the value of i the value is still 5.

In your second example you bind both i and j to the same list object. When you modify the contents of the list, you can see the change regardless of which name you use to refer to the list.

Note that it would be incorrect if you said "both lists have changed". There is only one list but it has two names (i and j) that refer to it.

Related documentation

• Execution Model - Naming and Binding

Python variables are names bound to objects

From the docs:

Names refer to objects. Names are introduced by name binding operations. Each occurrence of a name in the program text refers to the binding of that name established in the innermost function block containing the use.

When you do

i = 5j = i

that's the same as doing:

i = 5j = 5

j doesn't point to i, and after the assignment, j doesn't know that i exists. j is simply bound to whatever i was pointing to at the time of assignment.

If you did the assignments on the same line, it would look like this:

i = j = 5

And the result would be exactly the same.

Thus, later doing

i = 3

doesn't change what j is pointing to - and you can swap it - j = 3 would not change what i is pointing to.

Your example doesn't remove the reference to the list

So when you do this:

i = [1,2,3]j = i

It's the same as doing this:

i = j = [1,2,3]

so i and j both point to the same list. Then your example mutates the list:

i[0] = 5

Python lists are mutable objects, so when you change the list from one reference, and you look at it from another reference, you'll see the same result because it's the same list.