Retain all entries except for one key python

Question

I have a python dictionary. Just to give out context, I am trying to write my own simple cross validation unit.

So basically what I want is to get all the values except for the given keys. And depending on the input, it returns all the values from a dictionary except to those what has been given.

So if the input is 2 and 5 then the output values doesn't have the values from the keys 2 and 5?

score 72 · Accepted Answer · answered Jan 03 '12 at 19:17

72

for key, value in your_dict.items():
    if key not in your_blacklisted_set:
        print value

the beauty is that this pseudocode example is valid python code.

it can also be expressed as a list comprehension:

resultset = [value for key, value in your_dict.items() if key not in your_blacklisted_set]

answered Jan 03 '12 at 19:17

Samus_

2,903
1
23
22

1

Umm hi .. probably a dumb question.. but what would be my blacklisted set here? – frazman Jan 03 '12 at 19:21
1

[2, 5] in the example you've given, it's the list of keys you want to exclude. – Samus_ Jan 03 '12 at 19:22

Dendrobates · Answer 2 · 2018-09-24T11:52:03.437

25

If your goal is to return a new dictionary, with all key/values except one or a few, use the following:

exclude_keys = ['exclude', 'exclude2']
new_d = {k: d[k] for k in set(list(d.keys())) - set(exclude_keys)}

where 'exclude' can be replaced by (a list of) key(s) which should be excluded.

edited Sep 24 '18 at 11:52

answered Sep 24 '18 at 11:42

Dendrobates

3,294
6
37
56

4

small improvement: initialize exclude_keys directly as a set: `exclude_keys = {'exclude', 'exclude2'}` – Käseknacker Dec 17 '20 at 13:07

score 17 · Answer 3 · edited May 05 '22 at 21:53

17

Just for fun with sets

keys = set(d.keys())
excludes = set([...])

for key in keys.difference(excludes):
    print d[key]

edited May 05 '22 at 21:53

aungi

3
2

answered Jan 03 '12 at 19:29

joel3000

1,249
11
22

2

`[d[k] for k in set(d.keys()).difference(set(excludes))]` don't use `dict` as a name. – dansalmo Jul 14 '13 at 00:59

score 16 · Answer 4 · answered Mar 10 '16 at 00:01

16

keys = ['a', 'b']
a_dict = {'a':1, 'b':2, 'c':3, 'd':4}
[a_dict.pop(key) for key in keys]

After popping out the keys to be discarded, a_dict will retain the ones you're after.

answered Mar 10 '16 at 00:01

Darren McAffee

645
1
6
10

This was useful for me looking to remove one known key from a dict. If only one key then simply `dict.pop('key_name')` works. Needs try-catch if `key_name` might not exist. – yeliabsalohcin Jan 05 '23 at 17:25
Adding `None` as a second argument: `dict.pop('key_name', None)` solves the issue where the key doesn't exist. Thanks to @kolypto here: https://stackoverflow.com/a/70785605/2523501 – yeliabsalohcin Jan 05 '23 at 17:42

score 10 · Answer 5 · edited May 26 '16 at 23:11

10

Given a dictionary say

d = {
     2: 2, 5: 16, 6: 5,
     7: 6, 11: 17, 12: 9,
     15: 18, 16: 1, 18: 16,
     19: 17, 20: 10
     }

then the simple comprehension example would attain what you possibly desire

[v for k,v in d.iteritems() if k not in (2,5)]

This example lists all values not with keys {2,5}

for example the O/P of the above comprehension is

[5, 6, 1, 17, 9, 18, 1, 16, 17, 10]

edited May 26 '16 at 23:11

Steve Casey

9,966
1
20
24

answered Jan 03 '12 at 19:21

Abhijit

62,056
18
131
204

Note: from python 3 `.iteritems()` was renamed `.items()` ``` [v for k,v in d.items() if k not in (2,5)]``` – hamagust Feb 11 '22 at 20:50

score 3 · Answer 6 · answered Jan 03 '12 at 19:21

