昨天，我们学习了字典(Dictionary)，掌握了键值对数据结构的强大功能。今天，我们将学习集合(Set) — Python中用于存储无序、不重复元素的数据结构。

集合在去重、数学运算、成员检测等场景中非常有用，是Python中不可或缺的数据结构。

今天您将学习什么

• 什么是集合以及如何创建集合
• 集合的基本操作：增删改查
• 集合的数学运算：并集、交集、差集
• 集合的常用方法
• 真实世界示例：去重、权限管理、数据分析

什么是集合？

集合是Python中的一种无序、可变的数据结构，用花括号{}表示（与字典不同，没有键值对）。集合中的元素是唯一的，不允许重复。

基本语法：

# 创建空集合
empty_set = set()

# 创建包含元素的集合
fruits = {"apple", "banana", "orange"}

# 从列表创建集合
numbers = set([1, 2, 3, 4, 5])

# 从字符串创建集合（会去重）
letters = set("hello")  # {'h', 'e', 'l', 'o'}

1. 访问集合元素

集合是无序的，不能通过索引访问。但可以检查元素是否存在：

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

# 检查元素是否存在
print("apple" in fruits)    # True
print("grape" in fruits)    # False

# 遍历集合
for fruit in fruits:
    print(fruit)

2. 添加元素

add() - 添加单个元素

fruits = {"apple", "banana"}

fruits.add("orange")
fruits.add("apple")  # 重复元素不会被添加

print(fruits)  # {'apple', 'banana', 'orange'}

update() - 添加多个元素

fruits = {"apple", "banana"}

fruits.update(["orange", "grape", "kiwi"])
print(fruits)  # {'apple', 'banana', 'orange', 'grape', 'kiwi'}

3. 删除元素

remove() - 删除指定元素

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

fruits.remove("banana")
print(fruits)  # {'apple', 'orange'}

# 如果元素不存在会报错
# fruits.remove("grape")  # KeyError

discard() - 安全删除

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

fruits.discard("banana")  # 删除存在的元素
fruits.discard("grape")   # 删除不存在的元素不会报错

print(fruits)  # {'apple', 'orange'}

pop() - 随机删除并返回

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

removed_fruit = fruits.pop()
print(f"删除的水果：{removed_fruit}")
print(fruits)

clear() - 清空集合

fruits = {"apple", "banana", "orange"}
fruits.clear()
print(fruits)  # set()

4. 集合的数学运算

并集 (Union)

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

# 方法1：使用 | 操作符
union1 = set1 | set2
print(union1)  # {1, 2, 3, 4, 5, 6}

# 方法2：使用 union() 方法
union2 = set1.union(set2)
print(union2)  # {1, 2, 3, 4, 5, 6}

交集 (Intersection)

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

# 方法1：使用 & 操作符
intersection1 = set1 & set2
print(intersection1)  # {3, 4}

# 方法2：使用 intersection() 方法
intersection2 = set1.intersection(set2)
print(intersection2)  # {3, 4}

差集 (Difference)

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

# 方法1：使用 - 操作符
difference1 = set1 - set2
print(difference1)  # {1, 2}

# 方法2：使用 difference() 方法
difference2 = set1.difference(set2)
print(difference2)  # {1, 2}

对称差集 (Symmetric Difference)

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

# 方法1：使用 ^ 操作符
symmetric_diff1 = set1 ^ set2
print(symmetric_diff1)  # {1, 2, 5, 6}

# 方法2：使用 symmetric_difference() 方法
symmetric_diff2 = set1.symmetric_difference(set2)
print(symmetric_diff2)  # {1, 2, 5, 6}

5. 集合的关系判断

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

# 子集判断
print(set1.issubset(set2))    # True
print(set1 <= set2)           # True

# 超集判断
print(set2.issuperset(set1))  # True
print(set2 >= set1)           # True

# 不相交判断
print(set1.isdisjoint(set3))  # True

6. 集合的常用方法

copy() - 复制集合

fruits = {"apple", "banana", "orange"}
fruits_copy = fruits.copy()
print(fruits_copy)  # {'apple', 'banana', 'orange'}

len() - 获取集合大小

fruits = {"apple", "banana", "orange"}
print(len(fruits))  # 3

真实世界示例1：数据去重

def remove_duplicates(data_list):
    """去除列表中的重复元素"""
    return list(set(data_list))

def count_unique_elements(data_list):
    """统计唯一元素的数量"""
    return len(set(data_list))

# 使用示例
numbers = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
names = ["Alice", "Bob", "Alice", "Charlie", "Bob", "David"]

