17. 集合：处理唯一且无序的数据

# 创建一个编程语言集合
languages = {"Python", "JavaScript", "Java", "C++"}
print(languages)  # Output: {'Python', 'JavaScript', 'Java', 'C++'}
print(type(languages))  # Output: <class 'set'>

numbers = {5, 2, 8, 1, 9}
print(numbers)  # Output might be: {1, 2, 5, 8, 9} or another order

# 创建一个包含重复值的集合
student_ids = {101, 102, 103, 102, 101, 104}
print(student_ids)  # Output: {101, 102, 103, 104}
 
# 这个特性使集合非常适合用于去重
grades = [85, 90, 85, 78, 90, 92, 78, 85]
unique_grades = set(grades)
print(unique_grades)  # Output: {78, 85, 90, 92}

# 从列表创建集合
colors_list = ["red", "blue", "green", "red", "yellow"]
colors_set = set(colors_list)
print(colors_set)  # Output: {'red', 'blue', 'green', 'yellow'}
 
# 从字符串创建集合（每个字符会成为一个元素）
letters = set("programming")
print(letters)  # Output: {'p', 'r', 'o', 'g', 'a', 'm', 'i', 'n'}
 
# 从元组创建集合
coordinates = set((10, 20, 30, 20, 10))
print(coordinates)  # Output: {10, 20, 30}

text = "Mississippi"
unique_chars = set(text.lower())
print(unique_chars)  # Output: {'m', 'i', 's', 'p'}
print(f"The word contains {len(unique_chars)} unique letters")
# Output: The word contains 4 unique letters

# WRONG - This creates an empty dictionary, not a set
empty_dict = {}
print(type(empty_dict))  # Output: <class 'dict'>
 
# CORRECT - This creates an empty set
empty_set = set()
print(type(empty_set))  # Output: <class 'set'>
print(empty_set)  # Output: set()

# 理解使用变量创建集合
x = 5
my_set = {x}  # Creates {5}, not {'x'}
print(my_set)  # Output: {5}
 
# 如果你想创建一个包含字符串 'x' 的集合：
my_set = {'x'}
print(my_set)  # Output: {'x'}
 
# 这同样适用于任何表达式
result = 10 + 5
my_set = {result}  # Creates {15}
print(my_set)  # Output: {15}

# 检查唯一元素的数量
website_visitors = {"alice", "bob", "charlie", "alice", "david"}
print(f"Unique visitors: {len(website_visitors)}")
# Output: Unique visitors: 4
 
# 使用 'in' 检查成员关系（对集合来说非常快）
if "alice" in website_visitors:
    print("Alice visited the website")
# Output: Alice visited the website
 
# 检查非成员关系
if "eve" not in website_visitors:
    print("Eve has not visited yet")
# Output: Eve has not visited yet

# 构建已完成任务的集合
completed_tasks = {"task1", "task2"}
print(completed_tasks)  # Output: {'task1', 'task2'}
 
# 添加一个新任务
completed_tasks.add("task3")
print(completed_tasks)  # Output: {'task1', 'task2', 'task3'}
 
# 添加重复项不会产生影响
completed_tasks.add("task1")
print(completed_tasks)  # Output: {'task1', 'task2', 'task3'}

# 从一个较小的技能集合开始
skills = {"Python", "SQL"}
print(skills)  # Output: {'Python', 'SQL'}
 
# 从列表中添加多个技能
new_skills = ["JavaScript", "Docker", "Python"]
skills.update(new_skills)
print(skills)  # Output: {'Python', 'SQL', 'JavaScript', 'Docker'}

# 合并来自多个来源的技能
current_skills = {"Python"}
course_skills = ["JavaScript", "HTML"]
job_requirements = {"SQL", "Python", "Docker"}
 
current_skills.update(course_skills, job_requirements)
print(current_skills)
# Output: {'Python', 'JavaScript', 'HTML', 'SQL', 'Docker'}

# 管理活跃用户
active_users = {"alice", "bob", "charlie", "david"}
 
# 移除一个已登出的用户
active_users.remove("bob")
print(active_users)  # Output: {'alice', 'charlie', 'david'}
 
