一文搞定Python中的字典查值、元组防改与集合去重(进阶必学)

前言

在前几篇笔记里，我们聊了字符串和列表，它们都属于序列类型。今天开始，咱们来深入看看另外三种核心数据结构：字典、元组和集合。它们各自有独特的性格——字典靠键找值，元组一旦创建就不许变，集合则天生爱去重。掌握了它们，你的Python数据处理能力绝对能上一个台阶。

• 字典（dict）：通过“键”来查找“值”，就像查字典一样快速。
• 元组（tuple）：与列表类似，但一旦创建就不能修改，适合存储固定数据。
• 集合（set）：无序且元素唯一，支持并集、交集等数学运算。

好，咱们一个一个来拆解。

一、字典（dict）

字典说白了就是键值对（key-value）的映射结构，用大括号 {} 装起来，键和值之间用冒号 : 隔开，键值对之间用逗号 , 分隔。键必须唯一且不可变（通常用字符串、数字），值可以是任意类型——灵活得很。

为什么需要字典

拿列表来对比一下：列表只能通过下标访问元素，你根本看不出那个数字代表什么含义；而字典用有意义的键来取值，代码自解释性直接拉满。

# 列表方式（无法直接看出 98 是什么成绩）
list1 = ["语文", 98, "数学", 96, "英语", 100]
print(list1[1])   # 98

# 字典方式（一目了然）
dict1 = {"语文": 98, "数学": 96, "英语": 100}
print(dict1["语文"])   # 98

字典的创建

# 方式1：大括号直接创建
person = {'name': 'Alice', 'age': 25, 'city': 'New York'}

# 方式2：使用 dict() 构造函数
person2 = dict(name='Bob', age=30)

# 方式3：两个列表拼成字典（使用 zip）
keys = ['name', 'age', 'city']
values = ['charlie', 35, 'chicago']
dict3 = dict(zip(keys, values))
print(dict3)   # {'name': 'charlie', 'age': 35, 'city': 'chicago'}

获取字典元素

print(person['name'])        # Alice（如果键不存在会报错 KeyError）
print(person.get('age'))     # 25（键不存在返回 None，不报错）

修改与添加元素

# 修改已存在的键
person['age'] = 26

# 添加新键值对（直接赋值不存在的键）
person['email'] = 'alice@example.com'
print(person)   # {'name': 'Alice', 'age': 26, 'city': 'New York', 'email': 'alice@example.com'}

删除元素

# del 语句
del person['city']

# pop() 方法：删除并返回对应的值
email = person.pop('email')
print(email)   # alice@example.com

字典常用方法

综合练习：个人信息管理

# 1. 创建字典
person = {'name': 'Da vid', 'age': 40, '职业': '工程师'}

# 2. 获取名字
print("Name:", person['name'])

# 3. 修改年龄
person['age'] = 41
print("Updated Age:", person['age'])

# 4. 添加邮箱
person['email'] = 'da vid@example.com'
print("Email:", person['email'])

# 5. 删除职业
del person['职业']
print("删除后的个人信息:", person)

# 6. 批量更新
person.update({'name': 'Da vid Smith', '城市': '旧金山'})
print("更新后的信息:", person)

二、元组（tuple）

元组是不可变的序列，用圆括号 () 表示。一旦创建，你就没法再添加、删除或修改里面的元素了。这种“死板”的特性，恰恰让它适合存储坐标、日期这类固定不变的数据。

创建元组

# 包含多个元素
tuple1 = (1, 2, 3)

# 空元组
tuple2 = ()

# 单个元素的元组（注意逗号！）
tuple3 = (4,)   # 如果不加逗号，会被当作整数 4
print(type(tuple3))   # 

访问与切片（与列表类似）

tuple5 = (12, 13, 14, 15, 16)
print(tuple5[1])      # 13
print(tuple5[1:4])    # (13, 14, 15)
print(len(tuple5))    # 5

不可变性（重点）

tuple7 = (20, 21, 22)
# tuple7[0] = 23   # 会引发 TypeError: 'tuple' object does not support item assignment

其他操作

# 将列表转换为元组
list_to_tuple = tuple([6, 7, 8, 9])
print(list_to_tuple)   # (6, 7, 8, 9)

三、集合（set）

集合是无序、元素唯一的数据结构，用大括号 {} 表示，但不能是空的——空 {} 会被当成字典。集合最常用的场景就是去重和集合运算（并集、交集、差集）。

创建集合

# 使用大括号
set1 = {1, 2, 3, 4, 5}

# 使用 set() 函数（可去重）
set2 = set([1, 2, 2, 3, 4, 4, 5])   # {1, 2, 3, 4, 5}

