Python从入门到精通——第六章 字典与集合

一.字典的创建与访问

        字典（Dictionary）是Python中一种非常常用的数据结构，它存储键值对（key-value pairs），具有高效的查找能力。

（一）创建字典

1.直接创建字典

        将若干组“键值对”放在一对大括号“{}”中即可直接创建一个字典。

语法格式：

{键1:值1,键2:值2}

示例：

# 创建空字典
empty_dict = {}# 创建有内容的字典
person = {"name": "Alice","age": 25,"city": "New York"
}

2.使用内置函数dict()创建字典

        字典存储的是“键”与“值”之间一一对应的关系，因此Python语言也支持将一组双元素序列转换为字典。这需要使用内置函数dict()。

# 创建空字典
empty_dict = dict()# 使用关键字参数创建
person = dict(name="Bob", age=30, city="London")# 从键值对序列创建
person = dict([("name", "Charlie"), ("age", 35), ("city", "Paris")])

【注意】

（1）键具有唯一性，字典中不允许出现相同的键，但是不同的键允许对应相同的值。

（2）字典中的键必须是不可变的类型，一般是字符串、数字或者元组；而值却可以是任何数据类型。

（二）访问字典

        字典中存储了若干条目，但是都是无序的。这意味着字典没有索引的概念，它不通过索引访问条目，而是通过键访问条目。

语法格式：

字典名[键]

示例：

person = {"name": "Alice", "age": 25, "city": "New York"}# 访问存在的键
print(person["name"])  # 输出: Alice# 访问不存在的键会引发KeyError
# print(person["job"])  # 会引发KeyError

二.字典的基本操作

        字典存放的是数据与数据之间的映射关系，对应的条目是“键值对”。所以，字典的操作都会涉及“键”和“值”两个部分。

（一）空字典与字典更新

1.添加条目

        给字典添加条目即添加一对新的“键值对”，只要通过如下的赋值语句完成“值”与“键”的映射就可以。

语法格式：

字典名[键]=值

示例：

my_dict = {"name": "Alice", "age": 25}
my_dict["city"] = "New York"  # 添加新的键值对
print(my_dict)  # 输出: {'name': 'Alice', 'age': 25, 'city': 'New York'}

2.修改条目

语法格式：

字典名[键]=值

示例：

my_dict = {"name": "Alice", "age": 25}
my_dict["age"] = 26  # 更新已有键的值
print(my_dict)  # 输出: {'name': 'Alice', 'age': 26, 'city': 'New York'}

        对照添加条目和修改条目的示例代码段可以看出，赋值语句“字典名[键]=值”是一个双重操作，当其中的键在字典中不存在时，执行的是添加条目的操作；键在字典中存在时就执行修改条目的操作。

（二）删除字典条目

        当字典中的条目不再需要的时候，就需要用到字典的删除操作。Python语言提供了多种命令和方法来实现字典的删除，但是都需要通过键来指定要删除的条目。

1.使用del命令删除指定条目

语法格式：

del 字典名[键]

示例：

my_dict = {"name": "Alice", "age": 25, "city": "New York"}# 删除指定键的条目
del my_dict["age"]
print(my_dict)  # 输出: {'name': 'Alice', 'city': 'New York'}

2.使用pop()方法删除指定条目

语法格式：

字典名.pop(键，默认值)

        字典的pop()方法与在列表中介绍的类似，它在闪电湖指定键的对应条目时也会“弹出”（即返回）一个值。如果指定的键在字典中存在，pop()方法弹出键对应的值；如果键不存在，则弹出默认值。

示例：

my_dict = {"name": "Alice", "age": 25, "city": "New York"}# 删除并获取指定键的值
age = my_dict.pop("age")
print(age)  # 输出: 25
print(my_dict)  # 输出: {'name': 'Alice', 'city': 'New York'}

【注意】

（1）当不确定指定的键在字典中是否存在时，需要给出默认值，否则删除字典中不存在的条目时系统会报错。

（2）使用pop()方法时，最少要包含一个用于指定键的参数，如果参数都缺省的话，系统会报错。

3.用popitem()方法随机删除字典条目

语法格式：

字典名.popitem()

示例：

