11集合

## 概念

集合可以理解为一个 “无序的容器”，里面的元素**唯一且不可重复**，且元素必须是**不可变类型**（如整数、字符串、元组等）。它类似数学中的 “集合” 概念，适合用于去重、判断元素是否存在、或进行集合间的运算（如找共同元素）。

例如：

- 存储不重复的数字：{1, 2, 3, 4}
- 存储唯一的字符串：{"apple", "banana", "orange"}

## 创建

集合的创建主要有两种方式：直接用{}定义，或通过set()函数转换其他可迭代对象。

**直接用{}创建**

用花括号{}包裹元素，元素之间用逗号,分隔。**注意**：空集合不能用{}创建（{}会被解析为字典），空集合必须用set()。

```python
>>> numbers = {1, 2, 3, 4, 5}
>>> fruits = {"apple", "banana", "orange"}
>>> num = {1,2,1,2,3,3,4,5,6,6,5}
>>> print(numbers)
{1, 2, 3, 4, 5}
>>> print(fruits)
{'orange', 'banana', 'apple'}
>>> print(num)
{1, 2, 3, 4, 5, 6}
```

**用set()函数创建**

set()函数可将**可迭代对象**（如列表、字符串、元组等）转换为集合，同时自动去重。

```python
>>> list_to_set = set([1, 2, 2, 3])
>>> print(list_to_set)
{1, 2, 3}
>>> str_to_set = set("hello")
>>> print(str_to_set)
{'o', 'l', 'e', 'h'}
>>> tuple_to_set = set((1, 2, 3, 3))
>>> print(tuple_to_set)
{1, 2, 3}
```

## 元素限制

集合中的元素必须是**不可变类型**（创建后不能修改的类型），否则会报错。

- 不可变类型：整数、字符串、元组、布尔值等；
- 可变类型：列表、字典、集合等。

```python
>>> valid_set = {"apple", (1, 2, 3), 100}
>>> invalid_set = {[1, 2, 3]}
Traceback (most recent call last):
  File "<python-input-89>", line 1, in <module>
    invalid_set = {[1, 2, 3]}
                  ^^^^^^^^^^^
TypeError: unhashable type: 'list'
```

## 核心特性

**1.无序性（无索引）**

集合中的元素没有固定顺序，且不支持索引访问（不能通过set[0]获取元素）。

**2. 唯一性（自动去重）**

集合会自动移除重复元素，无论添加多少个相同元素，最终只会保留一个。

**3. 可变性（可修改元素）**

集合是可变的：可以添加新元素、删除已有元素（原集合会被直接修改）。

## 添加

- add(元素)：向集合中添加**单个元素**（若元素已存在，不做任何操作，不会报错）。
- update(可迭代对象)：向集合中添加**多个元素**（参数是列表、字符串、集合等可迭代对象，会自动去重）。

```python
>>> fruits = {"apple", "banana"}
>>> print(fruits)
{'banana', 'apple'}
>>> fruits.add("orange")
>>> print(fruits)
{'orange', 'banana', 'apple'}
>>> fruits.add("orange")
>>> print(fruits)
{'orange', 'banana', 'apple'}
>>> fruits.update(["grape", "mango", "apple"])
>>> print(fruits)
{'apple', 'mango', 'banana', 'orange', 'grape'}
```

## 删除

集合提供多种删除元素的方法，核心区别在于 “元素不存在时的处理”：

| 方法          | 功能描述                                 | 元素不存在时的行为         |
| ------------- | ---------------------------------------- | -------------------------- |
| remove(元素)  | 删除指定元素                             | 报错（KeyError）           |
| discard(元素) | 删除指定元素                             | 无操作（不报错）           |
| pop()         | 随机删除一个元素，并返回该元素（因无序） | 集合为空时报错（KeyError） |
| clear()       | 清空集合（删除所有元素，保留空集合）     | 无（空集合调用也安全）     |

```python
>>> fruits = {"apple", "banana", "orange"}
>>> print(fruits)
{'apple', 'orange', 'banana'}
>>> fruits.remove("banana")
>>> print(fruits)
{'apple', 'orange'}
>>> fruits.remove("banana1")
Traceback (most recent call last):
  File "<python-input-4>", line 1, in <module>
    fruits.remove("banana1")
    ~~~~~~~~~~~~~^^^^^^^^^^^
KeyError: 'banana1'
>>> fruits.discard("orange")
>>> print(fruits)
{'apple'}
>>> fruits.discard("orange1")
>>> print(fruits)
{'apple'}
>>> fruits.add("orange")
>>> print(fruits)
{'apple', 'orange'}
>>> deleted = fruits.pop()
>>> print(deleted)
apple
>>> print(fruits)
{'orange'}
>>> fruits.clear()
>>> print(fruits)
set()
```

