从嵌套字典中递归删除 None 值或 None 键

Question

问题：

如何遍历字典并从中删除None键或值？

这是我尝试过的：

代码：

import copy


def _ignore(data):
    copied_data = copy.deepcopy(data)

    print('-------------------------')
    print(f'copied_data: {copied_data}')
    print('-------------------------')

    if isinstance(copied_data, list):
        print(f'item is instance of list: {copied_data}')

        for idx, item in enumerate(data):
            if isinstance(item, list):
                return _ignore(item)

            elif isinstance(item, dict):
                return _ignore(item)

            elif item is None:
                del copied_data[idx]

    elif isinstance(copied_data, dict):
        print(f'item is instance of dict: {copied_data}')

        for key, item in data.items():
            if isinstance(item, list):
                return _ignore(item)

            elif isinstance(item, dict):
                return _ignore(item)

            elif item is None:
                del copied_data[key]

    return copied_data


if __name__ == '__main__':
    data = {'key1': None, 'key2': {'k1': None, 'k2': 2}, 'key3': [None, 1, 2, 3, 4]}

    print(f'output: {_ignore(data=data)}')

输入：

{'key1': None, 'key2': {'k1': None, 'k2': 2}, 'key3': [None, 1, 2, 3, 4]}

Output：

-------------------------
copied_data: {'key1': None, 'key2': {'k1': None, 'k2': 2}, 'key3': [None, 1, 2, 3, 4]}
-------------------------
item is instance of dict: {'key1': None, 'key2': {'k1': None, 'k2': 2}, 'key3': [None, 1, 2, 3, 4]}
-------------------------
copied_data: {'k1': None, 'k2': 2}
-------------------------
item is instance of dict: {'k1': None, 'k2': 2}
output: {'k2': 2}

请记住，代码还应该删除嵌套list或嵌套dict中的None值，并且我们不能在迭代时从dict中删除元素。

更新：代码应该支持嵌套dict或list

这是另一个输入示例：

{'key1': None, None:1 ,'key2': {'k1': {'k3': [None, 1, 23], 'k4': None}, 'k2': 2},
        'key3': [{'key1': None, 'key2': [None, 1, 2, 3], 'key3': {'k1': 1}}, 1, 2, 3, 4]} 

谢谢。

Answer 1

你没有做你声称要做的事情，因为据我所知，你只是删除了None值。 这个字典：

{'key1': None, 'key2': {'k1': None, 'k2': 2}, 'key3': [None, 1, 2, 3, 4]}

只有None值，没有键。 我要在这里坚持使用 Python 定义键和值。 None键如下所示：

{None: "value"}

但是，您可以轻松地执行以下操作：

def recursive_filter(item, *forbidden):
    if isinstance(item, list):
        return [recursive_filter(entry, *forbidden) for entry in item if entry not in forbidden]
    if isinstance(item, dict):
        result = {}
        for key, value in item.items():
            value = recursive_filter(value, *forbidden)
            if key not in forbidden and value not in forbidden:
                result[key] = value
        return result
    return item

您可以使用如下：

clean = recursive_filter(dirty, None)

或者，如果您想过滤掉更多：

clean = recursive_filter(dirty, *iterable_of_forbidden_things)
clean = recursive_filter(dirty, None, other_forbidden_thing)

如果您真的只关心值，那么您可以删除对键的检查。

Answer 2

您可以递归地检查并返回一个key, value对，然后从中创建一个新的dict ，例如，

$ cat rmnone.py
data = {'key1': None, 'key2': {'k1': {'k3': [None, 1, 23], 'k4': None}, 'k2': 2},
        'key3': [{'key1': None, 'key2': [None, 1, 2, 3], 'key3': {'k1': 1}}, 1, 2, 3, 4]}

def func(data):
    for key, val in data.items():
        if val is not None:
            if isinstance(val, list):
                tmp = []
                for v in val:
                    if isinstance(v, dict):
                        for k,v in func(v):
                            tmp.append({k:v})
                    elif v is not None:
                        tmp.append(v)
                yield (key, tmp)
            if isinstance(val, tuple):
                tmp = []
                for v in val:
                    if isinstance(v, dict):
                        for k,v in func(v):
                            tmp.append({k:v})
                    elif v is not None:
                        tmp.append(v)
                yield (key, tmp)
            elif isinstance(val, dict):
                    tmp = {}
                    for k,v in func(val):
                        tmp.update({k:v})
                    yield key, tmp
            elif not isinstance(val, (tuple, dict, list)):
                yield key,val

d = {k:v for k,v in func(data)}
print(d)

Output：

$ python3 rmnone.py
{'key2': {'k1': {'k3': [1, 23]}, 'k2': 2}, 'key3': [{'key2': [1, 2, 3]}, {'key3': {'k1': 1}}, 1, 2, 3, 4]}

Answer 3

这是通过创建新对象来做到这一点的一种方法。

def removed_none(obj):
    t = type(obj)
    if issubclass(t, (tuple, list, set)):
        obj = t(removed_none(a) for a in obj if a is not None)
    elif issubclass(t, dict):
        obj = {k: removed_none(v) for k, v in obj.items()
               if k is not None and v is not None}
    return obj

data = {'key1': None, 'key2': {'k1': None, 'k2': {1: 2, 3: None}},
        'key3': [None, [1, None, 0], 2, 3, 4]}
print(f'output: {removed_none(data)}')
# output: {'key2': {'k2': {1: 2}}, 'key3': [[1, 0], 2, 3, 4]}

如果您想修改现有的 object，这里是一个不同的 function（ remove_none而不是removed_none ）。 请注意，这不能用于修改包含None值的元组，因为它们是不可变的。

def remove_none(obj):
    if isinstance(obj, list):
        for i in range(len(obj) - 1, -1, -1):
            if obj[i] is None:
                del obj[i]
            else:
                remove_none(obj[i])
    elif isinstance(obj, set):
        obj.discard(None)
        for elem in obj:
            remove_none(elem)
    elif isinstance(obj, dict):
        for k, v in list(obj.items()):
            if k is None or v is None:
                del obj[k]
            else:
                remove_none(v)

data = {'key1': None, 'key2': {'k1': None, 'k2': {1: 2, 3: None}},
        'key3': [None, [1, None, 0], 2, 3, 4]}
remove_none(data)
print(f'output: {data}')
# output: {'key2': {'k2': {1: 2}}, 'key3': [[1, 0], 2, 3, 4]}

Answer 4

这基本上已经在这里完成了，并且也以稍微修改的形式解决了这个问题：

d = {'key1': None, 
     'key2': {'k1': None, 'k2': 2}, 
     'key3': [None, 1, 2, 3, 4],
     None: 42}    

def scrub_none(node):
    if isinstance(node, dict):
        for k in list(node.keys()):
            if node[k] is None or k is None:
                del node[k]
            else:
                scrub_none(node[k])
    elif isinstance(node, list):
        for i in reversed(range(len(node))):
            if node[i] is None:
                del node[i]
            else:
                scrub_none(node[i])
    else:
        pass

scrub_none(d)   
print(d)
# {'key2': {'k2': 2}, 'key3': [1, 2, 3, 4]}

注意＃1：就地修改输入dict

注意＃2：如果存在，也会删除None键