如何编写一个通用函数来检索 Python 中的嵌套值

简介

在 Python 中处理复杂的嵌套数据结构可能是一项常见挑战。在本教程中，我们将探讨如何开发一个通用函数，该函数可以从嵌套字典、列表或其他数据类型的任何层级检索值。到最后，你将拥有一个通用工具来简化你的 Python 编程任务。

Skills Graph

理解 Python 的嵌套数据结构

Python 的数据结构用途广泛，可以进行嵌套以表示复杂的层次关系。嵌套数据结构是包含其他数据结构的数据集合，能够表示复杂的信息。

嵌套列表

嵌套列表是指其元素包含其他列表的列表。这使得可以创建多维数据结构，其中每个内部列表可以包含不同类型的数据。

nested_list = [
    [1, 2, 3],
    ['a', 'b', 'c'],
    [True, False, True]
]

嵌套字典

嵌套字典是指其值包含其他字典的字典。这能够表示复杂的层次数据结构。

nested_dict = {
    "person1": {
        "name": "John Doe",
        "age": 35,
        "address": {
            "street": "123 Main St",
            "city": "Anytown",
            "state": "CA"
        }
    },
    "person2": {
        "name": "Jane Smith",
        "age": 28,
        "address": {
            "street": "456 Oak Rd",
            "city": "Somewhere",
            "state": "NY"
        }
    }
}

实际应用中的嵌套数据结构

嵌套数据结构常用于各种应用场景，例如：

• 表示层次数据（如组织结构、文件系统）
• 存储复杂的配置设置
• 处理具有嵌套元素的 JSON 或 XML 数据
• 实现类似图的数据结构（如社交网络、推荐系统）

通过理解 Python 中嵌套数据结构的概念，你可以有效地处理和操作复杂数据，从而构建更强大、更灵活的应用程序。

开发用于嵌套值检索的可重用函数

手动遍历嵌套数据结构以检索特定值很快就会变得繁琐，尤其是在处理深度嵌套或复杂结构时。为了简化这个过程，我们可以创建一个通用函数，以可重用且高效的方式处理嵌套值检索。

实现嵌套值检索函数

以下是一个 Python 函数示例，它可以从嵌套数据结构中检索值：

def get_nested_value(data, keys, default=None):
    """
    使用键列表从嵌套数据结构中检索值。

    参数：
        data (dict, list 或任何)：嵌套数据结构。
        keys (list)：用于遍历嵌套结构的键或索引列表。
        default (任何, 可选)：如果未找到键，则返回的默认值。

    返回：
        嵌套数据结构中指定位置存储的值，
        如果未找到键，则返回默认值。
    """
    try:
        value = data
        for key in keys:
            if isinstance(value, dict):
                value = value[key]
            elif isinstance(value, list):
                value = value[int(key)]
            else:
                return default
        return value
    except (KeyError, IndexError, TypeError):
        return default

此函数接受三个参数：

1. data：嵌套数据结构（字典、列表或任何其他数据类型）
2. keys：用于遍历嵌套结构的键或索引列表
3. default：如果未找到指定键，则返回的默认值

该函数遍历键列表，使用适当的索引方法（字典键或列表索引）访问嵌套值。如果未找到任何键，函数将返回默认值。

使用嵌套值检索函数

以下是如何使用 get_nested_value 函数的示例：

nested_data = {
    "person1": {
        "name": "John Doe",
        "age": 35,
        "address": {
            "street": "123 Main St",
            "city": "Anytown",
            "state": "CA"
        }
    },
    "person2": {
        "name": "Jane Smith",
        "age": 28,
        "address": {
            "street": "456 Oak Rd",
            "city": "Somewhere",
            "state": "NY"
        }
    }
}

## 从嵌套数据结构中检索值
name = get_nested_value(nested_data, ["person1", "name"])
print(name)  ## 输出: John Doe

## 使用默认值检索值
city = get_nested_value(nested_data, ["person1", "address", "city"], default="Unknown")
print(city)  ## 输出: Anytown

## 处理缺失的键
missing_value = get_nested_value(nested_data, ["person1", "phone"], default="N/A")
print(missing_value)  ## 输出: N/A

通过使用 get_nested_value 函数，你可以轻松地从复杂的嵌套数据结构中检索值，而无需编写重复的代码来处理不同层次的嵌套。

实际示例和用例

我们在上一节中开发的 get_nested_value 函数可应用于各种实际用例。让我们通过一些示例来展示它的通用性。

解析 JSON 数据

处理 JSON 数据时经常会遇到嵌套数据结构。get_nested_value 函数可以简化从 JSON 响应中提取特定值的过程。

import json

json_data = """
{
    "results": [
        {
            "id": 1,
            "name": "John Doe",
            "address": {
                "street": "123 Main St",
                "city": "Anytown",
                "state": "CA"
            }
        },
        {
            "id": 2,
            "name": "Jane Smith",
            "address": {
                "street": "456 Oak Rd",
                "city": "Somewhere",
                "state": "NY"
            }
        }
    ]
}
"""

data = json.loads(json_data)
street_address = get_nested_value(data, ["results", "0", "address", "street"])
print(street_address)  ## 输出: 123 Main St

遍历层次数据结构

get_nested_value 函数可用于从各种层次数据结构中检索值，例如文件系统目录或组织结构图。

file_system = {
    "documents": {
        "reports": {
            "2022": [
                "report_01.pdf",
                "report_02.pdf"
            ],
            "2023": [
                "report_03.pdf",
                "report_04.pdf"
            ]
        },
        "templates": [
            "template_1.docx",
            "template_2.docx"
        ]
    },
    "images": {
        "2022": [
            "image_01.jpg",
            "image_02.jpg"
        ],
        "2023": [
            "image_03.jpg",
            "image_04.jpg"
        ]
    }
}

report_filename = get_nested_value(file_system, ["documents", "reports", "2022", "1"])
print(report_filename)  ## 输出: report_02.pdf

处理配置设置

嵌套数据结构通常用于表示复杂的配置设置。get_nested_value 函数可以简化检索特定配置值的过程。

app_config = {
    "database": {
        "host": "localhost",
        "port": 5432,
        "user": "myuser",
        "password": "mypassword"
    },
    "logging": {
        "level": "INFO",
        "file_path": "/var/log/app.log"
    },
    "email": {
        "smtp_server": "smtp.example.com",
        "sender": "[email protected]",
        "recipient": "[email protected]"
    }
}

db_password = get_nested_value(app_config, ["database", "password"])
print(db_password)  ## 输出: mypassword

log_level = get_nested_value(app_config, ["logging", "level"])
print(log_level)  ## 输出: INFO

通过使用 get_nested_value 函数，你可以轻松地从复杂的嵌套数据结构中检索值，而无需编写重复的代码来处理不同层次的嵌套。这使你的代码更简洁、更易于维护，并且能够适应数据结构的变化。

总结

在本 Python 教程中，你已经学会了如何创建一个可重用的函数来高效地检索嵌套值。这项技术可以应用于广泛的数据结构和用例，使你的 Python 代码更健壮、更易于维护。有了所学的知识，你现在可以在 Python 项目中自信地处理复杂的嵌套数据了。