# 尝试移除不存在的元素会导致错误
# active_users.remove("eve")  # Raises: KeyError: 'eve'

# 通过错误处理来安全移除（我们会在第 28 章学习更多 try/except）
users = {"alice", "bob", "charlie"}
user_to_remove = "david"
 
if user_to_remove in users:
    users.remove(user_to_remove)
    print(f"Removed {user_to_remove}")
else:
    print(f"{user_to_remove} was not in the set")
# Output: david was not in the set

# 管理购物车
cart_items = {"apple", "banana", "orange"}
 
# 安全地移除物品（即使物品不存在也不会报错）
cart_items.discard("banana")
print(cart_items)  # Output: {'apple', 'orange'}
 
cart_items.discard("grape")  # No error, even though grape isn't in the set
print(cart_items)  # Output: {'apple', 'orange'}

# 处理待办任务队列（顺序不重要）
pending_tasks = {"email", "report", "meeting", "review"}
 
# 处理一个任务（我们不在意是哪一个）
task = pending_tasks.pop()
print(f"Processing: {task}")  # Output: Processing: email (or another task)
print(f"Remaining: {pending_tasks}")
# Output: Remaining: {'report', 'meeting', 'review'} (without the popped task)

empty_set = set()
# empty_set.pop()  # Raises: KeyError: 'pop from an empty set'

# 处理集合中的所有元素
items_to_process = {"item1", "item2", "item3"}
 
while items_to_process:
    item = items_to_process.pop()
    print(f"Processing {item}")
    # 处理该 item...
 
print("All items processed")
# Output:
# Processing item1
# Processing item2
# Processing item3
# All items processed

# 重置会话数据
session_data = {"user_id", "timestamp", "ip_address"}
print(session_data)  # Output: {'user_id', 'timestamp', 'ip_address'}
 
session_data.clear()
print(session_data)  # Output: set()
print(len(session_data))  # Output: 0

# 不同课程的选课学生
python_students = {"alice", "bob", "charlie"}
javascript_students = {"bob", "david", "eve"}
 
# 找出选择任一课程（或两者都选）的所有学生
all_students = python_students | javascript_students
print(all_students)
# Output: {'alice', 'bob', 'charlie', 'david', 'eve'}

# 使用 union() 方法得到相同结果
all_students = python_students.union(javascript_students)
print(all_students)
# Output: {'alice', 'bob', 'charlie', 'david', 'eve'}

# 三门不同课程的学生
python_students = {"alice", "bob"}
javascript_students = {"bob", "charlie"}
sql_students = {"charlie", "david"}
 
# 所有课程的全部学生
all_students = python_students.union(javascript_students, sql_students)
print(all_students)
# Output: {'alice', 'bob', 'charlie', 'david'}

# 合并不同部门的邮件列表
marketing_contacts = {"alice@company.com", "bob@company.com"}
sales_contacts = {"bob@company.com", "charlie@company.com"}
support_contacts = {"david@company.com", "alice@company.com"}
 
# 跨部门的所有唯一联系人
all_contacts = marketing_contacts | sales_contacts | support_contacts
print(f"Total unique contacts: {len(all_contacts)}")
# Output: Total unique contacts: 4

# 找出同时购买两种产品的客户
customers_product_a = {101, 102, 103, 104, 105}
customers_product_b = {103, 104, 105, 106, 107}
 
# 同时购买两种产品的客户
both_products = customers_product_a & customers_product_b
print(f"Bought both: {both_products}")
# Output: Bought both: {103, 104, 105}

# 找出同时选了三门课程的学生
python_students = {"alice", "bob", "charlie"}
javascript_students = {"bob", "charlie", "david"}
sql_students = {"charlie", "eve", "bob"}
 
# 同时选了三门课的学生
all_three = python_students.intersection(javascript_students, sql_students)
print(all_three)  # Output: {'bob', 'charlie'}

# 找出多个仓库都有的产品
warehouse_a = {"laptop", "mouse", "keyboard", "monitor"}
warehouse_b = {"mouse", "keyboard", "printer", "scanner"}
warehouse_c = {"keyboard", "monitor", "mouse", "desk"}
 
