集合（Set） #

# 空集合（注意：{}是空字典）
empty = set()       # 正确
# empty = {}        # 这是空字典！

# 带元素
numbers = {1, 2, 3, 4, 5}
fruits = {"apple", "banana", "cherry"}

# 自动去重
duplicates = {1, 2, 2, 3, 3, 3}
print(duplicates)  # {1, 2, 3}

# 混合类型
mixed = {1, "hello", 3.14, (1, 2)}  # 元组可以作为元素
# mixed = {1, [1, 2]}  # 列表不能作为元素（不可哈希）

# 从列表创建
list_data = [1, 2, 2, 3, 3, 3]
unique = set(list_data)
print(unique)  # {1, 2, 3}

# 从字符串创建
chars = set("hello")
print(chars)  # {'h', 'e', 'l', 'o'}

# 从元组创建
tuple_data = (1, 2, 2, 3)
unique = set(tuple_data)

# 基本推导式
squares = {x ** 2 for x in range(5)}
print(squares)  # {0, 1, 4, 9, 16}

# 带条件
evens = {x for x in range(10) if x % 2 == 0}
print(evens)  # {0, 2, 4, 6, 8}

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

# 不能通过索引访问
# print(fruits[0])  # TypeError

# 每次输出顺序可能不同
print(fruits)  # 顺序不确定

# 自动去重
numbers = {1, 2, 2, 3, 3, 3}
print(numbers)  # {1, 2, 3}

# 利用去重特性
items = [1, 2, 2, 3, 3, 3, 4, 4]
unique_items = list(set(items))
print(unique_items)  # [1, 2, 3, 4]（顺序可能改变）

# 保持顺序去重
def unique_ordered(items):
    seen = set()
    result = []
    for item in items:
        if item not in seen:
            seen.add(item)
            result.append(item)
    return result

# 不可变类型可以作为元素
valid = {1, "hello", 3.14, (1, 2), frozenset([1, 2])}

# 可变类型不能作为元素
# invalid = { [1, 2] }      # TypeError: list不可哈希
# invalid = { {1, 2} }      # TypeError: set不可哈希
# invalid = { {"a": 1} }    # TypeError: dict不可哈希

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

# 遍历元素
for fruit in fruits:
    print(fruit)

# 带索引遍历（使用enumerate）
for i, fruit in enumerate(fruits):
    print(f"{i}: {fruit}")

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

# in检查（效率高，O(1)）
print("apple" in fruits)    # True
print("orange" in fruits)   # False

print("orange" not in fruits)  # True

fruits = {"apple", "banana"}

# add：添加单个元素
fruits.add("cherry")
print(fruits)  # {'apple', 'banana', 'cherry'}

# 添加已存在元素（无效果）
fruits.add("apple")  # 不会重复

# update：添加多个元素
fruits.update(["date", "elderberry"])
print(fruits)

# update可以接受任何可迭代对象
fruits.update({"fig", "grape"})
fruits.update("hi")  # 添加 'h' 和 'i'

fruits = {"apple", "banana", "cherry", "date"}

# remove：删除元素（不存在会报错）
fruits.remove("banana")
print(fruits)  # {'apple', 'cherry', 'date'}

# fruits.remove("orange")  # KeyError

# discard：删除元素（不存在不报错）
fruits.discard("cherry")
fruits.discard("orange")  # 不报错

# pop：随机删除并返回一个元素
removed = fruits.pop()
print(removed)

# clear：清空集合
fruits.clear()
print(fruits)  # set()

original = {1, 2, 3}

# copy方法
copied = original.copy()

# set函数
copied = set(original)

# 注意：集合元素是不可变的，所以没有深拷贝问题

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

# 使用 |
union = a | b
print(union)  # {1, 2, 3, 4, 5}

# 使用 union 方法
union = a.union(b)
print(union)  # {1, 2, 3, 4, 5}

# union 可以接受任何可迭代对象
union = a.union([3, 4, 5])

# |= 原地更新
a |= b  # 或 a.update(b)

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

# 使用 &
intersection = a & b
print(intersection)  # {3, 4}

# 使用 intersection 方法
intersection = a.intersection(b)
print(intersection)  # {3, 4}

# &= 原地更新
a &= b  # 或 a.intersection_update(b)

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

# 使用 -
diff = a - b
print(diff)  # {1, 2}（在a但不在b）

diff = b - a
print(diff)  # {5, 6}（在b但不在a）

# 使用 difference 方法
diff = a.difference(b)
print(diff)  # {1, 2}

# -= 原地更新
a -= b  # 或 a.difference_update(b)

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

# 使用 ^
symmetric_diff = a ^ b
print(symmetric_diff)  # {1, 2, 5, 6}（在a或b但不同时在）

# 使用 symmetric_difference 方法
symmetric_diff = a.symmetric_difference(b)
print(symmetric_diff)  # {1, 2, 5, 6}

# ^= 原地更新
a ^= b  # 或 a.symmetric_difference_update(b)

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

# 子集判断
print(a.issubset(b))      # True
print(a <= b)             # True
print(a < b)              # True（真子集）

# 超集判断
print(b.issuperset(a))    # True
print(b >= a)             # True
print(b > a)              # True（真超集）

a = {1, 2, 3}
b = {4, 5, 6}
c = {3, 4, 5}

# 判断是否无交集
print(a.isdisjoint(b))    # True
print(a.isdisjoint(c))    # False（有共同元素3）

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

# 集合相等（顺序无关）
print(a == b)  # True
print(a != b)  # False

# 创建不可变集合
fs = frozenset([1, 2, 3])
print(fs)  # frozenset({1, 2, 3})

# 不能修改
# fs.add(4)     # AttributeError
# fs.remove(1)  # AttributeError

# 普通集合不能作为字典键
# d = {{1, 2}: "value"}  # TypeError

# frozenset可以作为键
d = {frozenset([1, 2]): "value"}
print(d[frozenset([1, 2])])  # "value"

# frozenset可以作为集合元素
nested = {frozenset([1, 2]), frozenset([3, 4])}
print(nested)  # {frozenset({1, 2}), frozenset({3, 4})}

a = frozenset([1, 2, 3])
b = frozenset([3, 4, 5])

# 支持集合运算（返回新frozenset）
print(a | b)  # frozenset({1, 2, 3, 4, 5})
print(a & b)  # frozenset({3})
print(a - b)  # frozenset({1, 2})

# 列表去重
items = [1, 2, 2, 3, 3, 3, 4]
unique = list(set(items))
print(unique)  # [1, 2, 3, 4]（顺序可能改变）

# 保持顺序去重
def dedupe(items):
    seen = set()
    for item in items:
        if item not in seen:
            seen.add(item)
            yield item

unique = list(dedupe(items))

# 集合的成员检查比列表快得多
items = range(100000)
items_list = list(items)
items_set = set(items)

# 列表：O(n)
# "99999" in items_list  # 较慢

# 集合：O(1)
# "99999" in items_set   # 很快

# 找两个列表的共同元素
list1 = [1, 2, 3, 4, 5]
list2 = [4, 5, 6, 7, 8]

common = set(list1) & set(list2)
print(common)  # {4, 5}

# 找只在一个列表中的元素
list1 = [1, 2, 3, 4, 5]
list2 = [4, 5, 6, 7, 8]

# 在list1但不在list2
unique_to_list1 = set(list1) - set(list2)
print(unique_to_list1)  # {1, 2, 3}

# 在任一列表但不同时存在
unique = set(list1) ^ set(list2)
print(unique)  # {1, 2, 3, 6, 7, 8}