ChatGPT解决这个技术问题 Extra ChatGPT

How can I remove a key from a Python dictionary?

Is there a one-line way of deleting a key from a dictionary without raising a KeyError?

if 'key' in my_dict:
    del my_dict['key']
Benchmark script for the various methods proposed in the answers to this question: gist.github.com/zigg/6280653
Does this answer your question? Delete an element from a dictionary

A
Ann Zen

To delete a key regardless of whether it is in the dictionary, use the two-argument form of dict.pop():

my_dict.pop('key', None)

This will return my_dict[key] if key exists in the dictionary, and None otherwise. If the second parameter is not specified (i.e. my_dict.pop('key')) and key does not exist, a KeyError is raised.

To delete a key that is guaranteed to exist, you can also use:

del my_dict['key']

This will raise a KeyError if the key is not in the dictionary.


Sometimes an advantage of using pop() over del: it returns the value for that key. This way you can get and delete an entry from a dict in one line of code.
In the question it is not required to keep the value. This would only add unneeded complexity. The answer from @zigg (below) is much better.
@SalvatoreCosentino I can't follow your argument. How is the code in this answer more complex than the code in in the other answer?
@SalvatoreCosentino No, ignoring the return value of a function is not inefficient at all. Quite the opposite – this solution is much faster than the try/except solution if the key does not exist. You might find one or the other easier to read, which is fine. Both are idiomatic Python, so choose whatever you prefer. But claiming that this answer is more complex or inefficient simply makes no sense.
@user5359531 I don't understand. How is this a problem? None of the methods on Python's built-in types returns self, so it would be rather surprising if this one did.
B
Boris Verkhovskiy

Specifically to answer "is there a one line way of doing this?"

if 'key' in my_dict: del my_dict['key']

...well, you asked ;-)

You should consider, though, that this way of deleting an object from a dict is not atomic—it is possible that 'key' may be in my_dict during the if statement, but may be deleted before del is executed, in which case del will fail with a KeyError. Given this, it would be safest to either use dict.pop or something along the lines of

try:
    del my_dict['key']
except KeyError:
    pass

which, of course, is definitely not a one-liner.


Yeah, pop is a definitely more concise, though there is one key advantage of doing it this way: it's immediately clear what it's doing.
The try/except statement is more expensive. Raising an exception is slow.
@ChrisBarker I've found if the key exists, try is marginally faster, though if it doesn't, try is indeed a good deal slower. pop is fairly consistent but slower than all but try with a non-present key. See gist.github.com/zigg/6280653. Ultimately, it depends on how often you expect the key to actually be in the dictionary, and whether or not you need atomicity—and, of course, whether or not you're engaging in premature optimization ;)
I believe the value of clarity should not be overlooked. +1 for this.
regarding expense of try/except, you can also go if 'key' in mydict: #then del.... I needed to pull out a key/val from a dict to parse correctly, pop was not a perfect solution.
P
Peter Mortensen

It took me some time to figure out what exactly my_dict.pop("key", None) is doing. So I'll add this as an answer to save others googling time:

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.

Documentation


Just type help(dict.pop) in the python interpreter.
help() and dir() can be your friends when you need to know what something does.
or dict.pop? in IPython.
B
Boris Verkhovskiy

del my_dict[key] is slightly faster than my_dict.pop(key) for removing a key from a dictionary when the key exists

>>> import timeit
>>> setup = "d = {i: i for i in range(100000)}"

>>> timeit.timeit("del d[3]", setup=setup, number=1)
1.79e-06
>>> timeit.timeit("d.pop(3)", setup=setup, number=1)
2.09e-06
>>> timeit.timeit("d2 = {key: val for key, val in d.items() if key != 3}", setup=setup, number=1)
0.00786

But when the key doesn't exist if key in my_dict: del my_dict[key] is slightly faster than my_dict.pop(key, None). Both are at least three times faster than del in a try/except statement:

>>> timeit.timeit("if 'missing key' in d: del d['missing key']", setup=setup)
0.0229
>>> timeit.timeit("d.pop('missing key', None)", setup=setup)
0.0426
>>> try_except = """
... try:
...     del d['missing key']
... except KeyError:
...     pass
... """
>>> timeit.timeit(try_except, setup=setup)
0.133

