• d.pop(key) -- consider using this if you need the value for the item being deleted, and/or you want to specify a default value and don't want an exception raised if the key doesn't exist.
  e.g., value = d.pop(key, None)
• del key -- consider using this if you are certain that the key exists (or you expect an exception if it doesn't), and you don't need the value of the item being deleted.
  e.g., del key

From the official Python language documentation:

del d[key] Remove d[key] from d. Raises a KeyError if key is not in the map.

pop(key[, default]) If key is in the dictionary, remove it and return its value, else return default. If default is not given and key is not in the dictionary, a KeyError is raised.

https://docs.python.org/3/library/stdtypes.html#mapping-types-dict

Popping a dictionary element returns the value to which the key points to. It also deletes it afterward.

Good question! A simple difference is pop() returns the item removed so it can be assigned a different label while del simply removes the item. If you use pop() and do not assign a new label to the returned object it is essentially performing the same function as del. The list of book title strings is actually a list of references that point to string objects stored in memory. Each string object "id" is the address in memory of the stored object. ```python b1 = "book title 1" b2 = "book title 2" b3 = "book title 3" b4 = "book title 4" book_list = [b1, b2, b3, b4] print(book_list) ['book title 1', 'book title 2', 'book title 3', 'book title 4'] print([id(b1), id(b2), id(b3, id(b4)]) [139996358750368, 139996358750256, 139996358750592, 139996358750648] print([id(book) for book in book_list]) [139996358750368, 139996358750256, 139996358750592, 139996358750648] saved = book_list.pop(0) print(saved) book title 1 print(id(saved)) 139996358750368 ``` In a more detailed look, pop() returns the "id" reference removed so that it can be assigned to another label or used in a subsequent statement. The label saved is assigned to the first book popped from the book list. So, use pop() when you want to have access to the removed item for another purpose, and use del when you no longer want the item. Edit: to comment on “garbage collection”. Garbage collection happens when an object is removed from memory and the memory freed for other uses. This occurs when all references to an object are removed. pop() removed the list’s reference to object (count goes down by 1). If count is now zero, object maybe garbage collected. If a label is assigned to the popped object, this adds a new reference (count goes up by 1). So labeling a pop becomes a wash (no net change in reference count). del removes the label (the count goes down by 1) but not the object. Using del b4 simply removes the label b4 but not the object referenced by b4 since the string “book title 4” is still referenced by the list. Post back if you have more questions. Good luck!!

I would not worry about the performance differences unless you have specific reason to believe that they are causing meaningful slowdowns in your program, which is unlikely.

The real reason you might choose to use del vs pop is because they have different behaviors. pop returns the value for the popped key, so you would use pop if you want to do something with that value at the same time as you remove it. If you don't need to do anything with the value, but just want to remove the item, use del.

You can use remove():

data = { "computers": [
    {"Netbios_Name0": "apple1", "User_Domain0": "paradise", "User_Name0": "adam", "SMS_Installed_Sites0": "heaven", "Client_Version0": "5.00.9058.1018"}, 
    {"Netbios_Name0": "apple2", "User_Domain0": "paradise", "User_Name0": "lilith", "SMS_Installed_Sites0": "heaven", "Client_Version0": "5.00.9040.1044"}, 
    {"Netbios_Name0": "apple3", "User_Domain0": "paradise", "User_Name0": "eve", "SMS_Installed_Sites0": "heaven", "Client_Version0": "5.00.9068.1026"}
]}

for item in list(data['computers']):
    if 'apple2' in item['Netbios_Name0']:
        data['computers'].remove(item)
data

Output:

{'computers': [{'Netbios_Name0': 'apple1',
   'User_Domain0': 'paradise',
   'User_Name0': 'adam',
   'SMS_Installed_Sites0': 'heaven',
   'Client_Version0': '5.00.9058.1018'},
  {'Netbios_Name0': 'apple3',
   'User_Domain0': 'paradise',
   'User_Name0': 'eve',
   'SMS_Installed_Sites0': 'heaven',
   'Client_Version0': '5.00.9068.1026'}]}

The del statement removes an element:

del d[key]

Note that this mutates the existing dictionary, so the contents of the dictionary changes for anybody else who has a reference to the same instance. To return a new dictionary, make a copy of the dictionary:

def removekey(d, key):
    r = dict(d)
    del r[key]
    return r

The dict() constructor makes a shallow copy. To make a deep copy, see the copy module.

---

Note that making a copy for every dict del/assignment/etc. means you're going from constant time to linear time, and also using linear space. For small dicts, this is not a problem. But if you're planning to make lots of copies of large dicts, you probably want a different data structure, like a HAMT (as described in this answer).