Python 嵌套数据结构

用户11081884

发布于 2026-07-20 17:26:15

290

文章被收录于专栏：用户11081884的专栏用户11081884的专栏

嵌套数据结构是Python编程中处理复杂数据的重要工具，它允许将数据结构以层级方式组织起来，形成更灵活的数据表示形式。本文将全面介绍Python中常见的嵌套数据结构类型，并通过代码示例展示其创建、访问、修改和实际应用场景。

嵌套数据结构是指在一个数据结构内部包含另一个或多个数据结构，形成层级关系的数据组织形式。Python中最常见的嵌套结构包括：

1、列表嵌套字典：列表中每个元素是一个字典

2、字典嵌套列表：字典中某些键对应的值是列表

3、字典嵌套字典：字典中某些键对应的值仍是字典

4、列表嵌套列表：列表中每个元素也是列表（如矩阵）

这些嵌套结构可以组合使用，形成更复杂的数据组织形式，非常适合表示现实世界中的层级关系数据。

嵌套数据结构类型与操作

1. 列表中嵌套字典

# 员工信息管理系统示例
employees = [
    {"id": 1001, "name": "张伟", "position": "高级工程师", "skills": ["Python", "Django", "SQL"]},
    {"id": 1002, "name": "李娜", "position": "产品经理", "skills": ["Axure", "PPT", "数据分析"]},
    {"id": 1003, "name": "王强", "position": "测试工程师", "skills": ["自动化测试", "Selenium", "性能测试"]}
]

# 访问第一个员工的职位
print(employees[0]["position"])  # 输出: 高级工程师

# 为第二个员工添加新技能
employees[1]["skills"].append("用户研究")

# 遍历所有员工信息
for emp in employees:
    print(f"员工ID:{emp['id']} 姓名:{emp['name']} 职位:{emp['position']}")
    print("技能列表:", ", ".join(emp["skills"]))

2. 字典中嵌套列表

# 学生成绩管理系统示例
student_grades = {
    "张三": {"数学": [85, 90, 88], "语文": [92, 88, 90], "英语": [78, 85, 82]},
    "李四": {"数学": [75, 80, 78], "语文": [85, 82, 88], "英语": [90, 92, 88]},
    "王五": {"数学": [92, 95, 90], "语文": [88, 90, 92], "英语": [85, 88, 90]}
}

# 获取张三的数学第二次考试成绩
print(student_grades["张三"]["数学"][1])  # 输出: 90

# 为李四的英语添加新成绩
student_grades["李四"]["英语"].append(95)

# 计算每个学生的各科平均分
for name, subjects in student_grades.items():
    print(f"\n学生: {name}")
    for subject, grades in subjects.items():
        avg = sum(grades) / len(grades)
        print(f"{subject}平均分: {avg:.1f}")

3. 字典中嵌套字典

# 电子商务平台用户管理系统
ecommerce_users = {
    "user001": {
        "personal_info": {"name": "Alice", "age": 28, "email": "alice@example.com"},
        "shipping_address": {
            "street": "123 Main St",
            "city": "New York",
            "zipcode": "10001"
        },
        "order_history": [
            {"order_id": "ORD1001", "date": "2023-05-15", "amount": 125.50},
            {"order_id": "ORD1002", "date": "2023-06-20", "amount": 89.99}
        ]
    },
    "user002": {
        "personal_info": {"name": "Bob", "age": 35, "email": "bob@example.com"},
        "shipping_address": {
            "street": "456 Oak Ave",
            "city": "Los Angeles",
            "zipcode": "90001"
        },
        "order_history": [
            {"order_id": "ORD1003", "date": "2023-04-10", "amount": 210.75}
        ]
    }
}

# 获取user001的城市信息
print(ecommerce_users["user001"]["shipping_address"]["city"])  # 输出: New York

# 为user002添加新订单
new_order = {"order_id": "ORD1004", "date": "2023-07-05", "amount": 155.25}
ecommerce_users["user002"]["order_history"].append(new_order)

# 计算每个用户的总消费金额
for user_id, user_data in ecommerce_users.items():
    total_spent = sum(order["amount"] for order in user_data["order_history"])
    print(f"用户 {user_data['personal_info']['name']} 总消费: ${total_spent:.2f}")

4. 列表中嵌套列表（矩阵操作）

