How do I delete an item from a dictionary in Python?
Without modifying the original dictionary, how do I obtain another dict with the item removed?
See also How can I remove a key from a Python dictionary? for the specific issue of removing an item (by key) that may not already be present.
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).
dict as you're looping through it, it'll give you an error: RuntimeError: dictionary changed size during iteration –
Gambetta pop method which in fact does the same? Isn't it more pythonic? (being dict's method, not special reserved word)? –
Raskin RuntimeError dictionary changed size during iteration see: https://mcmap.net/q/41195/-how-can-i-avoid-quot-runtimeerror-dictionary-changed-size-during-iteration-quot-error –
Iain d dictionary to d_copy: d = d_copy and then work over d_copy. What is the difference between this approach with respect to making a shallow copy (dict() constructor) or even making a deep copy ? –
Reconnoiter d_copy = d, you reference the same dictionary with a second name (so the id() of both is the same). when you d_copy = dict(d) you make a (shallow) copy and therefore another dict with the same content. so when you del in the first version, both d and d_copy are altered, in the second, they are not - unless you have a nested dict or something (like a list inside the dict), because the nested dict/list is the same for both again (because the content is another reference to the same dict/list)... and that's where copy.deepcopy() comes in. –
Fredrickafredrickson item to a dict|HashMap|table in each iteration inside a fn which is O(n) space complexity later on that fn I have another iteration which removed all item from the same dict will this be considered space constant ie O(1) ? –
Kaohsiung pop mutates the dictionary.
>>> lol = {"hello": "gdbye"}
>>> lol.pop("hello")
'gdbye'
>>> lol
{}
If you want to keep the original you could just copy it.
pop returns the value that was 'popped', which allows you to use this value for whatever further reason. If it's not more "Pythonic", I'd say that seems better, for sure :). It's not a dict, but it works the same way for both: github.com/ivanlmj/python-prototypes/blob/master/3.4/… –
Bullhead pop can be provided with a default value that will be returned when a key is missing from dict. It's good when you need to remove a few keys but some of them might be missing; del would throw KeyError in such case. –
Strata I think your solution is best way to do it. But if you want another solution, you can create a new dictionary with using the keys from old dictionary without including your specified key, like this:
>>> a
{0: 'zero', 1: 'one', 2: 'two', 3: 'three'}
>>> {i:a[i] for i in a if i!=0}
{1: 'one', 2: 'two', 3: 'three'}
{i:a[i] for i in a if i not in [0, 1, 2]} if you want to remove several elements. –
Krebs {k:v for k,v in a.items() if k != 0} I think. –
Confirm **kwargs, some_function(**{k:v for k,v in some_dict.items() if k not 'some_key'}) –
Litmus There're a lot of nice answers, but I want to emphasize one thing.
You can use both dict.pop() method and a more generic del statement to remove items from a dictionary. They both mutate the original dictionary, so you need to make a copy (see details below).
And both of them will raise a KeyError if the key you're providing to them is not present in the dictionary:
key_to_remove = "c"
d = {"a": 1, "b": 2}
del d[key_to_remove] # Raises `KeyError: 'c'`
and
key_to_remove = "c"
d = {"a": 1, "b": 2}
d.pop(key_to_remove) # Raises `KeyError: 'c'`
You have to take care of this:
by capturing the exception:
key_to_remove = "c"
d = {"a": 1, "b": 2}
try:
del d[key_to_remove]
except KeyError as ex:
print("No such key: '%s'" % ex.message)
and
key_to_remove = "c"
d = {"a": 1, "b": 2}
try:
d.pop(key_to_remove)
except KeyError as ex:
print("No such key: '%s'" % ex.message)
by performing a check:
key_to_remove = "c"
d = {"a": 1, "b": 2}
if key_to_remove in d:
del d[key_to_remove]
and
key_to_remove = "c"
d = {"a": 1, "b": 2}
if key_to_remove in d:
d.pop(key_to_remove)
but with pop() there's also a much more concise way - provide the default return value:
key_to_remove = "c"
d = {"a": 1, "b": 2}
d.pop(key_to_remove, None) # No `KeyError` here
Unless you use pop() to get the value of a key being removed you may provide anything, not necessary None.
Though it might be that using del with in check is slightly faster due to pop() being a function with its own complications causing overhead. Usually it's not the case, so pop() with default value is good enough.
As for the main question, you'll have to make a copy of your dictionary, to save the original dictionary and have a new one without the key being removed.
Some other people here suggest making a full (deep) copy with copy.deepcopy(), which might be an overkill, a "normal" (shallow) copy, using copy.copy() or dict.copy(), might be enough. The dictionary keeps a reference to the object as a value for a key. So when you remove a key from a dictionary this reference is removed, not the object being referenced. The object itself may be removed later automatically by the garbage collector, if there're no other references for it in the memory. Making a deep copy requires more calculations compared to shallow copy, so it decreases code performance by making the copy, wasting memory and providing more work to the GC, sometimes shallow copy is enough.
However, if you have mutable objects as dictionary values and plan to modify them later in the returned dictionary without the key, you have to make a deep copy.
With shallow copy:
def get_dict_wo_key(dictionary, key):
"""Returns a **shallow** copy of the dictionary without a key."""
_dict = dictionary.copy()
_dict.pop(key, None)
return _dict
d = {"a": [1, 2, 3], "b": 2, "c": 3}
key_to_remove = "c"
new_d = get_dict_wo_key(d, key_to_remove)
print(d) # {"a": [1, 2, 3], "b": 2, "c": 3}
print(new_d) # {"a": [1, 2, 3], "b": 2}
new_d["a"].append(100)
print(d) # {"a": [1, 2, 3, 100], "b": 2, "c": 3}
print(new_d) # {"a": [1, 2, 3, 100], "b": 2}
new_d["b"] = 2222
print(d) # {"a": [1, 2, 3, 100], "b": 2, "c": 3}
print(new_d) # {"a": [1, 2, 3, 100], "b": 2222}
With deep copy:
from copy import deepcopy
def get_dict_wo_key(dictionary, key):
"""Returns a **deep** copy of the dictionary without a key."""
_dict = deepcopy(dictionary)
_dict.pop(key, None)
return _dict
d = {"a": [1, 2, 3], "b": 2, "c": 3}
key_to_remove = "c"
new_d = get_dict_wo_key(d, key_to_remove)
print(d) # {"a": [1, 2, 3], "b": 2, "c": 3}
print(new_d) # {"a": [1, 2, 3], "b": 2}
new_d["a"].append(100)
print(d) # {"a": [1, 2, 3], "b": 2, "c": 3}
print(new_d) # {"a": [1, 2, 3, 100], "b": 2}
new_d["b"] = 2222
print(d) # {"a": [1, 2, 3], "b": 2, "c": 3}
print(new_d) # {"a": [1, 2, 3, 100], "b": 2222}
The del statement is what you're looking for. If you have a dictionary named foo with a key called 'bar', you can delete 'bar' from foo like this:
del foo['bar']
Note that this permanently modifies the dictionary being operated on. If you want to keep the original dictionary, you'll have to create a copy beforehand:
>>> foo = {'bar': 'baz'}
>>> fu = dict(foo)
>>> del foo['bar']
>>> print foo
{}
>>> print fu
{'bar': 'baz'}
The dict call makes a shallow copy. If you want a deep copy, use copy.deepcopy.
Here's a method you can copy & paste, for your convenience:
def minus_key(key, dictionary):
shallow_copy = dict(dictionary)
del shallow_copy[key]
return shallow_copy
>>> is often used in the python-examples? Yeah, python-doc contains a lot of such things. But such code is not convenient for copypaste. I am confused... –
Prisage >>> mimics the listening notation from python in cli mode –
Marji >>>. Yes, it is REPL-style, but let's talk frankly: the only one man had wrote this sample, and 1000 have read this. I think, it would be great to write examples in the way allowing easy copy and run. I don't like to remove this angle brackets by hand. Or copy line by line.. So I don't understand: why this angles are still there))) May be I don't know something? –
Prisage dict statement. –
Burgin … how can I delete an item from a dictionary to return a copy (i.e., not modifying the original)?
A dict is the wrong data structure to use for this.
Sure, copying the dict and popping from the copy works, and so does building a new dict with a comprehension, but all that copying takes time—you've replaced a constant-time operation with a linear-time one. And all those copies alive at once take space—linear space per copy.
Other data structures, like hash array mapped tries, are designed for exactly this kind of use case: adding or removing an element returns a copy in logarithmic time, sharing most of its storage with the original.1
Of course there are some downsides. Performance is logarithmic rather than constant (although with a large base, usually 32-128). And, while you can make the non-mutating API identical to dict, the "mutating" API is obviously different. And, most of all, there's no HAMT batteries included with Python.2
The pyrsistent library is a pretty solid implementation of HAMT-based dict-replacements (and various other types) for Python. It even has a nifty evolver API for porting existing mutating code to persistent code as smoothly as possible. But if you want to be explicit about returning copies rather than mutating, you just use it like this:
>>> from pyrsistent import m
>>> d1 = m(a=1, b=2)
>>> d2 = d1.set('c', 3)
>>> d3 = d1.remove('a')
>>> d1
pmap({'a': 1, 'b': 2})
>>> d2
pmap({'c': 3, 'a': 1, 'b': 2})
>>> d3
pmap({'b': 2})
That d3 = d1.remove('a') is exactly what the question is asking for.
If you've got mutable data structures like dict and list embedded in the pmap, you'll still have aliasing issues—you can only fix that by going immutable all the way down, embedding pmaps and pvectors.
1. HAMTs have also become popular in languages like Scala, Clojure, Haskell because they play very nicely with lock-free programming and software transactional memory, but neither of those is very relevant in Python.
2. In fact, there is an HAMT in the stdlib, used in the implementation of contextvars. The earlier withdrawn PEP explains why. But this is a hidden implementation detail of the library, not a public collection type.
immutables package is now available. –
Soni Using del you can remove a dict value passing the key of that value
Link: del method
del dictionary['key_to_del']
del rule['key_to_del']['nestedMapProp']. –
Infatuation d = {1: 2, '2': 3, 5: 7}
del d[5]
print 'd = ', d
Result: d = {1: 2, '2': 3}
Simply call del d['key'].
However, in production, it is always a good practice to check if 'key' exists in d.
if 'key' in d:
del d['key']
try-except block. At least, this will be an atomic operation;) –
Prisage d.pop('key', None) , it is oneliner. But the actual question was about getting the dictionary without one key, and not about modifying the dict. So comprehensions - is a good choice here;) –
Prisage No, there is no other way than
def dictMinus(dct, val):
copy = dct.copy()
del copy[val]
return copy
However, often creating copies of only slightly altered dictionaries is probably not a good idea because it will result in comparatively large memory demands. It is usually better to log the old dictionary(if even necessary) and then modify it.
# mutate/remove with a default
ret_val = body.pop('key', 5)
# no mutation with a default
ret_val = body.get('key', 5)
Here a top level design approach:
def eraseElement(d,k):
if isinstance(d, dict):
if k in d:
d.pop(k)
print(d)
else:
print("Cannot find matching key")
else:
print("Not able to delete")
exp = {'A':34, 'B':55, 'C':87}
eraseElement(exp, 'C')
I'm passing the dictionary and the key I want into my function, validates if it's a dictionary and if the key is okay, and if both exist, removes the value from the dictionary and prints out the left-overs.
Output: {'B': 55, 'A': 34}
Hope that helps!
info = {'country': 'Iran'}
country = info.pop('country') if 'country' in info else None
info = {'country': 'Iran'}
country = info.get('country') or None
>>> def delete_key(dict, key):
... del dict[key]
... return dict
...
>>> test_dict = {'one': 1, 'two' : 2}
>>> print delete_key(test_dict, 'two')
{'one': 1}
>>>
this doesn't do any error handling, it assumes the key is in the dict, you might want to check that first and raise if its not
del test_dict[key]? –
Riorsson Below code snippet will help you definitely, I have added comments in each line which will help you in understanding the code.
def execute():
dic = {'a':1,'b':2}
dic2 = remove_key_from_dict(dic, 'b')
print(dict2) # {'a': 1}
print(dict) # {'a':1,'b':2}
def remove_key_from_dict(dictionary_to_use, key_to_delete):
copy_of_dict = dict(dictionary_to_use) # creating clone/copy of the dictionary
if key_to_delete in copy_of_dict : # checking given key is present in the dictionary
del copy_of_dict [key_to_delete] # deleting the key from the dictionary
return copy_of_dict # returning the final dictionary
or you can also use dict.pop()
d = {"a": 1, "b": 2}
res = d.pop("c") # No `KeyError` here
print (res) # this line will not execute
or the better approach is
res = d.pop("c", "key not found")
print (res) # key not found
print (d) # {"a": 1, "b": 2}
res = d.pop("b", "key not found")
print (res) # 2
print (d) # {"a": 1}
Here's another variation using list comprehension:
original_d = {'a': None, 'b': 'Some'}
d = dict((k,v) for k, v in original_d.iteritems() if v)
# result should be {'b': 'Some'}
The approach is based on an answer from this post: Efficient way to remove keys with empty strings from a dict
For Python 3 this is
original_d = {'a': None, 'b': 'Some'}
d = dict((k,v) for k, v in original_d.items() if v)
print(d)
if v to if k is not 'a' answers the op. But i don't think that's an efficient way, this removes the element in O(n) rather than O(log n) as pop or del does. –
Mendelsohn species = {'HI': {'1': (1215.671, 0.41600000000000004),
'10': (919.351, 0.0012),
'1025': (1025.722, 0.0791),
'11': (918.129, 0.0009199999999999999),
'12': (917.181, 0.000723),
'1215': (1215.671, 0.41600000000000004),
'13': (916.429, 0.0005769999999999999),
'14': (915.824, 0.000468),
'15': (915.329, 0.00038500000000000003),
'CII': {'1036': (1036.3367, 0.11900000000000001), '1334': (1334.532, 0.129)}}
The following code will make a copy of dict species and delete items which are not in trans_HI
trans_HI=['1025','1215']
for transition in species['HI'].copy().keys():
if transition not in trans_HI:
species['HI'].pop(transition)
In Python 3, 'dict' object has no attribute 'remove'.
But with immutables package, can perform mutations that allow to apply changes to the Map object and create new (derived) Maps:
import immutables
map = immutables.Map(a=1, b=2)
map1 = map.delete('b')
print(map, map1)
# will print:
# <immutables.Map({'b': 2, 'a': 1})>
# <immutables.Map({'a': 1})>
TL;DR: Use either del dct[key_to_remove] or dct.pop(key_to_remove) to remove keys.
There are three main answers given on this page to remove a key from a dictionary dct:
d = dct.copy(); del d[key_to_remove]d = dct.copy(); d.pop(key_to_remove)d = {k:v for k,v in dct.items() if k != key_to_remove}While the third option is very easy to read, it is not only very slow (because it uses a Python loop while copy() is implemented in C)1, as the following memory tracing shows, it also has about 50% more peak memory usage than the other two options. This test uses a dictionary with 10,000 keys but the same difference holds for extremely large dictionaries as well. Tested on Python 3.12.0 on a Windows 10 AMD64 machine.
import tracemalloc
def pop_key(dct, key):
d = dct.copy()
d.pop(key)
return d
def del_key(dct, key):
d = dct.copy()
del d[key]
return d
def dict_comp(dct, key):
return {k: v for k,v in dct.items() if k!=key}
if __name__ == '__main__':
dct = {str(i): i for i in range(10000)}
key = "1"
for func in (dict_comp, pop_key, del_key):
tracemalloc.start()
x = func(dct, key)
size, peak = tracemalloc.get_traced_memory()
tracemalloc.stop()
print(f"{func.__name__:<9}: peak = {peak/1024:.3f} KB.")
dict_comp: peak = 304.117 KB.
pop_key : peak = 202.688 KB.
del_key : peak = 202.688 KB.
1 As the following timeit test shows, option 3 is about 10 times slower than the other two. The following test uses a dictionary with 10k keys but you can verify that the difference holds for much larger dictionaries as well.
if __name__ == '__main__':
dct = {str(i): i for i in range(10000)}
key = "1"
for func in (dict_comp, pop_key, del_key):
tm = min(timeit.repeat(lambda: func(dct, key), number=100))/100
print(f"{func.__name__:<9}: {tm:.6f} s")
dict_comp: 0.001415 s
pop_key : 0.000142 s
del_key : 0.000142 s
can try my method. In one line.
yourList = [{'key':'key1','version':'1'},{'key':'key2','version':'2'},{'key':'key3','version':'3'}]
resultList = [{'key':dic['key']} for dic in yourList if 'key' in dic]
print(resultList)
© 2022 - 2024 — McMap. All rights reserved.
popmethod changes the dictionary in-place. Therefore it alters the reference to the dictionary that was passed from the caller to the "helper function". So the "helper function" doesn't need to return anything, since the original reference to the dictionary in the caller will already be altered. Don't assign the return fromdict.pop()to anything if you don't need it. EG:do stuff with my_dict; my_dict.pop(my_key, None); do more stuff with my_dict # now doesn't have my_key. Usedeepcopy(my_dict)if needed. – Leadingd.pop(), I fixed the title to ask the question specified in the details. – Twobitd.pop(key). But if anything ever modifies the shallow copy, you have a well-known problem with aliasing. It helps if you tell us the wider context. (Is anything else ever modifying the dict values? Are you trying to destructively iterate over a list? if not, what?) – Twobit