Python字典与列表推导式：从基础到高级应用

1. Python字典：从基础操作到高级用法

字典（Dictionary）是Python中最强大、最常用的数据结构之一。作为零基础学习者，你可能已经接触过列表和元组，但字典的键值对结构会给你带来全新的编程体验。

1.1 字典的创建与基本操作

创建字典最简单的方式是使用花括号：

python复制# 创建空字典
empty_dict = {}

# 创建包含初始键值对的字典
student = {
    "name": "张三",
    "age": 20,
    "courses": ["数学", "英语"]
}

字典的键必须是不可变类型（如字符串、数字或元组），而值可以是任意Python对象。这个特性在实际开发中非常有用：

python复制# 有效的字典键示例
valid_keys_dict = {
    1: "数字键",
    "two": "字符串键",
    (3, 4): "元组键"
}

# 无效的字典键会引发TypeError
invalid_dict = {
    [1, 2]: "列表不能作为键"  # 会报错
}

访问字典元素有两种安全的方式：

python复制# 直接访问 - 键不存在会引发KeyError
print(student["name"])

# 使用get方法 - 键不存在返回None或默认值
print(student.get("grade"))  # 返回None
print(student.get("grade", "A"))  # 返回默认值"A"

1.2 字典的常用方法

Python字典提供了丰富的方法来操作数据：

python复制# 添加或修改元素
student["grade"] = "A"  # 添加新键值对
student["age"] = 21  # 修改已有键的值

# 删除元素
del student["courses"]  # 删除键值对
removed_value = student.pop("age")  # 删除并返回对应的值

# 获取所有键、值或键值对
keys = student.keys()  # 返回所有键的视图
values = student.values()  # 返回所有值的视图
items = student.items()  # 返回所有键值对的视图

注意：在Python 3中，keys()、values()和items()返回的是视图对象，而不是列表。这意味着它们会动态反映字典的变化。

1.3 字典的高级用法

字典推导式（Dictionary Comprehension）是创建字典的简洁方式：

python复制# 将列表转换为字典
numbers = [1, 2, 3]
squared_dict = {x: x**2 for x in numbers}
# 结果：{1: 1, 2: 4, 3: 9}

# 条件过滤的字典推导式
even_squares = {x: x**2 for x in range(10) if x % 2 == 0}

字典合并有多种方法，Python 3.5+提供了最简洁的方式：

python复制dict1 = {"a": 1, "b": 2}
dict2 = {"b": 3, "c": 4}

# 方法1：update方法（会修改原字典）
dict1.update(dict2)  # dict1变为{"a":1, "b":3, "c":4}

# 方法2：字典解包（Python 3.5+）
merged_dict = {**dict1, **dict2}

# 方法3：collections.ChainMap（创建视图而非新字典）
from collections import ChainMap
chain = ChainMap(dict1, dict2)

2. 深拷贝与浅拷贝：理解Python的对象复制机制

在Python中，理解拷贝机制对于避免意外的数据修改至关重要。这涉及到可变对象（如列表、字典）和不可变对象（如数字、字符串、元组）的区别。

2.1 赋值、浅拷贝与深拷贝的区别

让我们通过一个例子来理解这三种操作的区别：

python复制import copy

original = {
    "name": "Alice",
    "scores": [90, 85, 95],
    "info": {"age": 25, "city": "New York"}
}

# 赋值 - 只是创建新引用
assigned = original

# 浅拷贝 - 创建新容器，但内部对象是引用
shallow_copied = copy.copy(original)

# 深拷贝 - 完全独立的副本
deep_copied = copy.deepcopy(original)

修改这些变量会看到不同效果：

python复制original["name"] = "Bob"  # assigned也会改变
original["scores"].append(100)  # assigned和shallow_copied都会改变
original["info"]["age"] = 26  # assigned和shallow_copied都会改变

# 只有deep_copied完全不受影响

2.2 何时使用浅拷贝与深拷贝

浅拷贝适用于：

• 对象只包含不可变类型
• 你希望共享内部可变对象的引用
• 性能要求高（深拷贝更耗时）

深拷贝适用于：

• 对象包含多层嵌套的可变结构
• 你需要完全独立的副本
• 数据需要被安全地传递或修改

实际经验：在处理配置数据或复杂数据结构时，我通常会使用深拷贝来避免意外的副作用。但在性能敏感的场景下，可以考虑使用浅拷贝并谨慎操作。

2.3 自定义拷贝行为

