Python 入门手札：从 0 到会--第三天Python的基本数据类型之容器类型 dict ，set，frozenset

目录

一、集合类型-set && frozenset

1. 基本概念

2. 集合的创建

3. 集合常用操作

4. 集合之间的操作

5. 集合的比较

6. 集合更新操作（只能用于 set，frozenset 不支持）

7. 不可变集合：frozenset

8. 集合运算符与方法的非运算符版本

9. 集合和字典的关系

二、字典（dict）

1. 映射类型

2. 字典的键（key）

3. 字典的创建

4. 字典的常见操作

5. 字典视图对象

6. 常见字典方法

7. 字典的排序与逆序

8. 字典的合并

9. 字典的比较

10. 字典在实际中的应用场景

---

一、集合类型-set && frozenset

集合（set）是一种无序、唯一且不可变的数据结构，通常用于执行数学中的集合运算，如交集、并集、差集和对称差集等。集合的元素必须是可哈希的（hashable），不能包含可变类型（如列表）。

1. 基本概念

• set：可变的集合类型，支持增、删、改操作。集合元素必须是可哈希的类型，如数字、字符串、元组等。

• frozenset：不可变的集合类型，内容不可更改，因此可以作为字典的键或其他集合的元素。

2. 集合的创建

• 使用花括号创建：

  my_set = {'jack', 'sjoerd'}

• 使用构造器创建：

  my_set = set([1, 2, 3])
  frozenset_example = frozenset([1, 2, 3])

• 集合推导式：

  my_set = {c for c in 'abracadabra' if c not in 'abc'}

3. 集合常用操作

• 添加元素：使用 add() 方法

  my_set.add('new_element')

• 删除元素：使用 remove() 或 discard() 方法

  • remove() 会在元素不存在时引发 KeyError

  • discard() 在元素不存在时不会引发错误

  my_set.remove('jack')  # 会引发 KeyError 如果 'jack' 不存在
  my_set.discard('jack')  # 不会引发错误

• 随机移除元素：使用 pop()

  element = my_set.pop()  # 移除并返回一个随机元素

• 清空集合：使用 clear()

  my_set.clear()  # 清空所有元素

• 集合的大小：使用 len()

  len(my_set)  # 返回集合中元素的个数

• 成员检测：使用 in 和 not in

  'jack' in my_set  # 检查元素是否在集合中
  'jack' not in my_set  # 检查元素是否不在集合中

4. 集合之间的操作

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}

交集（Intersection）

print(set1 & set2)                      # {3, 4}
print(set1.intersection(set2))         # {3, 4}

并集（Union）

print(set1 | set2)                      # {1, 2, 3, 4, 5, 6}
print(set1.union(set2))                # {1, 2, 3, 4, 5, 6}

差集（Difference）

print(set1 - set2)                      # {1, 2}（set1 中有但 set2 中没有）
print(set1.difference(set2))           # {1, 2}

对称差集（Symmetric Difference）

print(set1 ^ set2)                      # {1, 2, 5, 6}
print(set1.symmetric_difference(set2)) # {1, 2, 5, 6}

5. 集合的比较

a = {1, 2}
b = {1, 2, 3}

子集 / 真子集

print(a <= b)              # True，a 是 b 的子集
print(a.issubset(b))       # True

print(a < b)               # True，a 是 b 的真子集（但不等于 b）

超集 / 真超集

print(b >= a)              # True，b 是 a 的超集
print(b.issuperset(a))     # True

print(b > a)               # True，b 是 a 的真超集

6. 集合更新操作（只能用于 set，frozenset 不支持）

set1 = {1, 2, 3}
set2 = {3, 4, 5}

set1.update(set2) → 并集更新

set1.update(set2)
print(set1)  # {1, 2, 3, 4, 5}

set1.intersection_update(set2) → 交集更新

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5}
set1.intersection_update(set2)
print(set1)  # {3, 4}

set1.difference_update(set2) → 差集更新

set1 = {1, 2, 3, 4}
set2 = {3, 4}
set1.difference_update(set2)
print(set1)  # {1, 2}

set1.symmetric_difference_update(set2) → 对称差集更新

set1 = {1, 2, 3}
set2 = {3, 4, 5}
set1.symmetric_difference_update(set2)
print(set1)  # {1, 2, 4, 5}

---

✅ 总结表格