@Boris - this is useful as a general exercise.
@daisy what I'm saying is that you should choose the most readable syntax not the operation that is 300 nanoseconds faster (that's literally the difference between del and pop from the first set of timings above)
Also these operations are so fast that these timings aren't reliable.
M
Marc Maxmeister

If you need to remove a lot of keys from a dictionary in one line of code, I think using map() is quite succinct and Pythonic readable:

myDict = {'a':1,'b':2,'c':3,'d':4}
map(myDict.pop, ['a','c']) # The list of keys to remove
>>> myDict
{'b': 2, 'd': 4}

And if you need to catch errors where you pop a value that isn't in the dictionary, use lambda inside map() like this:

map(lambda x: myDict.pop(x,None), ['a', 'c', 'e'])
[1, 3, None] # pop returns
>>> myDict
{'b': 2, 'd': 4}

or in python3, you must use a list comprehension instead:

[myDict.pop(x, None) for x in ['a', 'c', 'e']]

It works. And 'e' did not cause an error, even though myDict did not have an 'e' key.


This will not work in Python 3 because map and friends are now lazy and return iterators. Using map for side-effects is generally considered poor practice; a standard for ... in loop would be better. See Views And Iterators Instead Of Lists for more information.
Regardless of taste and practice style, list comprehensions should still work in Py3 [myDict.pop(i, None) for i in ['a', 'c']], as they offer a general alternative to map (and filter).
@MichaelEkoka you shouldn't use list comprehensions for their side effects, use a regular for ... in loop.
@Boris You're probably right. My answer is specifically pertaining to using map(), which is often used for its side-effects. The recommended alternative in Python is the list comprehension, which in my opinion is still quite readable and cognitively light as a one-liner (see question). Used only for their side-effects, both constructs indeed result in a useless list, which can be inefficient. As of Python3, I'm not aware of a built-in function that can safely and elegantly iterate through a generator expression, without a costly byproduct e.g. loop(d.pop(k) for k in ['a', 'b']).
@MichaelEkoka the "builtin function" is a for loop: for k in ['a', 'b']: d.pop(k). Why do you need a different way to do it? If you need it to take up only one line that badly then you can put the second part of the for loop on the same line.
B
Boris Verkhovskiy

You can use a dictionary comprehension to create a new dictionary with that key removed:

>>> my_dict = {k: v for k, v in my_dict.items() if k != 'key'}

You can delete by conditions. No error if key doesn't exist.


This answer is different than the others because it has no side-effects (it does not mutate the original dictionary).
While this is probably the way I would do it aswell, this makes a whole new dictionary in memory, copying (references to) objects to the new dictionary. It then saves it onto the old name. For big dictionaries this can take some time. del dict[key] or dict.pop(key) will be faster in all cases.
del and pop are faster, but sometimes you just don't want to modify the original dictionary. It would make more sense if in the example above, the comprehension result was assigned to another variable.
P
Peter Mortensen

Using the "del" keyword:

del dict[key]

M
M.Innat

We can delete a key from a Python dictionary by the some of the following approaches.

Using the del keyword; it's almost the same approach like you did though -

 myDict = {'one': 100, 'two': 200, 'three': 300 }
 print(myDict)  # {'one': 100, 'two': 200, 'three': 300}
 if myDict.get('one') : del myDict['one']
 print(myDict)  # {'two': 200, 'three': 300}

Or

We can do like the following:

But one should keep in mind that, in this process actually it won't delete any key from the dictionary rather than making a specific key excluded from that dictionary. In addition, I observed that it returned a dictionary which was not ordered the same as myDict.

myDict = {'one': 100, 'two': 200, 'three': 300, 'four': 400, 'five': 500}
{key:value for key, value in myDict.items() if key != 'one'}

If we run it in the shell, it'll execute something like {'five': 500, 'four': 400, 'three': 300, 'two': 200} - notice that it's not the same ordered as myDict. Again if we try to print myDict, then we can see all keys including which we excluded from the dictionary by this approach. However, we can make a new dictionary by assigning the following statement into a variable:

var = {key:value for key, value in myDict.items() if key != 'one'}

Now if we try to print it, then it'll follow the parent order:

print(var) # {'two': 200, 'three': 300, 'four': 400, 'five': 500}

