How does del operator work in list in python?

Question

I have read the python docs for list and how the del operators works, but I need explanation for the following behavior

In this case, c and l points to the same object(list), so doing changes on one affects the other, but deleting one does not delete the object. So what happens here? Is it just the pointer to the list object is lost?

>>> l = [1,2,3]
>>> c = l
>>> c.append(4)
>>> c
[1, 2, 3, 4]
>>> l
[1, 2, 3, 4]
>>> del c
>>> l
[1, 2, 3, 4]
>>> c
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'c' is not defined

Deletion by slice operation

>>> l
[1, 2, 3, 4]
>>> del l[::2]
>>> l
[2, 4]

l[::2] returns the new list. but del l[::2] does in-place deletion. So in this case, is not a new list being returned? What exactly is happening here?

Decoration

Answer 1

l and c are bound to the same object. They both are references to a list, and manipulating that list object is visible through both references. del c unbinds c; it removes the reference to the list.

del l[::2] removes a specific set of indices from the list, you are now operating on the list object itself. You are not unbinding l, you are unbinding indices inside of the list.

You can compare this with retrieving and setting values as well. print c is different from print c[::2] and c = something is different from c[::2] = something; the first of both examples accesses just the list object, or assign a new value to c, the latter examples retrieve a slice of values or set new values to the sliced indices.

Under the hood, del c removes the name c from the dictionary handling all variables (globals() gives you a reference to this dictionary). del l[::2] calls the __delitem__ special method on the list, passing in a slice() object.

Interclavicle

I understand print c is different from print c[::2] because in the latter case, a new list object is returned. Now your explanation for __delitem__, passing the slice object makes perfect sense. but wondering, the corresponding indices have to de-reference those items, before shifting elements to the left..correct? – Decoration

That is correct; those indices are references that are being removed from the list. – Interclavicle

print c[::2] is translated as c.__getitem__(slice(None, None, 2)), which can return whatever it likes. A list returns a new list with values, yes. – Interclavicle