操作符 / 方法	含义	示例结果
set1 & set2set1.intersection(set2)	交集（公共元素）	{3}
set1  |   set2set1.union(set2)	并集（全部唯一元素）	{1，2，3，4，5}
set1 - set2set1.difference(set2)	差集（仅在 set1 中的元素）	{1, 2}
set1 ^ set2set1.symmetric_difference(set2)	对称差集（非交集）	{1, 2, 4, 5}
set1 <= set2set1.issubset(set2)	是否子集	False
set1 >= set2set1.issuperset(set2)	是否超集	False

7. 不可变集合：frozenset

• frozenset 和 set 类似，但它是不可变的，无法进行增、删、改操作。它的主要用途是在需要不变的集合对象时使用，如用作字典的键。

• frozenset 示例：

  fs = frozenset([1, 2, 3])

8. 集合运算符与方法的非运算符版本

大多数集合操作都有对应的非运算符版本，能够接受任何可迭代对象作为参数：

• intersection()：交集

• union()：并集

• difference()：差集

• symmetric_difference()：对称差集

• issubset()：子集

• issuperset()：超集

例如：

set1.intersection('abc')  # 比较 set1 和 'abc' 的交集
set1.union('abc')         # 比较 set1 和 'abc' 的并集

9. 集合和字典的关系

• 集合与字典的相似性：

  • 集合的元素类似于字典的键。它们都需要是可哈希的类型。

  • 集合没有值部分，只有键。

• 集合与 frozenset 的比较：

  • frozenset 是不可变的，可以用作字典的键或其他集合的元素。

  • set 是可变的，不可作为字典的键或其他集合的元素。

这里提到了字典dict，接下来就一起来看看字典是怎样的数据类型~

二、字典（dict）

字典（dict）是 Python 中的一个内置数据结构，它允许你通过键（key）快速访问值（value）。字典本质上就是一种映射类型，将 可哈希 的键（hashable values）映射到任意的值。其典型应用场景包括数据存储、快速查找和关联关系的建立。

键值对的定义：

键值对（key-value pair）是由 键（key）和 值（value）组成的一组数据结构。在这种结构中，键通常是一个唯一的标识符，而值则是与该键关联的具体数据。键值对广泛用于数据存储和检索，键作为索引可以用来快速访问与之关联的值。

1. 映射类型

• 映射类型（mapping）是指一类数据结构，专门用来映射键到值。映射类型属于 可变 对象，因为它们可以被修改。

• 在 Python 中，字典（dict）是最常见的映射类型，它允许你将 哈希值可比较的键（例如：字符串、整数、元组等）映射到 任意对象。

2. 字典的键（key）

字典的键（key）几乎可以是任何不可变（hashable）的值。例如：

• 数字（整数、浮点数）

• 字符串

• 元组（不可包含可变元素）

不可用作键的值：

• 列表（因为列表是可变的）

• 字典（字典本身也是可变的）

示例：

# 合法键
my_dict = {1: "apple", "name": "Alice", (1, 2): "point"}
​
# 非法键（会抛出 TypeError）
# my_dict[[1, 2]] = "invalid"  # List as key is not allowed.

3. 字典的创建

字典的创建方式有很多种，常见的几种方法如下：

(1) 使用花括号 {}：

#直接通过花括号创建
my_dict = {"name": "Alice", "age": 30}

(2) 使用 dict() 构造函数：

#使用 dict() 创建
my_dict = dict(name="Alice", age=30)

(3) 使用字典推导式：

#字典推导式：创建一个以 x 为键，x 的平方为值的字典
squares = {x: x**2 for x in range(5)}

(4) 使用 zip 创建：

# 使用 zip() 来创建字典
keys = ['one', 'two', 'three']
values = [1, 2, 3]
my_dict = dict(zip(keys, values))

4. 字典的常见操作

(1) 访问字典值：

my_dict = {"name": "Alice", "age": 30}
print(my_dict["name"])  # Alice

• 如果访问不存在的键，会抛出 KeyError。

• 使用 .get() 方法可以避免错误并返回默认值：

print(my_dict.get("address", "Not Found"))  # Not Found

(2) 添加或更新键值对：

# 创建空字典
my_dict = {}
# 添加键值对
my_dict["name"] = "Alice"
my_dict["age"] = 25
# 添加新的键值对
my_dict["address"] = "Wonderland"
​
# 更新已有的键值对
my_dict["age"] = 31

(3) 删除键值对：