my_dict = {"name": "Alice", "age": 25, "city": "New York"}# 删除并返回一个键值对
item = my_dict.popitem()
print(item)  # 可能是 ('city', 'New York')
print(my_dict)  # 剩余的字典内容

        从上述的示例可以看出，删除的条目会以元组的形式返回。

popitem()方法与pop()方法的区别：

特性	popitem()	pop()
参数	不需要参数	需要指定key参数
返回值	返回 (key, value) 元组	只返回value
删除方式	删除最后插入项(Python 3.7+)	删除指定key的项
空字典处理	引发KeyError	如果key不存在可能引发KeyError

4.用clear()方法清空字典条目

语法格式：

字典名.clear()

示例：

my_dict = {"name": "Alice", "age": 25, "city": "New York"}# 清空字典
my_dict.clear()print(my_dict)  # 输出: {}
print(len(my_dict))  # 输出: 0

               如果虚伪删除字典中的所有条目，可以执行多次del命令，或者多次调用pop()和popitem()方法。也可以直接调用clear()方法一次性清空字典。

        调用了clear()方法的字典虽然删除了所有的条目，但依然是一个字典（一个空字典）。后续可以继续采用添加条目的方式向其中增加新的内容。

5.直接删除整个字典

语法格式：

del 字典名

示例：

my_dict = {"name": "Alice", "age": 25, "city": "New York"}# 删除整个字典
del my_dict# 尝试访问已删除的字典会引发错误
print(my_dict)  # 引发 NameError: name 'my_dict' is not defined

        前面介绍的clear()方法清空了字典中的条目，但是保留了字典的结构。而“del 字典名”操作却会直接删除字典本身，即从内存中注销掉该字典对象。

（三）查找字典条目

1.成员运算符in

语法格式：

键 in 字典

示例：

        在查找对应条目前可以先试用in运算符确认指定的键是否在字典中，如果存在，则运算结果为True；如果不存在，则运算结果为False。

my_dict = {"name": "Alice", "age": 25, "city": "New York"}# 检查键是否存在
print("name" in my_dict)    # 输出: True
print("country" in my_dict) # 输出: False

2.用get()方法获取条目的值

语法格式：

字典名.get(键,默认值)

示例：

        get()方法按照指定的键访问字典中对应条目的值，如果指定的键在字典中不存在，则返回默认值。

my_dict = {"name": "Alice", "age": 25, "city": "New York"}# 获取存在的键
print(my_dict.get("name"))  # 输出: Alice# 获取不存在的键
print(my_dict.get("country"))  # 输出: None

三.字典的整体操作

（一）字典的遍历

1.遍历字典中所有的键

        字典有一个称为keys()的方法，可以用来返回字典中所有的键。keys()方法配合for循环一起使用时就可以遍历字典中每一个键。

my_dict = {"name": "Alice", "age": 25, "city": "New York"}# 方法1：直接遍历字典（默认遍历键）
for key in my_dict:print(key)# 方法2：使用keys()方法
for key in my_dict.keys():print(key)

输出：

name
age
city

        通过keys()方法可以遍历字典中所有的键，也可以通过键与值的映射访问对应的值，从而遍历所有的条目信息。

2.遍历字典中所有的值

        与keys()方法相对应，字典也提供了一个用来返回所有值的方法values()。同样地，values()方法配合for循环一起使用就可以遍历字典中所有的值。

# 使用values()方法
for value in my_dict.values():print(value)

输出：

Alice
25
New York

        借助values()方法虽然可以遍历出字典中所有的值，但是值却无法映射到对应的键，因而无法便利完整的条目信息。

3.遍历字典中所有的条目

        keys()方法和values()方法只能单独给出自己的键或者值的内容，而字典的items()方法却能以“（键，值）”的形式返回所有的条目。

# 使用items()方法
for key, value in my_dict.items():print(f"{key}: {value}")

输出：

name: Alice
age: 25
city: New York

（二）字典的排序

        字典本身是无序的或保持插入顺序，但我们可以通过多种方式对字典进行排序操作。

1.按键排序

方法1：使用sorted()函数

my_dict = {'banana': 3, 'apple': 2, 'pear': 1, 'orange': 4}# 按键排序（字母顺序）
sorted_dict = {k: my_dict[k] for k in sorted(my_dict)}
print(sorted_dict)  # 输出: {'apple': 2, 'banana': 3, 'orange': 4, 'pear': 1}

