使用Python从嵌套项中过滤键

---

Python可以通过过滤嵌套项中的键来从包含嵌套字典或列表的复杂数据结构中提取特定值。该键是嵌套项内某个值的唯一标识符。基于此问题陈述，它具有各种应用领域，例如数据操作、数据交互和API交互。

语法

以下语法用于示例：

append()

这是Python中的一种内置方法，用于在列表末尾添加元素。

isintance()

Python有一个内置函数`isinstance()`，用于确定一个对象是否是某个类或类型的实例或子类。

values()

`values()`是Python中的一个内置函数，可用于获取字典中的每个值。

pop()

Python中的内置方法`pop()`用于删除或返回给定索引值。

使用递归和`isinstance()`

在下面的示例中，程序使用递归，这意味着函数调用自身，在函数内部，使用内置函数`isinstance()`检查对象类型，并通过返回函数来使用字典推导。

示例

def filter_keys_nested_item(data, keys):
    if isinstance(data, dict):
        return {k: filter_keys_nested_item(v, keys) for k, v in data.items() if k in keys}
    elif isinstance(data, list):
        return [filter_keys_nested_item(item, keys) for item in data]
    else:
        return data

# create the nested item
nested_item = {
    "key1": "value1",
    "key2": {
        "key3": "value3",
        "key4": "value4"
    },
    "key5": [
        {"key6": "value6"},
        {"key7": "value7"}
    ]
}
filtered_item = filter_keys_nested_item(nested_item, ["key2", "key4", "key6"])
print(filtered_item)

输出

 {'key2': {'key4': 'value4'}}

使用堆栈

在下面的示例中，程序根据特定键删除嵌套项。程序调整嵌套字典和列表，以相应地探索嵌套项。因此，它遍历字典的嵌套结构，检查每个键是否与给定键匹配。如果找到匹配的键，则将相应的值添加到过滤后的输出中。最后，它将使用函数返回来过滤嵌套项并显示结果。

示例

def filter_keys_nested_item(data, keys):
    stack = [(data, {})]
    while stack:
        current, filtered = stack.pop()
        if isinstance(current, dict):
            for k, v in current.items():
                if k in keys:
                    filtered[k] = filter_keys_nested_item(v, keys)
                elif isinstance(v, (dict, list)):
                    stack.append((v, {}))
        elif isinstance(current, list):
            for item in current:
                stack.append((item, {}))
    return filtered

# create the nested item
nested_item = {
    "key1": "value1",
    "key2": {
        "key3": "value3",
        "key4": "value4"
    },
    "key5": [
        {"key6": "value6"},
        {"key7": "value7"}
    ]
}
filtered_item = filter_keys_nested_item(nested_item, ["key2", "key4", "key5"])
print(filtered_item)

输出

 {'key2': {'key4': {}}, 'key5': {}}

使用递归生成器

在下面的示例中，程序使用递归生成器，类似于列表推导，根据特定键过滤嵌套列表或字典。使用递归函数，它将提到要过滤嵌套项的特定键。它允许对给定输入的嵌套结构进行深度遍历，如果找到匹配项，则它将生成相应的过滤输出。

示例

def filter_keys_nested_item(data, keys):
    if isinstance(data, dict):
        filtered = {k: filter_keys_nested_item(v, keys) for k, v in data.items() if k in keys}
    elif isinstance(data, list):
        filtered = [filter_keys_nested_item(item, keys) for item in data]
    else:
        return data

    if filtered:
        yield filtered

    for item in filtered.values() if isinstance(filtered, dict) else filtered:
        if isinstance(item, dict) or isinstance(item, list):
            yield from filter_keys_nested_item(item, keys)

# create the nested item
nested_item = {
    "key1": "value1",
    "key2": {
        "key3": "value3",
        "key4": "value4"
    },
    "key5": [
        {"key6": "value6"},
        {"key7": "value7"}
    ]
}
filtered_item = next(filter_keys_nested_item(nested_item, ["key2", "key4", "key6"]))
print(filtered_item)

输出

 {'key2': <generator object filter_keys_nested_item at 0x7f29d0e4aab0>}

结论

我们讨论了解决问题陈述的各种方法。对于许多应用程序，包括数据操作、数据分析、API交互和配置解析，从嵌套对象中过滤键至关重要。它允许我们解析API响应、分析数据子集以及根据配置参数修改应用程序的行为。