#使用 del 删除键值对
del my_dict["age"]
​
# 使用 pop() 删除并返回值
address = my_dict.pop("address")
print(address)  # Wonderland
#使用 popitem() 删除并返回字典中的最后一对键值
last_item = my_dict.popitem()
print(last_item)  # 输出: ('address', '123 Street')
print(my_dict)  # 输出: {'name': 'Alice'}
#使用 clear() 清空字典：
my_dict.clear()
print(my_dict)  # 输出: {}

(4) 遍历字典：

 遍历字典的键
for key in my_dict:
    print(key)
​
# 遍历字典的值
for value in my_dict.values():
    print(value)
​
# 遍历字典的键值对
for key, value in my_dict.items():
    print(key, value)

(5) 查询元素:

• 通过键直接访问值： 如果键不存在，会引发 KeyError。

print(my_dict["name"])  # 输出: Alice

• 使用 get() 方法访问值： get() 方法不会引发异常，如果键不存在，可以返回默认值。

print(my_dict.get("name", "Not Found"))  # 输出: Alice
print(my_dict.get("address", "Not Found"))  # 输出: Not Found

• 通过 keys() 获取所有键： keys() 方法返回一个字典视图对象，包含字典中的所有键。

keys = my_dict.keys()
print(keys)  # 输出: dict_keys(['name', 'age'])

• 通过 values() 获取所有值： values() 方法返回一个字典视图对象，包含字典中的所有值。

values = my_dict.values()
print(values)  # 输出: dict_values(['Alice', 30])

• 通过 items() 获取所有键值对： items() 方法返回一个字典视图对象，包含字典中的所有键值对，每个元素是一个 (key, value) 元组。

items = my_dict.items()
print(items)  # 输出: dict_items([('name', 'Alice'), ('age', 30)])

5. 字典视图对象

Python 字典的 keys()、values() 和 items() 方法返回的不是列表，而是视图对象。这些视图是 动态的，意味着当字典本身发生变化时，视图也会同步更新。

• keys() 返回字典中所有键的视图。

• values() 返回字典中所有值的视图。

• items() 返回字典中所有键值对的视图。

示例：

dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500}
keys = dishes.keys()
values = dishes.values()
​
# 修改字典内容时，视图对象会同步更新
del dishes['eggs']
print(list(keys))  # ['sausage', 'bacon', 'spam']

6. 常见字典方法

(1) clear()：清空字典

my_dict.clear()

(2) copy()：浅拷贝

new_dict = my_dict.copy()

(3) fromkeys()：使用可迭代对象创建字典

keys = ['a', 'b', 'c']
new_dict = dict.fromkeys(keys, 0)  # {'a': 0, 'b': 0, 'c': 0}

(4) setdefault()：如果键不存在，则插入并返回默认值

my_dict.setdefault("age", 25)  # 如果 "age" 不在字典中，插入 "age" = 25

(5) update()：合并另一个字典或键值对更新当前字典

my_dict.update({"city": "Wonderland", "age": 32})

7. 字典的排序与逆序

Python 3.7+ 保证字典是 有序的，即键值对的插入顺序是有保障的。你可以使用 reversed() 函数来反转字典的顺序。

原始字典
d = {"one": 1, "two": 2, "three": 3}
# 逆序
reversed_dict = list(reversed(d))
print(reversed_dict)  # ['three', 'two', 'one']

8. 字典的合并

Python 3.9 引入了 | 操作符来合并两个字典：

d1 = {"a": 1, "b": 2}
d2 = {"b": 3, "c": 4}
merged = d1 | d2  # {': 1, 'b': 3, 'c': 4}

你也可以使用 |= 操作符来更新原字典：

d1 |= d2  # d1 更新为 {'a': 1, 'b': 3, 'c': 4}

9. 字典的比较

字典比较是基于键值对进行的，只有当两个字典拥有相同的键值对时，它们才被认为相等：

d1 = {'a': 1, 'b': 2}
d2 = {'b': 2, 'a': 1}
print(d1 == d2)  # True

10. 字典在实际中的应用场景

• 数据库索引： 使用字典可以快速实现索引查询。

• 配置文件： 用字典来存储配置信息，键是配置项，值是配置信息。

• 频率统计： 通过字典的键值对来统计元素出现的频率，例如通过 collections.Counter 来计算频次。

小编有感，写在最后：今日内容较多，知识常看常新，基础越打越牢，多巩固多复习总是能有不一样的收获~