方法2：使用operator模块

import operator# 按键排序
sorted_items = sorted(my_dict.items(), key=operator.itemgetter(0))
sorted_dict = dict(sorted_items)
print(sorted_dict)

2.按值排序

方法1：使用lambda表达式

# 按值升序排序
sorted_dict = {k: v for k, v in sorted(my_dict.items(), key=lambda item: item[1])}
print(sorted_dict)  # 输出: {'pear': 1, 'apple': 2, 'banana': 3, 'orange': 4}# 按值降序排序
sorted_dict = {k: v for k, v in sorted(my_dict.items(), key=lambda item: item[1], reverse=True)}
print(sorted_dict)  # 输出: {'orange': 4, 'banana': 3, 'apple': 2, 'pear': 1}

方法2：使用operator模块

import operator# 按值排序
sorted_items = sorted(my_dict.items(), key=operator.itemgetter(1))
sorted_dict = dict(sorted_items)
print(sorted_dict)

3.复杂排序

多条件排序

people = {'Alice': {'age': 25, 'score': 90},'Bob': {'age': 30, 'score': 85},'Charlie': {'age': 25, 'score': 95}
}# 先按年龄升序，再按分数降序
sorted_people = dict(sorted(people.items(), key=lambda x: (x[1]['age'], -x[1]['score'])))
print(sorted_people)

（三）字典的合并

1. 使用 update() 方法（原地修改）

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}dict1.update(dict2)
print(dict1)  # 输出: {'a': 1, 'b': 3, 'c': 4}

特点：

• 修改原字典（dict1）

• 重复键的值会被dict2中的值覆盖

2. 字典解包

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}merged_dict = {**dict1, **dict2}
print(merged_dict)  # 输出: {'a': 1, 'b': 3, 'c': 4}

特点：

• 创建新字典，不修改原字典

• 可以合并多个字典：{**dict1, **dict2, **dict3}

• 后面的字典会覆盖前面字典的相同键

3. 使用 | 合并运算符

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}merged_dict = dict1 | dict2
print(merged_dict)  # 输出: {'a': 1, 'b': 3, 'c': 4}

特点：

• 语法简洁

• 创建新字典，不修改原字典

• 也支持原地合并：dict1 |= dict2

四.集合

        集合(Set)是Python中一种重要的内置数据类型，它提供了一种存储无序、不重复元素的高效方式。

（一）集合的基本特性

• 无序性：集合中的元素没有固定顺序

• 唯一性：集合自动去除重复元素

• 可变性：集合是可变的，可以增删元素

• 可哈希性：集合元素必须是不可变类型（数字、字符串、元组等）

（二）创建集合

方法1：使用花括号

fruits = {'apple', 'banana', 'orange'}

方法2：使用set()构造函数

numbers = set([1, 2, 3, 4, 5])  # 从列表创建
chars = set("hello")            # 从字符串创建 → {'h', 'e', 'l', 'o'}

方法3：空集合的创建

empty_set = set()  # 正确方式
not_empty = {}     # 这是创建空字典，不是集合！

（三）集合的基本操作

添加元素

fruits.add('mango')       # 添加单个元素
fruits.update(['kiwi', 'pear'])  # 添加多个元素

删除元素

fruits.remove('banana')   # 存在则删除，不存在则报错
fruits.discard('banana')  # 存在则删除，不存在也不报错
popped = fruits.pop()     # 随机删除并返回一个元素
fruits.clear()            # 清空集合

成员检测

'apple' in fruits   # True
'pear' not in fruits  # True

（四）集合运算

并集 (Union)

a = {1, 2, 3}
b = {3, 4, 5}
print(a | b)          # {1, 2, 3, 4, 5}
print(a.union(b))     # 同上

交集 (Intersection)

print(a & b)          # {3}
print(a.intersection(b))  # 同上

差集 (Difference)

print(a - b)          # {1, 2}
print(a.difference(b))  # 同上

对称差集 (Symmetric Difference)

print(a ^ b)          # {1, 2, 4, 5}
print(a.symmetric_difference(b))  # 同上