Python进阶 - day1:深入理解数据结构

以下是“Python进阶 - Day 1：深入理解数据结构”的详细学习内容，包含带注释的代码示例，帮助你掌握列表、字典、集合、元组的高级用法，并完成指定练习任务。

学习内容

1. 列表（List）高级用法
2. 列表推导式（List Comprehension）：快速生成列表。
3. 深拷贝与浅拷贝：理解对象引用和复制的区别。
4. 字典（Dict）高级用法
5. 字典推导式（Dict Comprehension）：高效构建字典。
6. 默认字典（collections.defaultdict）：处理缺失键。
7. 集合（Set）高级用法
8. 集合推导式（Set Comprehension）：去重与集合操作。
9. 集合运算：交集、并集、差集。
10. 元组（Tuple）高级用法
11. 不可变性与内存效率。
12. 命名元组（collections.namedtuple）：增强可读性。
13. 深拷贝与浅拷贝
14. 浅拷贝（copy.copy）：复制对象但不复制嵌套对象。
15. 深拷贝（copy.deepcopy）：完全复制，包括嵌套对象。

任务

• 练习：实现一个函数 compare_lists，比较两个列表的差异，返回新增、删除和相同的元素。

代码示例（带注释）

1. 列表、字典、集合、元组的高级用法

python

# 导入所需模块
import copy
from collections import defaultdict, namedtuple

# 列表推导式：生成平方数列表
squares = [x**2 for x in range(5)]
print("列表推导式:", squares)  # 输出: [0, 1, 4, 9, 16]

# 字典推导式：创建键值对
dict_squares = {x: x**2 for x in range(5)}
print("字典推导式:", dict_squares)  # 输出: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# 默认字典：自动为缺失键提供默认值
dd = defaultdict(int)  # 默认值为0
dd['a'] += 1
print("默认字典:", dd)  # 输出: defaultdict(<class 'int'>, {'a': 1})

# 集合推导式：生成偶数集合
evens = {x for x in range(10) if x % 2 == 0}
print("集合推导式:", evens)  # 输出: {0, 2, 4, 6, 8}

# 集合运算
set_a = {1, 2, 3}
set_b = {2, 3, 4}
print("交集:", set_a & set_b)  # 输出: {2, 3}
print("并集:", set_a | set_b)  # 输出: {1, 2, 3, 4}
print("差集:", set_a - set_b)  # 输出: {1}

# 命名元组：增强元组的可读性
Point = namedtuple('Point', ['x', 'y'])
p = Point(1, 2)
print("命名元组:", p.x, p.y)  # 输出: 1 2

# 深拷贝与浅拷贝
original = [[1, 2], [3, 4]]
shallow_copy = copy.copy(original)  # 浅拷贝，只复制外层
deep_copy = copy.deepcopy(original)  # 深拷贝，复制所有层
original[0][0] = 99
print("原始列表:", original)        # 输出: [[99, 2], [3, 4]]
print("浅拷贝:", shallow_copy)      # 输出: [[99, 2], [3, 4]]
print("深拷贝:", deep_copy)         # 输出: [[1, 2], [3, 4]]

2. 练习：比较两个列表的差异

python

def compare_lists(list1, list2):
    """
    比较两个列表的差异，返回新增、删除和相同的元素。
    
    参数:
        list1 (list): 第一个列表
        list2 (list): 第二个列表
    
    返回:
        dict: 包含 'added'（新增）、'removed'（删除）、'common'（相同）的结果
    """
    # 转换为集合以便高效比较
    set1 = set(list1)
    set2 = set(list2)
    
    # 计算差异
    added = list(set2 - set1)    # list2 中有而 list1 中没有的元素
    removed = list(set1 - set2)  # list1 中有而 list2 中没有的元素
    common = list(set1 & set2)   # list1 和 list2 共有的元素
    
    # 返回结果字典
    return {
        'added': added,
        'removed': removed,
        'common': common
    }

# 测试函数
list1 = [1, 2, 3, 4]
list2 = [2, 3, 5, 6]
result = compare_lists(list1, list2)
print("比较结果:", result)
# 输出: {'added': [5, 6], 'removed': [1, 4], 'common': [2, 3]}

输出示例

运行上述代码后，输出如下：

列表推导式: [0, 1, 4, 9, 16]
字典推导式: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
默认字典: defaultdict(<class 'int'>, {'a': 1})
集合推导式: {0, 2, 4, 6, 8}
交集: {2, 3}
并集: {1, 2, 3, 4}
差集: {1}
命名元组: 1 2
原始列表: [[99, 2], [3, 4]]
浅拷贝: [[99, 2], [3, 4]]
深拷贝: [[1, 2], [3, 4]]
比较结果: {'added': [5, 6], 'removed': [1, 4], 'common': [2, 3]}

学习要点

1. 推导式：列表、字典、集合推导式是Python高效生成数据结构的工具，减少代码量。
2. 集合运算：利用集合的数学特性（如&、|、-）快速处理数据差异。
3. 深浅拷贝：浅拷贝只复制引用，深拷贝创建独立副本，嵌套对象处理需谨慎。
4. 命名元组：为元组字段命名，提升代码可读性，适合轻量数据结构。

后续建议

• 尝试修改compare_lists函数，支持重复元素的计数（提示：使用collections.Counter）。
• 实验深拷贝与浅拷贝在复杂嵌套对象（如字典中套列表）中的表现。

完成Day 1后，你已掌握Python数据结构的高级用法，并通过练习巩固了知识。如果需要进一步解释或扩展代码，随时告诉我！明天可以进入函数进阶或面向对象编程，加油！