## 运算

集合支持数学中的常用集合运算（如交集、并集、差集），既可以通过运算符实现，也可以通过方法实现。假设有两个集合：

```python
>>> A = {1, 2, 3, 4}
>>> B = {3, 4, 5, 6}
```

**1.交集**

- 运算符：A & B
- 方法：A.intersection(B)
- 结果：包含同时存在于 A 和 B 中的元素。

```python
>>> A = {1, 2, 3, 4}
>>> B = {3, 4, 5, 6}
>>> print(A & B)
{3, 4}
>>> print(A.intersection(B))
{3, 4}
```

**2.并集**

- 运算符：A | B
- 方法：A.union(B)
- 结果：包含 A 和 B 中的所有元素，重复元素只保留一个。

```python
>>> print(A | B)
{1, 2, 3, 4, 5, 6}
>>> print(A.union(B))
{1, 2, 3, 4, 5, 6}
```

**3.差集**

- 运算符：A - B
- 方法：A.difference(B)
- 结果：包含在 A 中但不在 B 中的元素。

```py
>>> print(A - B)
{1, 2}
>>> print(A.difference(B))
{1, 2}
```

**4.对称差集**

- 运算符：A ^ B
- 方法：A.symmetric_difference(B)
- 结果：包含在 A 或 B 中，但不同时在两个集合中的元素（即并集减去交集）。

```python
>>> print(A ^ B)
{1, 2, 5, 6}
>>> print(A.symmetric_difference(B))
{1, 2, 5, 6}
```

**5.子集与超集判断**

- 子集：A <= B → 判断 A 是否是 B 的子集（A 的所有元素都在 B 中）。
- 超集：A >= B → 判断 A 是否是 B 的超集（B 的所有元素都在 A 中）。

```python
>>> A = {1, 2, 3, 4}
>>> B = {3, 4, 5, 6}
>>> C = {3, 4}
>>> D = {1, 2, 3, 4, 5}
>>> print(C <= A)
True
>>> print(A >= C)
True
>>> print(A <= D)
True
>>> print(D >= A)
True
```

## 遍历

集合是可迭代对象，可以用for循环遍历所有元素（但顺序不固定，因集合无序）。

```python
>>> fruits = {"apple", "banana", "orange"}
>>> for fruit in fruits:
...     print(fruit)
...
apple
orange
banana
```

## 不可变集合

Python 中还有一种**不可变集合（frozenset）**，它的特点是：

- 一旦创建，**不能添加、删除或修改元素**（不可变性）；
- 可以作为字典的键（因不可变）或其他集合的元素（普通集合不能包含集合，因集合可变）；
- 支持除修改外的所有集合操作（如交集、并集、遍历等）。

用frozenset()函数创建，参数为可迭代对象：

```python
>>> frozen = frozenset([1, 2, 3])	# 创建不可变集合
>>> print(type(frozen))
<class 'frozenset'>
>>> frozen.add(4)	# 尝试修改（会报错）
Traceback (most recent call last):
  File "<python-input-49>", line 1, in <module>
    frozen.add(4)
    ^^^^^^^^^^
AttributeError: 'frozenset' object has no attribute 'add'
>>> another_frozen = frozenset([3, 4, 5])
>>> print(frozen & another_frozen)	# 支持集合运算
frozenset({3})
>>> valid_dict = {frozen: "value"}	# 可作为字典的键（普通集合不行）
>>> invalid_dict = {{1, 2}: "value"}
Traceback (most recent call last):
  File "<python-input-53>", line 1, in <module>
    invalid_dict = {{1, 2}: "value"}
                   ^^^^^^^^^^^^^^^^^
TypeError: unhashable type: 'set'
```

## 总结

集合是 Python 中处理 “唯一元素集合” 的高效工具，核心要点：

- 无序、可变、元素唯一，支持自动去重；
- 适合去重、成员判断、集合运算（交集 / 并集等）；
- 元素必须是不可变类型，不可用索引访问；
- 不可变集合（frozenset）适用于需要不可变特性的场景（如作为字典键）。