# 图像处理中的像素矩阵示例
image_pixels = [
    [[255, 0, 0], [0, 255, 0], [0, 0, 255]],  # 第一行像素 (红,绿,蓝)
    [[255, 255, 0], [255, 0, 255], [0, 255, 255]],  # 第二行像素 (黄,粉红,青)
    [[128, 128, 128], [0, 0, 0], [255, 255, 255]]   # 第三行像素 (灰,黑,白)
]

# 访问第二行第三列像素的蓝色分量
print(image_pixels[1][2][2])  # 输出: 255

# 修改第一行第一列像素为深红色
image_pixels[0][0] = [192, 0, 0]

# 矩阵转置函数
def transpose_matrix(matrix):
    return [[row[i] for row in matrix] for i in range(len(matrix))]

# 转置像素矩阵
transposed_pixels = transpose_matrix(image_pixels)
print("转置后的矩阵:")
for row in transposed_pixels:
    print(row)

应用场景

1. API响应处理

# 模拟社交媒体API响应数据
api_response = {
    "status": "success",
    "data": {
        "posts": [
            {
                "post_id": "p1001",
                "author": {"user_id": "u2001", "name": "张伟"},
                "content": "今天学习了Python嵌套数据结构，很有收获！",
                "likes": 24,
                "comments": [
                    {"user_id": "u2002", "text": "写得很好！", "timestamp": "2023-07-15T10:30:00"},
                    {"user_id": "u2003", "text": "期待更多分享", "timestamp": "2023-07-15T11:15:00"}
                ]
            },
            {
                "post_id": "p1002",
                "author": {"user_id": "u2003", "name": "李娜"},
                "content": "分享一个数据分析的小技巧...",
                "likes": 42,
                "comments": [
                    {"user_id": "u2001", "text": "实用！", "timestamp": "2023-07-16T09:20:00"},
                    {"user_id": "u2004", "text": "已收藏", "timestamp": "2023-07-16T10:05:00"},
                    {"user_id": "u2005", "text": "感谢分享", "timestamp": "2023-07-16T11:30:00"}
                ]
            }
        ],
        "page_info": {
            "current_page": 1,
            "total_pages": 5,
            "items_per_page": 10
        }
    }
}

# 获取第二篇帖子的作者名字
author_name = api_response["data"]["posts"][1]["author"]["name"]
print(f"第二篇帖子的作者是: {author_name}")  # 输出: 第二篇帖子的作者是: 李娜

# 为第一篇帖子添加新评论
new_comment = {
    "user_id": "u2005",
    "text": "我也在学习这个",
    "timestamp": "2023-07-17T14:25:00"
}
api_response["data"]["posts"][0]["comments"].append(new_comment)

# 统计每篇帖子的评论数量
for post in api_response["data"]["posts"]:
    print(f"帖子ID: {post['post_id']}, 评论数: {len(post['comments'])}")

2. 配置文件管理

# 应用配置管理系统
app_config = {
    "app_name": "数据分析平台",
    "version": "1.2.0",
    "database": {
        "host": "localhost",
        "port": 5432,
        "credentials": {
            "username": "admin",
            "password": "secure_password_123"
        },
        "tables": ["users", "products", "orders", "logs"]
    },
    "logging": {
        "level": "DEBUG",
        "file_path": "/var/log/app.log",
        "rotation": {
            "enabled": True,
            "max_size": "10MB",
            "backup_count": 5
        }
    },
    "features": {
        "analytics": True,
        "notifications": False,
        "export_formats": ["CSV", "Excel", "JSON"]
    }
}

# 获取数据库端口号
db_port = app_config["database"]["port"]
print(f"数据库端口: {db_port}")  # 输出: 数据库端口: 5432

# 修改日志级别为INFO
app_config["logging"]["level"] = "INFO"

# 启用通知功能
app_config["features"]["notifications"] = True

# 显示所有配置项
def print_config(config, indent=0):
    for key, value in config.items():
        if isinstance(value, dict):
            print(" " * indent + f"{key}:")
            print_config(value, indent + 4)
        else:
            print(" " * indent + f"{key}: {value}")

print("当前应用配置:")
print_config(app_config)

3. 开发中的角色系统

