All variables in Python are references. Elementary data types aren't an exception.

In the first example, you reassign b. It no longer references the same object as a.

In the second example, you modify b. Since you've previously set a and b to be references to the same object, the modification applies to a as well.

In Python a variable is not a box that holds things, it is a name that points to an object. In your code:

• d = { 'm': [1,2,3] } --> binds the name d to a dictionary
• m = d['m'] --> binds the name m to a list
• m = m[1:] --> binds the name m to another list

Your third line is not changing m itself, but what m is pointing to.

To edit the elements in the list what you can do is:

m = d['m']
for i, item in enumerate(m):
    result = do_something_with(item)
    m[i] = result

Your original question is really asking about two different things.

The first is this, with some annotation - you ask about lists. Lists are objects that are mutable sequences, and in your code, v and v2 always refer to the same list. You can modify the contents of the list using any referrer to it and those changes are visible to anything that refers to it.

v = [0,0,0,0] # create a list object and assign reference to v

v2 = v        # assign v2 to be the reference to list v also refers to

v[0]=5        # modify first list element

print(v2)     # print the list v2 refers to, which is the same list v refers to

In the second piece of code you show, you're changing what a variable refers to, rather than changing the underlying value of an object.

a=5      # Assign a to be a reference to 5

b=a      # Assign b to be a reference to the thing a refers to

a=6      # Re-assign a to refer to 6, a now refers to a different object than b

print(b) # b still refers to 5

And you pointed out the use of id. I will also introduce sys.getrefcount() which lets you see what the reference count for any particular object is, so we can see that, say, v's referred-to list has multiple things referring to it.

import sys

v = [0,0,0,0] 

v2 = v        

v[0]=5        

print(f"id(v) = {id(v)}")
print(f"id(v2) = {id(v2)}")

# this shows 3 instead of 2 because getrefcount(x)
# increases refcount of x by 1
print(f"v referrers: {sys.getrefcount(v)}")

del v2 # remove v2 as a reference

# and this will show 2 because v2 doesn't
# exist/doesn't refer to it anymore
print(f"v referrers: {sys.getrefcount(v)}")

a = 5
b = 5
print(f"id(a) = {id(a)}")
print(f"id(b) = {id(b)}")

# you're reassigning a here, so the id will change
# but you didn't change what b refers to
a = 6
print(f"id(a) = {id(a)}")
print(f"id(b) = {id(b)}")

And the output of this would look something like this...

id(v) = 4366332480
id(v2) = 4366332480
v referrers: 3
v referrers: 2

id(a) = 4365582704
id(b) = 4365582704
id(a) = 4365582736
id(b) = 4365582704

And as I mentioned - CPython does some special stuff for numbers in the range of [-5, 256] and keeps a static list of them in memory, so id on any integer in that range should return the same value for any referrers to them.