# 所有仓库都可用的产品
available_everywhere = warehouse_a & warehouse_b & warehouse_c
print(f"Available in all locations: {available_everywhere}")
# Output: Available in all locations: {'mouse', 'keyboard'}

# 库存管理：找出差异
expected_items = {"item001", "item002", "item003", "item004"}
actual_items = {"item001", "item003", "item005"}
 
# 库存中缺少的物品
missing = expected_items - actual_items
print(f"Missing items: {missing}")
# Output: Missing items: {'item002', 'item004'}
 
# 库存中意外出现的物品
unexpected = actual_items - expected_items
print(f"Unexpected items: {unexpected}")
# Output: Unexpected items: {'item005'}

# 只在 Python 课程中的学生（不在 JavaScript 课程中）
python_students = {"alice", "bob", "charlie"}
javascript_students = {"bob", "david", "eve"}
 
python_only = python_students.difference(javascript_students)
print(python_only)  # Output: {'alice', 'charlie'}

python_students = {"alice", "bob", "charlie"}
javascript_students = {"bob", "david", "eve"}
 
# 在 Python 中但不在 JavaScript 中的学生
python_only = python_students - javascript_students
print(f"Python only: {python_only}")
# Output: Python only: {'alice', 'charlie'}
 
# 在 JavaScript 中但不在 Python 中的学生
javascript_only = javascript_students - python_students
print(f"JavaScript only: {javascript_only}")
# Output: JavaScript only: {'david', 'eve'}

# 对比配置的两个版本
old_settings = {"debug", "logging", "cache", "compression"}
new_settings = {"logging", "cache", "monitoring", "security"}
 
# 发生变化的配置项（新增或移除）
changes = old_settings ^ new_settings
print(f"Changed settings: {changes}")
# Output: Changed settings: {'debug', 'compression', 'monitoring', 'security'}
 
# 若要明确区分新增与移除：
removed = old_settings - new_settings
added = new_settings - old_settings
print(f"Removed: {removed}")  # Output: Removed: {'debug', 'compression'}
print(f"Added: {added}")  # Output: Added: {'monitoring', 'security'}

# 只选了一门课程的学生（不是两门都选）
python_students = {"alice", "bob", "charlie"}
javascript_students = {"bob", "david", "eve"}
 
one_course_only = python_students.symmetric_difference(javascript_students)
print(one_course_only)
# Output: {'alice', 'charlie', 'david', 'eve'}

result1 = python_students ^ javascript_students
result2 = javascript_students ^ python_students
print(result1 == result2)  # Output: True

# 课程先修要求
basic_skills = {"reading", "writing"}
intermediate_skills = {"reading", "writing", "analysis"}
 
# 检查 basic_skills 是否为 intermediate_skills 的子集
print(basic_skills.issubset(intermediate_skills))  # Output: True
print(basic_skills <= intermediate_skills)  # Output: True (same result)

skills = {"Python", "SQL", "JavaScript"}
print(skills.issubset(skills))  # Output: True
print(skills <= skills)  # Output: True

basic_skills = {"reading", "writing"}
intermediate_skills = {"reading", "writing", "analysis"}
 
# 真子集：basic 是 intermediate 的子集，并且二者不相等
print(basic_skills < intermediate_skills)  # Output: True
 
# 不是自身的真子集（它们相等）
print(basic_skills < basic_skills)  # Output: False

# 用户权限系统
required_permissions = {"read", "write"}
user_permissions = {"read", "write", "delete", "admin"}
 
# 检查用户是否拥有所有必需权限
if required_permissions.issubset(user_permissions):
    print("Access granted")
else:
    print("Access denied - missing permissions")
# Output: Access granted
 
# 另一个权限不足的用户
limited_user = {"read"}
if required_permissions.issubset(limited_user):
    print("Access granted")
else:
    missing = required_permissions - limited_user
    print(f"Access denied - missing: {missing}")
# Output: Access denied - missing: {'write'}

# 技能等级
basic_skills = {"reading", "writing"}
advanced_skills = {"reading", "writing", "analysis", "research"}
 