# 角色扮演游戏中的角色管理系统
game_characters = {
    "heroes": {
        "warrior": {
            "name": "阿尔萨斯",
            "level": 35,
            "attributes": {
                "strength": 85,
                "agility": 60,
                "intelligence": 40,
                "health": 500,
                "mana": 200
            },
            "skills": ["旋风斩", "盾击", "嘲讽"],
            "equipment": {
                "weapon": "霜之哀伤",
                "armor": "板甲套装",
                "accessories": ["力量戒指", "生命护符"]
            }
        },
        "mage": {
            "name": "吉安娜",
            "level": 40,
            "attributes": {
                "strength": 30,
                "agility": 45,
                "intelligence": 95,
                "health": 300,
                "mana": 600
            },
            "skills": ["火球术", "寒冰箭", "暴风雪", "传送"],
            "equipment": {
                "weapon": "埃提耶什",
                "armor": "法师长袍",
                "accessories": ["智慧项链", "魔法水晶"]
            }
        }
    },
    "monsters": {
        "dragon": {
            "name": "死亡之翼",
            "level": 50,
            "attributes": {
                "strength": 100,
                "agility": 70,
                "intelligence": 80,
                "health": 1500,
                "mana": 400
            },
            "skills": ["龙息", "爪击", "尾扫", "恐惧咆哮"],
            "loot": ["龙鳞", "龙牙", "传说装备"]
        },
        "goblin": {
            "name": "地精盗贼",
            "level": 15,
            "attributes": {
                "strength": 40,
                "agility": 75,
                "intelligence": 60,
                "health": 200,
                "mana": 100
            },
            "skills": ["偷窃", "背刺", "逃跑"],
            "loot": ["金币", "小刀", "破布"]
        }
    }
}


# 获取法师的武器
mage_weapon = game_characters["heroes"]["mage"]["equipment"]["weapon"]
print(f"法师的武器是: {mage_weapon}")  # 输出: 法师的武器是: 埃提耶什

# 为战士添加新技能
game_characters["heroes"]["warrior"]["skills"].append("破甲攻击")

# 计算所有角色的平均等级
total_level = 0
character_count = 0

for category in game_characters.values():
    for character in category.values():
        total_level += character["level"]
        character_count += 1

average_level = total_level / character_count
print(f"所有角色的平均等级: {average_level:.1f}")

4. 安全访问

# 安全访问嵌套数据的实用函数
def safe_get(dct, *keys, default=None):
    """
    安全获取嵌套字典中的值
    :param dct: 要访问的字典
    :param keys: 键的路径
    :param default: 找不到时的默认值
    :return: 找到的值或默认值
    """
    for key in keys:
        try:
            dct = dct[key]
        except (KeyError, TypeError):
            return default
    return dct

# 测试数据
user_data = {
    "user": {
        "id": 1001,
        "profile": {
            "name": "张伟",
            "contact": {
                "email": "zhangwei@example.com",
                "phone": None
            }
        }
    }
}

# 安全访问存在的字段
email = safe_get(user_data, "user", "profile", "contact", "email", default="未提供")
print(f"用户邮箱: {email}")  # 输出: 用户邮箱: zhangwei@example.com

# 安全访问不存在的字段
address = safe_get(user_data, "user", "profile", "address", "street", default="未提供")
print(f"用户街道地址: {address}")  # 输出: 用户街道地址: 未提供

5. 嵌套数据结构的扁平化

# 嵌套字典扁平化函数
def flatten_dict(d, parent_key='', sep='_'):
    """
    将嵌套字典扁平化为单层字典
    :param d: 要扁平化的字典
    :param parent_key: 父键前缀
    :param sep: 分隔符
    :return: 扁平化后的字典
    """
    items = []
    for k, v in d.items():
        new_key = f"{parent_key}{sep}{k}" if parent_key else k
        if isinstance(v, dict):
            items.extend(flatten_dict(v, new_key, sep=sep).items())
        else:
            items.append((new_key, v))
    return dict(items)

# 测试数据
nested_data = {
    "user": {
        "id": 1001,
        "name": "张伟",
        "preferences": {
            "theme": "dark",
            "language": "zh-CN",
            "notifications": {
                "email": True,
                "sms": False
            }
        }
    },
    "system": {
        "version": "1.2.3",
        "settings": {
            "auto_update": True,
            "backup_interval": 24
        }
    }
}

# 扁平化处理
flat_data = flatten_dict(nested_data)
print("扁平化后的字典:")
for key, value in flat_data.items():
    print(f"{key}: {value}")

6. 使用字典推导式处理嵌套数据

# 学生成绩数据处理
students = {
    "Alice": {"math": 85, "science": 92, "english": 88},
    "Bob": {"math": 78, "science": 85, "english": 82},
    "Charlie": {"math": 92, "science": 88, "english": 95}
}

