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:

[foo[n] for n in foo if foo[n]['a'] == 10]

You can also avoid the lookup on n with:

[d for d in foo.values() if d['a'] == 10]

List comprehensions are generally considered more Pythonic than map or filter related approaches for simpler problems like this, though map and filter certainly have their place if you're using a pre-defined function.

This gives me the desired values but I'm not sure if iterating over values of a dictionary is a good/pythonic approach.

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:

list(filter(lambda x: x['a'] == 10, foo.values()))

There's no need for the if-else in your original code.

You can just use a dictionary comprehension over the Filme.items():

In [2]: {k:v for k,v in Filme.items() if v['Wertung'] >= 7}
Out[2]:
{'2': {'Jahr': 3,
  'Preis': 70,
  'Schauspielern': [''],
  'Titel': 30,
  'Wertung': 7},
 '4': {'Jahr': 3,
  'Preis': 20,
  'Schauspielern': [''],
  'Titel': 5,
  'Wertung': 9},
 '5': {'Jahr': 3,
  'Preis': 100,
  'Schauspielern': [''],
  'Titel': 8,
  'Wertung': 10},
 '7': {'Jahr': 3,
  'Preis': 20,
  'Schauspielern': [''],
  'Titel': 16,
  'Wertung': 9},
 '9': {'Jahr': 3,
  'Preis': 20,
  'Schauspielern': [''],
  'Titel': 90,
  'Wertung': 9}}

This is equivalent to the following:

new_dict = {}
for k,v in Filme.items():
    if v['Wertung'] >= 7:
        new_dict[k] = v

You can define this recursively pretty easily with a dict comprehension.

def remove_keys_with_none_values(item):
    if not hasattr(item, 'items'):
        return item
    else:
        return {key: remove_keys_with_none_values(value) for key, value in item.items() if value is not None}

Recursion isn't too optimised in Python, but given the relatively small number of nestings that are likely, I wouldn't worry.

Looking before we leap isn't too Pythonic, I think it is a better option than catching the exception - as it's likely that the value will not be a dict most of the time (it is likely we have more leaves than branches).

Also note that in Python 2.x, you probably want to swap in iteritems() for items().

It's a really old question. I came across a similar problem recently.

It maybe obvious, but you are dealing with a tree in which each node has an arbitray number of children. You want to cut the subtrees that do not contain some items as nodes (not leaves). To achieve this, you are using a custom DFS: the main function returns either a subtree or None. If the value is None then you "cut" the branch.

First of all, the function dict_key_filter returns a (non empty) dict, a (non empty) list or None if no filter key was not found in the branch. To reduce complexity, you could return a sequence in every case: an empty sequence if no filter key was found, and a non empty sequence if you are still searching or you found the leaf of the tree. Your code would look like:

def dict_key_filter(obj, obj_filter):
    if isinstance(obj, dict):
        retdict = {}
        ...
        return retdict # empty or not
    elif isinstance(obj, list):
        retlist = []
        ...
        return retlist # empty or not
    else:
        return [] # obvioulsy empty

This was the easy part. Now we have to fill the dots.

The list case

Let's begin with the list case, since it is the easier to refactor:

retlist = []
for value in obj:
    child = dict_key_filter0(value, obj_filter)
    if child:
        retlist.append(child)

We can translate this into a simple list comprehension:

retlist = [dict_key_filter(value, obj_filter) for value in obj if dict_key_filter(value, obj_filter)]