Or

Using the pop() method.

myDict = {'one': 100, 'two': 200, 'three': 300}
print(myDict)

if myDict.get('one') : myDict.pop('one')
print(myDict)  # {'two': 200, 'three': 300}

The difference between del and pop is that, using pop() method, we can actually store the key's value if needed, like the following:

myDict = {'one': 100, 'two': 200, 'three': 300}
if myDict.get('one') : var = myDict.pop('one')
print(myDict) # {'two': 200, 'three': 300}
print(var)    # 100

Fork this gist for future reference, if you find this useful.


Don't use if myDict.get('one') to check if a key is present! It fails if myDict['one'] has a falsey value. Also, dicts don't have an inherent order, so it doesn't make sense to mention it.
@Rob dicts are ordered by insertion order starting with CPython 3.6 and all other Python implementations starting with 3.7.
A
Alec

You can use exception handling if you want to be very verbose:

try: 
    del dict[key]

except KeyError: pass

This is slower, however, than the pop() method, if the key doesn't exist.

my_dict.pop('key', None)

It won't matter for a few keys, but if you're doing this repeatedly, then the latter method is a better bet.

The fastest approach is this:

if 'key' in dict: 
    del myDict['key']

But this method is dangerous because if 'key' is removed in between the two lines, a KeyError will be raised.


A
Anshika Singh

Dictionary data type has a method called dict_name.pop(item) and this can be used to delete a key:value pair from a dictionary.

a={9:4,2:3,4:2,1:3}
a.pop(9)
print(a)

This will give the output as:

{2: 3, 4: 2, 1: 3}

This way you can delete an item from a dictionary in one line.


P
Peter Mortensen

Another way is by using items() + dict comprehension.

items() coupled with dict comprehension can also help us achieve the task of key-value pair deletion, but it has the drawback of not being an in place dict technique. Actually a new dict if created except for the key we don’t wish to include.

test_dict = {"sai" : 22, "kiran" : 21, "vinod" : 21, "sangam" : 21}

# Printing dictionary before removal
print ("dictionary before performing remove is : " + str(test_dict))

# Using items() + dict comprehension to remove a dict. pair
# removes  vinod
new_dict = {key:val for key, val in test_dict.items() if key != 'vinod'}

# Printing dictionary after removal
print ("dictionary after remove is : " + str(new_dict))

Output:

dictionary before performing remove is : {'sai': 22, 'kiran': 21, 'vinod': 21, 'sangam': 21}
dictionary after remove is : {'sai': 22, 'kiran': 21, 'sangam': 21}

this doesn't actually do what is asked - it creates a new dict with the unwanted keys removed. Furthermore, iterating over all keys to delete one is doing an O(1) operation in O(N) time.
A
Abhishek

just create a copy of your dictionary .

newMy_dict = my_dict.copy()
if 'key' in newMy_dict :
    del newMy_dict['key']

This way , you can control exception.


C
CervEd

I prefer the immutable version

foo = {
    1:1,
    2:2,
    3:3
}
removeKeys = [1,2]
def woKeys(dct, keyIter):
    return {
        k:v
        for k,v in dct.items() if k not in keyIter
    }

>>> print(woKeys(foo, removeKeys))
{3: 3}
>>> print(foo)
{1: 1, 2: 2, 3: 3}

Z
ZenG

Single filter on key

return "key" and remove it from my_dict if "key" exists in my_dict

return None if "key" doesn't exist in my_dict

this will change my_dict in place (mutable)

my_dict.pop('key', None)

Multiple filters on keys

generate a new dict (immutable)

dic1 = {
    "x":1,
    "y": 2,
    "z": 3
}

def func1(item):
    return  item[0]!= "x" and item[0] != "y"

print(
    dict(
        filter(
            lambda item: item[0] != "x" and item[0] != "y", 
            dic1.items()
            )
    )
)

U
U12-Forward

You could also use filter with lambda:

>>> d = {'a': 1, 'b': 2, 'c': 3}
>>> dict(filter(lambda x: x[0] != 'a', d.items()))
{'b': 2, 'c': 3}
>>>

Right, but this create new obj, so my_dict.pop('key', None) is the best answer
m
muTheTechie

Try this

if key in data:
   del data[key]