9

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?

Martijn Pieters
  • 1,048,767
  • 296
  • 4,058
  • 3,343
eagertoLearn
  • 9,772
  • 23
  • 80
  • 122

1 Answers1

15

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.

Martijn Pieters
  • 1,048,767
  • 296
  • 4,058
  • 3,343
  • 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? – eagertoLearn Dec 30 '13 at 20:52
  • That is correct; those indices are references that are being removed from the list. – Martijn Pieters Dec 30 '13 at 20:57
  • `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. – Martijn Pieters Dec 30 '13 at 20:58