The drawback is that dict_key_filter is evaluated twice. We can avoid this with a little trick (see https://stackoverflow.com/a/15812866):

retlist = [subtree for subtree in (dict_key_filter(value, obj_filter) for value in obj) if subtree]

The inner expression (dict_key_filter(value, obj_filter) for value in obj) is a generator that calls dict_key_filter once per value. But we can even do better if we build a closure of dict_key_filter:

def dict_key_filter(obj, obj_filter):
    def inner_dict_key_filter(obj): return dict_key_filter(obj, obj_filter)

    ...

    retlist = list(filter(len, map(inner_dict_key_filter, obj)))

Now we are in the functional world: map applies inner_dict_key_filter to every element of the list and then the subtrees are filtered to exclude empty subtrees (len(subtree) is true iff subtree is not empty). Now, the code looks like:

def dict_key_filter(obj, obj_filter):
    def inner_dict_key_filter(obj): return dict_key_filter(obj, obj_filter)

    if isinstance(obj, dict):
        retdict = {}
        ...
        return retdict
    elif isinstance(obj, list):
        return list(filter(len, map(inner_dict_key_filter, obj)))
    else:
        return []

If you are familiar with functional programming, the list case is readable (not quite as readable as it would be in Haskell, but still readable).

The dict case

I do not forget the dictionary-comprehension tag in your question. The first idea is to create a function to return either a whole copy of the branch or the result of the rest of the DFS.

def build_subtree(key, value):
    if key in obj_filter:
        return copy.deepcopy(value) # keep the branch
    elif isinstance(value, (dict, list)):
        return inner_dict_key_filter(value) # continue to search
    return [] # just an orphan value here

As in the list case, we do not refuse empty subtrees for now:

retdict = {}
for key, value in obj.items():
    retdict[key] = build_subtree(key, value)

We have now a perfect case for dict comprehension:

retdict = {key: build_subtree(key, value) for key, value in obj.items() if build_subtree(key, value)}

Again, we use the little trick to avoid to compute a value twice:

retdict = {key:subtree for key, subtree in ((key, build_subtree(key, value)) for key, value in obj.items()) if subtree}

But we have a little problem here: the code above is not exaclty equivalent to the original code. What if the value is 0? In the original version, we have retdict[key] = copy.deepcopy(0) but in the new version we have nothing. The 0 value is evaluated as false and filtered. And then the dict may become empty and we cut the branch wrongfully. We need another test to be sure we want to remove a value: if it's an empty list or dict, then remove it, else keep it:

def to_keep(subtree): return not (isinstance(subtree, (dict, list)) or len(subtree) == 0)

That is:

 def to_keep(subtree): return not isinstance(subtree, (dict, list)) or subtree

If you remember a bit of logic (https://en.wikipedia.org/wiki/Truth_table#Logical_implication) you can interpret this as: if subtree is a dict or a list, then it must not be empty.

Let's put the pieces together:

def dict_key_filter(obj, obj_filter):
    def inner_dict_key_filter(obj): return dict_key_filter(obj, obj_filter)
    def to_keep(subtree): return not isinstance(subtree, (dict, list)) or subtree

    def build_subtree(key, value):
        if key in obj_filter:
            return copy.deepcopy(value) # keep the branch
        elif isinstance(value, (dict, list)):
            return inner_dict_key_filter(value) # continue to search
        return [] # just an orphan value here

    if isinstance(obj, dict):
        key_subtree_pairs = ((key, build_subtree(key, value)) for key, value in obj.items())
        return {key:subtree for key, subtree in key_subtree_pairs if to_keep(subtree)}
    elif isinstance(obj, list):
        return list(filter(to_keep, map(inner_dict_key_filter, obj)))
    return []

I don't know if this is more pythonic, but it seems clearer to me.

dict1 = {
    'test1': { 'test2':[1,2] }, 
    'test3': [
        {'test6': 2}, 
        {
            'test8': { 'test9': 23 }
        }
    ],
    'test4':{'test5': 0}
}

obj_filter = ['test5' , 'test9']

print (dict_key_filter(dict1, obj_filter))
# {'test3': [{'test8': {'test9': 23}}], 'test4': {'test5': 0}}

You can try a nested dictionary comprehension:

test_dict = {'Nikhil' : { 'roll' : 24, 'marks' : 17, 'extra' : {'item1': 5, 'item2': 3, 'item3': 2}},
             'Akshat' : {'roll' : 54, 'marks' : 12, 'extra' : {'item1': 8, 'item2': 4, 'item3': 3}}, 
             'Akash' : { 'roll' : 12, 'marks' : 15, 'extra' : {'item1': 9, 'item2': 3, 'item3': 1}}}

new_dict = {}

rollList = [24, 54]
item123List = [2, 4, 6, 8, 10]

new_dict = {k:v for k,v in test_dict.items() if v['roll'] in rollList}
new_dict = {k: {i: {a: b for a, b in j.items() if b in item123List} if i == 'extra' else j \
                for i,j in v.items()} \
                for k, v in test_dict.items()}
print(new_dict)

Output:

{'Nikhil': {'roll': 24, 'marks': 17, 'extra': {'item3': 2}}, 'Akshat': {'roll': 54, 'marks': 12, 'extra': {'item1': 8, 'item2': 4}}, 'Akash': {'roll': 12, 'marks': 15, 'extra': {}}}

I have coded a custom filter method:

def customFilter(all_assets, search_attribute, search_attribute_value):
    res = []
    for asset in all_assets:
        if asset:
            attributes = asset["metadata"]["tags"][1]["attributes"]
            if attributes and search_attribute in attributes:
                if search_attribute_value == attributes[search_attribute]:
                    res.append(asset)
    return res

Lets test it:

all_assets = [
    {
        "dateListed": 58391,
        "id": "118572",
        "metadata": {
            "files": [],
            "mediaType": "image/png",
            "name": "The three",
            "tags": [
                {"right": "101 Galaxy"},
                {
                    "attributes": {
                        "Background": "Mars",
                        "Body": "Rough",
                        "Face": "Dumb",
                        "Headwear": "Helmet",
                    }
                },
            ],
            "thumbnail": "something",
        },
        "Session": None,
        "police": "pewpew",
        "verified": {"project": "Thes", "verified": True},
    },
    {
        "dateListed": 430298239,
        "id": "1191281",
        "metadata": {
            "files": [],
            "mediaType": "image/png",
            "name": "TheOne",
            "tags": [
                {"right": "101 Galaxy"},
                {
                    "attributes": {
                        "Background": "Star",
                        "Body": "Smooth",
                        "Face": "Fresh",
                        "Headwear": "Cap",
                    }
                },
            ],
            "thumbnail": "something",
        },
        "Session": None,
        "police": "pewpew",
        "verified": {"project": "Thes", "verified": True},
    },
]

search_attribute = "Background"
search_attribute_value = "Star"

print(customFilter(all_assets, search_attribute, search_attribute_value))

Output:

[{'dateListed': 430298239, 'id': '1191281', 'metadata': {'files': [], 'mediaType': 'image/png', 'name': 'TheOne', 'tags': [{'right': '101 Galaxy'}, {'attributes': {'Background': 'Star', 'Body': 'Smooth', 'Face': 'Fresh', 'Headwear': 'Cap'}}], 'thumbnail': 'something'}, 'Session': None, 'police': 'pewpew', 'verified': {'project': 'Thes', 'verified': True}}]

Use a nested loop and the del keyword.:

import json

orders = ...

for order in orders:
    for item in order["line_items"]:
        if "note" in item.keys():
            del item["note"]

# for pretty output
formatted_orders = json.dumps(orders, indent=2)

print(formatted_orders)

Output

[
  {
    "order_id": 1,
    "line_items": [
      {
        "product_id": 2,
        "product_name": "mango"
      },
      {
        "product_id": 3,
        "product_name": "orange"
      }
    ]
  },
  {
    "order_id": 2,
    "line_items": [
      {
        "product_id": 4,
        "product_name": "banana"
      }
    ]
  }
]

Maybe something like this:

from collections import defaultdict

new_tgt_dict = defaultdict(dict)
for k, v in src_tgt_dict.items():
  for k1, v1 in v.items():
    k_temp = k1
    if "-" in k1:
      k_temp = k1[0:(k1.index("-"))]
    if k_temp in tgt_preps:
      new_tgt_dict[k].update({k1: v1})
print(dict(new_tgt_dict))

{'in-front-of': {'devant': 4}, 'next-to': {'à-côté-de': 5}, 'for': {'pour': 7}, 'on': {'sur': 2}}

There are a few simple optimization you can try:

• make comparison_list a set so the lookup is O(1) instead of O(n)
• make list_of_tuples a generator, so you don't have to materialize all the entries at once
• you can also integrate the condition into the generator itself

Example:

comparison_set = set(['value_1', 'value_2'])
tuples_generator = ((c['key'], x['value']) 
                    for c in list_of_dict for x in c['data']
                    if x['value'] in comparison_set)
print(*tuples_generator)
# ('key1', 'value_1') ('key1', 'value_2')

Of course, you can also keep the comparison separate from the generator:

tuples_generator = ((c['key'], x['value']) 
                    for c in list_of_dict for x in c['data'])
for k, v in tuples_generator:
    if v in comparison_set:
        print(k, v)

Or you could instead create a dict mapping values from comparison_set to keys from list_of_dicts. This will make finding the key to a particular value faster, but note that you can then only keep one key to each value.

values_dict = {x['value']: c['key'] 
               for c in list_of_dict for x in c['data']
               if x['value'] in comparison_set}
print(values_dict)
# {'value_2': 'key1', 'value_1': 'key1'}