# 空集合（必须用 set()，不能用 {}）
empty_set = set()

集合的基本操作

# 添加元素
set1.add(6)

# 删除元素（如果元素不存在会报错 KeyError）
set1.remove(3)

# 清空集合
set1.clear()

# 判断元素是否存在
print(4 in set2)   # True

集合的数学运算

setA = {1, 2, 3, 4}
setB = {3, 4, 5, 6}

# 并集（所有元素）
print(setA | setB)   # {1, 2, 3, 4, 5, 6}

# 交集（共同元素）
print(setA & setB)   # {3, 4}

# 差集（在A但不在B）
print(setA - setB)   # {1, 2}

常用方法

综合练习

setA = {1, 2, 3, 4}
setB = {3, 4, 5, 6}

setA.add(7)
print("添加之后:", setA)   # {1, 2, 3, 4, 7}

setA.remove(2)
print("删除之后:", setA)   # {1, 3, 4, 7}

print("并集:", setA | setB)   # {1, 3, 4, 5, 6, 7}
print("交集:", setA & setB)   # {3, 4}
print("差集:", setA - setB)   # {1, 7}

作业（请先独立完成，再对照答案）

一、单选题

1.下列关于列表下标取值的说法，正确的是（ ）

• A. 列表下标只能从 0 开始正向取值，不能反向（如 -1）
• B. 嵌套列表 l = [1, [2, [3]]] 中，取 3 的写法是 l[1][1][0]
• C. 列表下标越界不会报错
• D. 列表 ['a', 'b'] 中，列表为 [2] 会返回空值

2.执行 l = [11,22,33]; l.append(44); l.insert(1,55) 后，列表 l 的结果是（ ）

• A. [11,55,22,33,44]
• B. [55,11,22,33,44]
• C. [11,22,33,55,44]
• D. [11,22,55,33,44]

3.字典 d = {'name':'maiya', 'age':18}，下列操作错误的是（ ）

• A. print(d['name'])
• B. d['gender'] = '女'
• C. print(d[0])
• D. del d['age']

4.关于元组的特性，描述正确的是（ ）

• A. 元组支持 append() 函数添加元素
• B. 元组 (10) 和表示存储一个数据
• C. 元组支持下标取值，但不支持切片
• D. 元组一旦定义，内部元素无法修改

5.字典 d = {'a':1, 'b':2, 'a':3}，打印 d['a'] 的结果是（ ）

• A. 1
• B. 2
• C. 3
• D. 报错

二、编程题

1.定义列表 l = [5, 8, 2, 9, 1, 8]，完成以下操作：

• a. 删除列表中所有的数字 8；
• b. 在列表末尾添加数字 10；
• c. 将列表中索引为 2 的元素修改为 7；
• d. 打印最终的列表。

2.定义字典 student = {'name':'张三', 'score':85, 'gender':'男'}，完成以下操作：

• a. 新增键值对 'age':18；
• b. 将分数（score）修改为 90；
• c. 删除性别（gender）键值对；
• d. 打印字典中所有的键和所有的值。

（选做题）定义嵌套列表 l = ['python', ['ja va', ['c++', 'ja vascript'], 'php'], 'ruby']，通过下标取值提取出 ja vascript 并打印。

作业答案

单选题答案

编程题答案

1. 列表操作

l = [5, 8, 2, 9, 1, 8]

# a. 删除所有 8（使用循环，注意删除时倒序或用 while）
while 8 in l:
    l.remove(8)

# b. 末尾添加 10
l.append(10)

# c. 修改索引 2 的元素为 7
l[2] = 7

# d. 打印
print(l)   # [5, 2, 7, 1, 10]

2. 字典操作

student = {'name': '张三', 'score': 85, 'gender': '男'}

# a. 新增 age
student['age'] = 18

# b. 修改分数
student['score'] = 90

# c. 删除 gender
del student['gender']

# d. 打印所有键和所有值
print("键:", student.keys())
print("值:", student.values())

3. 嵌套列表取值（选做题）

l = ['python', ['ja va', ['c++', 'ja vascript'], 'php'], 'ruby']
# ja vascript 在 l[1][1][1]
print(l[1][1][1])   # ja vascript

总结

这篇笔记把字典、元组、集合的核心知识梳理了一遍：

• 字典：键值对映射，通过键快速取值。常用操作：增删改查、keys()、values()、items()。
• 元组：不可变序列，适用于固定数据。注意单元素元组必须加逗号。
• 集合：无序、元素唯一，支持去重和数学运算（并集 |、交集 &、差集 -）。

这三种数据结构在实际开发中使用频率极高，建议结合练习题多敲几遍，真正内化成自己的技能。