print("原始数字列表：", numbers)
print("去重后：", remove_duplicates(numbers))
print("唯一元素数量：", count_unique_elements(numbers))

print("\n原始姓名列表：", names)
print("去重后：", remove_duplicates(names))
print("唯一姓名数量：", count_unique_elements(names))

真实世界示例2：权限管理系统

class PermissionManager:
    def __init__(self):
        self.user_permissions = {}
    
    def add_user_permissions(self, user_id, permissions):
        """为用户添加权限"""
        if user_id not in self.user_permissions:
            self.user_permissions[user_id] = set()
        self.user_permissions[user_id].update(permissions)
        print(f"用户 {user_id} 权限已更新")
    
    def remove_user_permissions(self, user_id, permissions):
        """移除用户权限"""
        if user_id in self.user_permissions:
            self.user_permissions[user_id].difference_update(permissions)
            print(f"用户 {user_id} 权限已移除")
    
    def check_permission(self, user_id, permission):
        """检查用户是否有特定权限"""
        if user_id in self.user_permissions:
            return permission in self.user_permissions[user_id]
        return False
    
    def get_user_permissions(self, user_id):
        """获取用户所有权限"""
        return self.user_permissions.get(user_id, set())
    
    def get_users_with_permission(self, permission):
        """获取拥有特定权限的所有用户"""
        users = set()
        for user_id, permissions in self.user_permissions.items():
            if permission in permissions:
                users.add(user_id)
        return users

# 使用示例
pm = PermissionManager()

# 添加用户权限
pm.add_user_permissions("user1", {"read", "write", "delete"})
pm.add_user_permissions("user2", {"read", "write"})
pm.add_user_permissions("user3", {"read"})

# 检查权限
print("user1 是否有删除权限：", pm.check_permission("user1", "delete"))
print("user2 是否有删除权限：", pm.check_permission("user2", "delete"))

# 获取有读取权限的用户
read_users = pm.get_users_with_permission("read")
print("有读取权限的用户：", read_users)

# 移除权限
pm.remove_user_permissions("user1", {"delete"})
print("user1 权限：", pm.get_user_permissions("user1"))

真实世界示例3：数据分析工具

def analyze_common_elements(list1, list2):
    """分析两个列表的共同元素"""
    set1 = set(list1)
    set2 = set(list2)
    
    common = set1 & set2
    only_in_list1 = set1 - set2
    only_in_list2 = set2 - set1
    
    return {
        "共同元素": list(common),
        "仅在列表1中": list(only_in_list1),
        "仅在列表2中": list(only_in_list2),
        "共同元素数量": len(common)
    }

def find_missing_elements(expected, actual):
    """找出缺失的元素"""
    expected_set = set(expected)
    actual_set = set(actual)
    
    missing = expected_set - actual_set
    extra = actual_set - expected_set
    
    return {
        "缺失的元素": list(missing),
        "多余的元素": list(extra),
        "缺失数量": len(missing)
    }

# 使用示例
# 分析两个班级的学生
class_a = ["Alice", "Bob", "Charlie", "David", "Eve"]
class_b = ["Bob", "David", "Frank", "Grace", "Henry"]

analysis = analyze_common_elements(class_a, class_b)
print("班级分析结果：")
for key, value in analysis.items():
    print(f"  {key}: {value}")

# 检查库存
expected_items = ["apple", "banana", "orange", "grape", "kiwi"]
actual_items = ["apple", "banana", "orange", "mango"]

inventory_check = find_missing_elements(expected_items, actual_items)
print("\n库存检查结果：")
for key, value in inventory_check.items():
    print(f"  {key}: {value}")

集合的最佳实践

推荐做法：

• 使用集合进行去重操作
• 利用集合进行高效的成员检测
• 使用集合进行数学运算
• 合理使用集合的不可变性

避免的做法：

• 在需要保持顺序的场景使用集合
• 在需要重复元素的场景使用集合
• 过度使用集合进行复杂的数据操作

集合与其他数据结构的转换

# 列表转集合
numbers_list = [1, 2, 2, 3, 3, 3]
numbers_set = set(numbers_list)
print(numbers_set)  # {1, 2, 3}

# 集合转列表
fruits_set = {"apple", "banana", "orange"}
fruits_list = list(fruits_set)
print(fruits_list)

# 元组转集合
coordinates = (1, 2, 3, 2, 1)
coordinates_set = set(coordinates)
print(coordinates_set)  # {1, 2, 3}

回顾

今天您学习了：

• 如何创建和操作集合
• 集合的基本操作：增删改查
• 集合的数学运算：并集、交集、差集
• 集合的关系判断
• 真实世界应用：数据去重、权限管理、数据分析