3

Also, as a list comprehension using sets:

d = dict(zip(range(9),"abcdefghi"))
blacklisted = [2,5]
outputs = [d[k] for k in set(d.keys())-set(blacklisted)]

answered Jan 03 '12 at 19:21

Nate

12,499
5
45
60

score 2 · Answer 7 · answered Aug 09 '22 at 07:38

2

you can also use pydash - https://pydash.readthedocs.io/en/latest/

from pydash import omit
d = {'a': 1, 'b': 2, 'c': 3}
c = omit(d, 'a')
print(c) # {'b': 2, 'c': 3}

answered Aug 09 '22 at 07:38

Tanvi Agrawal

21
1

Your answer could be improved with additional supporting information. Please [edit] to add further details, such as citations or documentation, so that others can confirm that your answer is correct. You can find more information on how to write good answers [in the help center](/help/how-to-answer). – Community Aug 11 '22 at 22:44

score 2 · Answer 8 · answered Jan 03 '12 at 19:17

How about something along the following lines:

In [7]: d = dict((i,i+100) for i in xrange(10))

In [8]: d
Out[8]: 
{0: 100,
 1: 101,
 2: 102,
 3: 103,
 4: 104,
 5: 105,
 6: 106,
 7: 107,
 8: 108,
 9: 109}

In [9]: exc = set((2, 5))

In [10]: for k, v in d.items():
   ....:     if k not in exc:
   ....:         print v
   ....:         
   ....:         
100
101
103
104
106
107
108
109

score 0 · Answer 9 · answered Apr 07 '21 at 10:00

using exception handling

facebook_posts = [
    {'Likes': 21, 'Comments': 2}, 
    {'Likes': 13, 'Comments': 2, 'Shares': 1}, 
    {'Likes': 33, 'Comments': 8, 'Shares': 3}, 
    {'Comments': 4, 'Shares': 2}, 
    {'Comments': 1, 'Shares': 1}, 
    {'Likes': 19, 'Comments': 3}
]

total_likes = 0

for post in facebook_posts:
    try:
        total_likes = total_likes + post['Likes']
    except KeyError:
        pass
print(total_likes)

you can also use:

except KeyError: 'My Key'

but probably only good for once off use

score 0 · Answer 10 · answered Oct 29 '21 at 11:17

Be careful of using a shallow copy if you intend to modify the resulting dict.

import copy

def copy_dict_except_keys_shallow(d:dict, exclude_keys):
  return {k: d[k] for k in set(list(d.keys())) - set(exclude_keys)}

def copy_dict_except_keys_deep(d:dict, exclude_keys):
  return {k: copy.deepcopy(d[k]) for k in set(list(d.keys())) - set(exclude_keys)}

original = {'a': 1, 'b': [1, 2, 3]}
deep = copy_dict_except_keys_deep(original, ['a'])
deep['b'].append(4)

print("Modifying the deep copy preserves the original")
print(f"original: {original}")
print(f"deep copy: {deep}")
print()

shallow = copy_dict_except_keys_shallow(original, 'a')
shallow['b'].append(4)

print("Modifying the shallow copy changes the original")
print(f"original: {original}")
print(f"shallow copy: {shallow}")

Modifying the deep copy preserves the original
original: {'a': 1, 'b': [1, 2, 3]}
deep copy: {'b': [1, 2, 3, 4]}

Modifying the shallow copy changes the original
original: {'a': 1, 'b': [1, 2, 3, 4]}
shallow copy: {'b': [1, 2, 3, 4]}

score 0 · Answer 11 · answered Jun 09 '23 at 15:28

0

Here's mine:

def dict_exclude_keys(d: dict, excludes: list[str]) -> dict:
    keys = set(list(d.keys())) - set(excludes)
    return {k: d[k] for k in keys if k in d}

answered Jun 09 '23 at 15:28

masroore

9,668
3
23
28

Retain all entries except for one key python

11 Answers11

Linked

Related