# 检查 advanced_skills 是否为 basic_skills 的超集
print(advanced_skills.issuperset(basic_skills))  # Output: True
print(advanced_skills >= basic_skills)  # Output: True (same result)

skills = {"Python", "SQL"}
print(skills.issuperset(skills))  # Output: True

basic_skills = {"reading", "writing"}
advanced_skills = {"reading", "writing", "analysis"}
 
# 真超集：advanced 包含 basic 的全部元素，并且还有更多
print(advanced_skills > basic_skills)  # Output: True
 
# 不是自身的真超集
print(advanced_skills > advanced_skills)  # Output: False

# 检查排课是否有冲突
morning_classes = {"math", "english", "history"}
afternoon_classes = {"science", "art", "music"}
 
# 检查是否有任何冲突（同一门课出现在两个时段）
if morning_classes.isdisjoint(afternoon_classes):
    print("No scheduling conflicts")
else:
    conflicts = morning_classes & afternoon_classes
    print(f"Conflicts: {conflicts}")
# Output: No scheduling conflicts

morning_classes = {"math", "english", "history"}
afternoon_classes = {"science", "math", "music"}
 
if morning_classes.isdisjoint(afternoon_classes):
    print("No scheduling conflicts")
else:
    conflicts = morning_classes & afternoon_classes
    print(f"Conflicts: {conflicts}")
# Output: Conflicts: {'math'}

empty = set()
numbers = {1, 2, 3}
 
print(empty.isdisjoint(numbers))  # Output: True
print(empty.isdisjoint(empty))  # Output: True

# 检查用户是否在一个很大的集合中
active_users_list = []
for i in range(10000):
    active_users_list.append("user" + str(i))
 
# 使用列表（对大集合来说较慢）
print("user5000" in active_users_list)  # Checks each element until found
 
active_users_set = set()
for i in range(10000):
    active_users_set.add("user" + str(i))
 
# 使用集合（无论大小都很快）
print("user5000" in active_users_set)  # Direct lookup

# 从用户输入中移除重复项
survey_responses = [
    "yes", "no", "yes", "maybe", "yes", "no", "maybe", "yes"
]
 
# 获取唯一回复
unique_responses = set(survey_responses)
print(unique_responses)  # Output: {'yes', 'no', 'maybe'}
 
# 如果你需要再转回列表（去重后）
unique_list = list(unique_responses)
print(unique_list)  # Output: ['yes', 'no', 'maybe'] (order may vary)

# 分析客户购买模式
customers_product_a = {101, 102, 103, 104, 105}
customers_product_b = {103, 104, 105, 106, 107}
 
# 同时购买两种产品的客户
both_products = customers_product_a & customers_product_b
print(f"Bought both: {both_products}")
# Output: Bought both: {103, 104, 105}
 
# 只购买产品 A 的客户
only_a = customers_product_a - customers_product_b
print(f"Only product A: {only_a}")
# Output: Only product A: {101, 102}
 
# 至少购买一种产品的所有客户
all_customers = customers_product_a | customers_product_b
print(f"Total customers: {len(all_customers)}")
# Output: Total customers: 7

# WRONG - 使用集合无法保留顺序
task_order = {"wake up", "breakfast", "work", "lunch", "work", "dinner"}
print(task_order)  # Order is unpredictable and "work" appears only once
 
# CORRECT - 当顺序重要时使用列表
task_order = ["wake up", "breakfast", "work", "lunch", "work", "dinner"]
print(task_order)
# Output: ['wake up', 'breakfast', 'work', 'lunch', 'work', 'dinner']

# 记录测验分数（重复项表示有多少学生得到该分数）
quiz_scores = [85, 90, 85, 78, 90, 92, 85, 88]
 
# 使用列表，我们可以统计出现次数
score_85_count = quiz_scores.count(85)
print(f"Students who scored 85: {score_85_count}")
# Output: Students who scored 85: 3
 
# 使用集合则会丢失这类信息
unique_scores = set(quiz_scores)
print(unique_scores)  # Output: {78, 85, 88, 90, 92}
# We can't tell how many students got each score

# WRONG - 集合不支持索引
colors = {"red", "blue", "green"}
# first_color = colors[0]  # Raises: TypeError: 'set' object is not subscriptable
 