# 使用字典推导式提取数学成绩
math_scores = {name: scores["math"] for name, scores in students.items()}
print("数学成绩:", math_scores)

# 使用字典推导式找出成绩优秀的学生(平均分>=90)
top_students = {
    name: {
        "average": sum(scores.values()) / len(scores),
        "scores": scores
    }
    for name, scores in students.items()
    if sum(scores.values()) / len(scores) >= 90
}
print("\n优秀学生:")
for name, info in top_students.items():
    print(f"{name}: 平均分 {info['average']:.1f}, 各科成绩 {info['scores']}")

7. 递归遍历嵌套数据结构

# 递归遍历任意嵌套数据结构
def traverse_nested(data, depth=0, indent=4):
    """
    递归遍历并打印嵌套数据结构
    :param data: 要遍历的数据
    :param depth: 当前深度
    :param indent: 缩进空格数
    """
    indent_str = " " * (depth * indent)
    
    if isinstance(data, dict):
        print(f"{indent_str}字典 (长度: {len(data)})")
        for key, value in data.items():
            print(f"{indent_str}键: {key}")
            traverse_nested(value, depth + 1, indent)
    elif isinstance(data, (list, tuple)):
        print(f"{indent_str}列表 (长度: {len(data)})")
        for i, item in enumerate(data):
            print(f"{indent_str}索引: {i}")
            traverse_nested(item, depth + 1, indent)
    else:
        print(f"{indent_str}值: {data} ({type(data).__name__})")

# 测试数据
complex_data = {
    "metadata": {
        "version": "1.0",
        "authors": ["张伟", "李娜", "王强"],
        "created": "2023-07-15",
        "modified": "2023-07-20"
    },
    "content": [
        {
            "id": "s1001",
            "type": "section",
            "data": {
                "title": "引言",
                "paragraphs": [
                    "这是第一段内容...",
                    "这是第二段内容..."
                ]
            }
        },
        {
            "id": "s1002",
            "type": "section",
            "data": {
                "title": "方法",
                "paragraphs": [
                    "我们采用了以下方法...",
                    "具体步骤如下..."
                ],
                "images": ["fig1.png", "fig2.png"]
            }
        }
    ]
}

# 遍历打印数据结构
print("数据结构分析:")
traverse_nested(complex_data)

注意事项

1、控制嵌套深度：通常建议嵌套层级不超过3层，过深的嵌套会降低代码可读性和维护性。

2、使用具名变量：在访问嵌套数据时，使用有意义的中间变量名提高可读性。

# 不推荐
print(data["a"]["b"]["c"]["d"])

# 推荐
user_profile = data["user"]["profile"]
contact_info = user_profile["contact"]
print(contact_info["email"])

3、考虑使用类：对于复杂的数据结构，考虑使用类来封装数据和行为。

4、文档和类型提示：为嵌套数据结构添加文档说明和类型提示。

from typing import Dict, List, Union

UserType = Dict[
    str, 
    Union[
        str, 
        Dict[str, Union[str, int, List[str]]]
    ]
]

def process_user(user: UserType) -> None:
    """处理用户数据
    :param user: 用户字典，格式为{
        "name": str,
        "age": int,
        "contacts": {
            "email": str,
            "phones": List[str]
        }
    }
    """
    # 函数实现...

5、性能考虑：频繁访问深层嵌套数据可能影响性能，必要时可以扁平化数据结构或使用缓存。

6、错误处理：使用 try-except 或 dict.get() 方法处理可能缺失的键。

# 安全访问方式
email = user.get("profile", {}).get("contact", {}).get("email", "default@example.com")

Python的嵌套数据结构提供了强大的工具来组织和处理复杂数据。通过灵活组合列表和字典，可以创建出能够精确表示现实世界复杂关系的数据模型。通过合理运用这些最佳实践，可以确保嵌套数据结构既灵活又易于维护，满足复杂应用场景的需求。

“无他，惟手熟尔”！有需要就用起来。

如果你觉得这篇文章有用，欢迎点赞、转发、收藏、留言、推荐❤！

本文参与腾讯云自媒体同步曝光计划，分享自微信公众号。

原始发表：2025-08-18，如有侵权请联系 cloudcommunity@tencent.com 删除

遍历

本文分享自 Nicholas与Pypi 微信公众号，前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

登录后参与评论

0 条评论

热度