I've a nested dictionary.
>>> foo = {'m': {'a': 10}, 'n': {'a': 20}}
>>>
I'd like to filter specific values, based on the values of 'a'.
I can use list comprehensions for the purpose.
>>> [foo[n] for n in foo if foo[n]['a'] == 10]
[{'a': 10}]
>>>
Using list alone gives me the elements from foo (and not the values of the elements) - as expected:
>>> list(filter(lambda x: foo[x] if foo[x]['a']==10 else None,foo))
['m']
>>>
Using map returns me unwanted 'None' values:
>>> list(map(lambda x: foo[x] if foo[x]['a']==10 else None,foo))
[{'a': 10}, None]
>>>
Combining these two, I can fetch the desired value. But I guess foo is iterated twice - once each for filter and map. The list comprehension solution needs me to iterate just once.
>>> list(map(lambda t: foo[t], filter(lambda x: foo[x] if foo[x]['a']==10 else None,foo)))
[{'a': 10}]
>>>
Here's another approach using just filter. This gives me the desired values but I'm not sure if iterating over values of a dictionary is a good/pythonic approach:
>>> list(filter(lambda x: x if x['a'] == 10 else None, foo.values()))
[{'a': 10}]
>>>
I'd like to know if:
- What's the pythonic/recommended approach for this scenario?
- If the last example using filter on dictionary values is an acceptable?
Regards
Sharad
If you want to return the full nested dictionary if it contains
a
, a list comprehension is probably the cleanest way. Your initial list comprehension would work:You can also avoid the lookup on
n
with:List comprehensions are generally considered more Pythonic than
map
orfilter
related approaches for simpler problems like this, thoughmap
andfilter
certainly have their place if you're using a pre-defined function.If you want to return all values of a dictionary that meet a certain criteria, I'm not sure how you would be able to get around not iterating over the values of a dictionary.
For a filter-based approach, I would do it as:
There's no need for the
if-else
in your original code.A list comprehension can do this beautifully.
You don't need the for loop or the list comprehension if you are matching against a known key in the dictionary.