# CORRECT - 使用列表进行索引访问
colors = ["red", "blue", "green"]
first_color = colors[0]
print(first_color)  # Output: red

# 从列表创建 frozenset
colors = frozenset(["red", "blue", "green"])
print(colors)  # Output: frozenset({'red', 'blue', 'green'})
print(type(colors))  # Output: <class 'frozenset'>
 
# 从元组创建 frozenset
numbers = frozenset((1, 2, 3, 4, 5))
print(numbers)  # Output: frozenset({1, 2, 3, 4, 5})
 
# 创建空 frozenset
empty = frozenset()
print(empty)  # Output: frozenset()

# 重复项会被移除
values = frozenset([1, 2, 2, 3, 3, 3, 4])
print(values)  # Output: frozenset({1, 2, 3, 4})

# 创建一个 frozenset
languages = frozenset(["Python", "JavaScript", "Java"])
 
# 尝试修改会报错
# languages.add("C++")  # AttributeError: 'frozenset' object has no attribute 'add'
# languages.remove("Java")  # AttributeError: 'frozenset' object has no attribute 'remove'

# 原始 frozenset
original = frozenset([1, 2, 3])
 
# 创建包含额外元素的新 frozenset
modified = frozenset(list(original) + [4])
print(original)  # Output: frozenset({1, 2, 3})
print(modified)  # Output: frozenset({1, 2, 3, 4})

# 使用 frozenset 进行集合运算
set_a = frozenset([1, 2, 3, 4])
set_b = frozenset([3, 4, 5, 6])
 
# Union
print(set_a | set_b)  # Output: frozenset({1, 2, 3, 4, 5, 6})
 
# Intersection
print(set_a & set_b)  # Output: frozenset({3, 4})
 
# Difference
print(set_a - set_b)  # Output: frozenset({1, 2})
 
# Symmetric difference
print(set_a ^ set_b)  # Output: frozenset({1, 2, 5, 6})

regular_set = {1, 2, 3}
frozen_set = frozenset([3, 4, 5])
 
# 普通集合与 frozen_set 之间的运算
result = regular_set | frozen_set
print(result)  # Output: {1, 2, 3, 4, 5}
print(type(result))  # Output: <class 'set'> (result is a regular set)

# WRONG - 普通集合不能作为字典键
# regular_set = {1, 2, 3}
# my_dict = {regular_set: "value"}  # TypeError: unhashable type: 'set'
 
# CORRECT - frozenset 可以作为字典键
frozen_set = frozenset([1, 2, 3])
my_dict = {frozen_set: "value"}
print(my_dict)  # Output: {frozenset({1, 2, 3}): 'value'}
print(my_dict[frozen_set])  # Output: value

# 存储关于坐标对的信息
# 每个坐标都是 (x, y) 值组成的 frozenset
location_data = {
    frozenset([0, 0]): "origin",
    frozenset([1, 0]): "east",
    frozenset([1, 1]): "northeast"
}
 
# 查找位置
point = frozenset([1, 0])
print(location_data[point])  # Output: east

# WRONG - 普通集合不能作为集合的元素
# set_of_sets = {{1, 2}, {3, 4}}  # TypeError: unhashable type: 'set'
 
# CORRECT - frozenset 可以作为集合的元素
set_of_frozensets = {
    frozenset([1, 2]),
    frozenset([3, 4]),
    frozenset([5, 6])
}
print(set_of_frozensets)
# Output: {frozenset({1, 2}), frozenset({3, 4}), frozenset({5, 6})}

# 表示队伍：每个队伍是由玩家 ID 组成的 frozenset
tournament_teams = {
    frozenset([101, 102, 103]),  # Team A
    frozenset([201, 202, 203]),  # Team B
    frozenset([301, 302, 303])   # Team C
}
 
# 检查某支队伍是否已注册
team_to_check = frozenset([101, 102, 103])
if team_to_check in tournament_teams:
    print("Team is registered")
else:
    print("Team not found")
# Output: Team is registered