对于自定义类，你可以通过实现__copy__和__deepcopy__方法来控制拷贝行为：

python复制class MyClass:
    def __init__(self, value):
        self.value = value
        self.children = []
    
    def __copy__(self):
        new_obj = MyClass(self.value)
        new_obj.children = self.children.copy()  # 浅拷贝children
        return new_obj
    
    def __deepcopy__(self, memo):
        new_obj = MyClass(copy.deepcopy(self.value, memo))
        new_obj.children = copy.deepcopy(self.children, memo)
        return new_obj

3. 列表推导式：Pythonic的列表创建方式

列表推导式（List Comprehension）是Python中创建列表的简洁、高效方式，也是Pythonic编程的重要体现。

3.1 基础列表推导式

基本语法是[expression for item in iterable]：

python复制# 创建平方数列表
squares = [x**2 for x in range(10)]
# 结果：[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 处理字符串列表
words = ["hello", "world", "python"]
upper_words = [word.upper() for word in words]
# 结果：['HELLO', 'WORLD', 'PYTHON']

3.2 带条件的列表推导式

可以在推导式中添加条件：

python复制# 只包含偶数的平方
even_squares = [x**2 for x in range(10) if x % 2 == 0]
# 结果：[0, 4, 16, 36, 64]

# 条件表达式也可以放在前面
results = ["Pass" if score >= 60 else "Fail" for score in [85, 45, 72]]
# 结果：['Pass', 'Fail', 'Pass']

3.3 嵌套列表推导式

列表推导式可以嵌套，用于处理多维数据结构：

python复制# 展平二维列表
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = [num for row in matrix for num in row]
# 结果：[1, 2, 3, 4, 5, 6, 7, 8, 9]

# 转置矩阵
transposed = [[row[i] for row in matrix] for i in range(3)]
# 结果：[[1, 4, 7], [2, 5, 8], [3, 6, 9]]

3.4 列表推导式与生成器表达式

对于大数据集，生成器表达式（Generator Expression）更节省内存：

python复制# 列表推导式 - 立即计算并存储所有结果
list_comp = [x**2 for x in range(1000000)]  # 占用大量内存

# 生成器表达式 - 按需生成结果
gen_exp = (x**2 for x in range(1000000))  # 几乎不占内存

4. 综合应用：数据处理实战

让我们通过一个实际案例来综合运用这些知识点。假设我们有一组学生数据，需要进行各种处理：

python复制students = [
    {"name": "Alice", "scores": [85, 90, 78], "info": {"age": 20, "major": "CS"}},
    {"name": "Bob", "scores": [92, 88, 95], "info": {"age": 21, "major": "Math"}},
    {"name": "Charlie", "scores": [78, 82, 80], "info": {"age": 19, "major": "Physics"}}
]

4.1 使用列表推导式处理数据

计算每个学生的平均分：

python复制avg_scores = [
    {
        "name": student["name"],
        "avg_score": sum(student["scores"]) / len(student["scores"])
    }
    for student in students
]

筛选特定专业的学生：

python复制cs_students = [student for student in students if student["info"]["major"] == "CS"]

4.2 使用字典组织数据

创建按专业分组的字典：

python复制from collections import defaultdict

major_dict = defaultdict(list)
for student in students:
    major_dict[student["info"]["major"]].append(student["name"])

# 结果：{'CS': ['Alice'], 'Math': ['Bob'], 'Physics': ['Charlie']}

4.3 深拷贝的应用场景

当我们需要修改学生数据而不影响原数据时：

python复制import copy

# 创建深拷贝
students_copy = copy.deepcopy(students)

# 修改拷贝
students_copy[0]["scores"].append(95)
students_copy[0]["info"]["age"] = 21

# 原数据保持不变
print(students[0]["scores"])  # 仍然是[85, 90, 78]
print(students[0]["info"]["age"])  # 仍然是20

4.4 性能优化技巧

在处理大型数据集时，组合使用生成器表达式和字典推导式可以显著提高性能：

python复制# 大型数据集示例
big_data = [{"id": i, "value": i*2} for i in range(1000000)]

# 高效创建字典
id_to_value = {item["id"]: item["value"] for item in big_data}

# 使用生成器表达式过滤
high_values = (value for value in id_to_value.values() if value > 1000000)

在实际项目中，我发现合理使用这些Python特性不仅使代码更简洁，还能提高执行效率。特别是在数据处理和转换场景中，列表推导式和字典操作往往比传统的循环方式快得多。