# 将普通集合转换为 frozenset
regular = {1, 2, 3, 4}
frozen = frozenset(regular)
print(frozen)  # Output: frozenset({1, 2, 3, 4})
 
# 将 frozenset 转换为普通集合
frozen = frozenset([5, 6, 7, 8])
regular = set(frozen)
print(regular)  # Output: {5, 6, 7, 8}
 
# 现在我们可以修改普通集合
regular.add(9)
print(regular)  # Output: {5, 6, 7, 8, 9}

# 可哈希类型拥有哈希值
print(hash(42))  # Output: 42
print(hash("Python"))  # Output: (some large integer)
print(hash((1, 2, 3)))  # Output: (some large integer)

# 整数是可哈希的
numbers = {1, 2, 3, 4, 5}
print(numbers)  # Output: {1, 2, 3, 4, 5}
 
# 字符串是可哈希的
words = {"apple", "banana", "cherry"}
print(words)  # Output: {'apple', 'banana', 'cherry'}
 
# 元组是可哈希的（前提是它只包含可哈希元素）
coordinates = {(0, 0), (1, 1), (2, 2)}
print(coordinates)  # Output: {(0, 0), (1, 1), (2, 2)}
 
# frozenset 是可哈希的
frozen_sets = {frozenset([1, 2]), frozenset([3, 4])}
print(frozen_sets)  # Output: {frozenset({1, 2}), frozenset({3, 4})}
 
# 布尔值与 None 是可哈希的
mixed = {True, False, None, 42, "text"}
print(mixed)  # Output: {False, True, None, 42, 'text'}

# 列表不是可哈希的
# my_set = {[1, 2, 3]}  # TypeError: unhashable type: 'list'
 
# 普通集合不是可哈希的
# set_of_sets = {{1, 2}, {3, 4}}  # TypeError: unhashable type: 'set'
 
# 字典不是可哈希的
# my_set = {{"key": "value"}}  # TypeError: unhashable type: 'dict'

# 假设场景（这实际上并不能运行）
# my_list = [1, 2, 3]
# my_set = {my_list}  # Suppose this worked
# 
# # Python computes hash based on [1, 2, 3]
# # Now we modify the list:
# my_list.append(4)  # Now it's [1, 2, 3, 4]
# 
# # The hash value would be wrong! The set would be corrupted.

# 常见困惑：set 可变，但元素必须不可变
# set 是可变的——你可以改变其中的内容
fruits = {'apple', 'banana'}
fruits.add('orange')     # ✓ Works
fruits.remove('apple')   # ✓ Works
 
# 但元素必须不可变——它们不能被修改
my_list = [1, 2, 3]
# my_set = {my_list}  # ✗ TypeError: unhashable type: 'list'
# Why? If you could modify my_list after adding it, the set's internal 
# structure would be corrupted.
 
# 这之所以可行，是因为元组不可变
my_tuple = (1, 2, 3)
my_set = {my_tuple}  # ✓ Works - tuples can't be modified

# 仅包含不可变元素的元组——可哈希
good_tuple = (1, 2, "three")
my_set = {good_tuple} # Works: good_tuple is hashable
print(my_set)  # Output: {(1, 2, 'three')}
 
# 包含列表的元组——不可哈希
bad_tuple = (1, 2, [3, 4])
# my_set = {bad_tuple}  # TypeError: unhashable type: 'list'

# 演示为什么包含可变元素的元组不能被哈希
inner_list = [1, 2]
my_tuple = (inner_list, 3)
 
# 元组结构固定，但里面的列表可以变化
inner_list.append(3)  # Now inner_list is [1, 2, 3]
# 元组现在“包含”了不同的数据，但它仍然是同一个元组对象

# 测试可哈希性
def is_hashable(obj):
    """检查对象是否可哈希。"""
    try:
        hash(obj)
        return True
    except TypeError:
        return False
 
# 测试各种类型
print(is_hashable(42))  # Output: True
print(is_hashable("text"))  # Output: True
print(is_hashable((1, 2, 3)))  # Output: True
print(is_hashable([1, 2, 3]))  # Output: False
print(is_hashable({1, 2, 3}))  # Output: False
print(is_hashable({"key": "value"}))  # Output: False