Python集合类型set的无序不重复特性

my_set = {1, 2, 3}
print(my_set[0])  # 报错！TypeError: 'set' object is not subscriptable

# 顺序1：先a后b
set_a = {"apple", "banana", "cherry"}
# 顺序2：先c后b
set_b = {"cherry", "banana", "apple"}
print("Set A:", set_a)  # 输出可能：{'banana', 'apple', 'cherry'}
print("Set B:", set_b)  # 输出可能：{'cherry', 'banana', 'apple'}
print("A == B?", set_a == set_b)  # 输出：True

users = {"alice", "bob"}
print("初始:", users)  # 输出：{'bob', 'alice'}
users.add("charlie")
print("添加后:", users)  # 输出可能：{'charlie', 'bob', 'alice'} 或 {'bob', 'charlie', 'alice'}
users.add("alice")  # 重复添加
print("再添加alice:", users)  # 输出不变！仍为{'charlie', 'bob', 'alice'}

# 模拟从文件读取的数据（含重复）
raw_ids = [101, 205, 101, 307, 205, 409]
# 转换为set自动去重
unique_ids = set(raw_ids)
print("原始数据:", raw_ids)
print("唯一ID:", unique_ids)

tags = ["Python", "data", "PYTHON", "Data", "AI"]
# 忽略大小写去重
clean_tags = set(tag.lower() for tag in tags)
print("清洗后标签:", clean_tags)

class User:
    def __init__(self, id, name):
        self.id = id
        self.name = name
    def __hash__(self):
        return hash(self.id)  # 用ID作为哈希依据
    def __eq__(self, other):
        return self.id == other.id
# 创建用户对象
u1 = User(1, "Alice")
u2 = User(2, "Bob")
u3 = User(1, "Alicia")  # ID相同，视为重复
user_set = {u1, u2, u3}
print("用户集合大小:", len(user_set))  # 输出：2（u1和u3视为同一元素）

nums = {0.1 + 0.2, 0.3}
print(nums)  # 输出：{0.30000000000000004, 0.3} → 两个元素！

# 错误：尝试将列表放入set
try:
    invalid_set = {[1, 2], [3, 4]}
except TypeError as e:
    print("错误:", e)  # 输出：unhashable type: 'list'

valid_set = {(1, 2), (3, 4)}  # 正确

null_set = {None, None}
print(null_set)  # 输出：{None} → 仅一个None

fruits = {"apple", "banana", "cherry"}  # 正确
empty_set = {}  # 错误！这是空字典(dict)

colors = set(["red", "green", "blue"])  # 从列表转换
empty_set = set()  # 正确的空set

# 列表 → set（自动去重）
names = ["Tom", "Jerry", "Tom", "Spike"]
unique_names = set(names)
print(unique_names)  # {'Jerry', 'Spike', 'Tom'}
# 字符串 → set（拆分为唯一字符）
chars = set("hello")
print(chars)  # {'l', 'e', 'o', 'h'} → 注意：无序且去重
# 字典 → set（仅保留键）
user_data = {"id": 101, "name": "Alice", "age": 30}
keys_set = set(user_data)
print(keys_set)  # {'id', 'name', 'age'}

# 示例1：平方数去重
squares = {x*x for x in range(5)}
print(squares)  # {0, 1, 4, 9, 16}
# 示例2：过滤偶数并平方
even_squares = {x*x for x in range(10) if x % 2 == 0}
print(even_squares)  # {0, 4, 16, 36, 64}
# 示例3：处理字符串（转小写去重）
text = "Hello World"
unique_letters = {char.lower() for char in text if char.isalpha()}
print(unique_letters)  # {'d', 'e', 'h', 'l', 'o', 'r', 'w'}

# 创建frozenset
fset = frozenset(["a", "b", "c"])
# 尝试修改会报错
try:
    fset.add("d")
except AttributeError as e:
    print("错误:", e)  # 'frozenset' object has no attribute 'add'
# 但可用于字典键（因可哈希）
cache = {frozenset([1,2]): "value"}
print(cache)  # {frozenset({1, 2}): 'value'}

s = {1, 2}
s.add(3)
print(s)  # {1, 2, 3}
s.add(2)  # 重复添加，无变化
print(s)  # {1, 2, 3}

s = {"a", "b"}
s.update(["c", "d"])  # 从列表添加
print(s)  # {'a', 'b', 'c', 'd'}
s.update("ef")  # 字符串视为字符序列
print(s)  # {'a', 'b', 'c', 'd', 'e', 'f'}
# 等效于：s |= set(["c","d"]) 或 s = s | {"c","d"}

s = {10, 20, 30}
s.remove(20)
print(s)  # {10, 30}
s.remove(40)  # KeyError: 40

s = {10, 20, 30}
s.discard(20)
print(s)  # {10, 30}
s.discard(40)  # 无错误，集合不变
print(s)  # {10, 30}

s = {"x", "y", "z"}
removed = s.pop()
print("移除:", removed)  # 可能是'x','y'或'z'
print("剩余:", s)       # 剩余两个元素

allowed_users = {"admin", "manager", "editor"}
# 高效检查权限
if "guest" in allowed_users:
    print("访问允许")
else:
    print("拒绝访问")  # 输出：拒绝访问
# 与列表对比（大数据量时差距巨大）
import time
big_list = list(range(1000000))
big_set = set(big_list)
start = time.time()
1000000 in big_list  # 列表：需遍历全部
print("列表检查耗时:", time.time() - start)  # 约0.1秒
start = time.time()
1000000 in big_set   # 集合：直接哈希定位
print("集合检查耗时:", time.time() - start)  # 约0.000001秒

s = {1, 2, 3}
s.clear()
print(s)  # set() → 空集合

original = {1, 2, 3}
copy_ref = original  # 引用同一对象
copy_ref.add(4)
print(original)  # {1, 2, 3, 4} → 原始集合被修改！
# 正确复制方式
safe_copy = original.copy()  # 或 set(original)
safe_copy.add(5)
print(original)   # {1, 2, 3, 4} → 不变
print(safe_copy)  # {1, 2, 3, 4, 5}

A = {1, 2, 3}
B = {3, 4, 5}
# 操作符方式
union_set = A | B
print(union_set)  # {1, 2, 3, 4, 5}
# 方法方式（可接受任意可迭代对象）
union_list = A.union([3, 4, 5, 6])
print(union_list)  # {1, 2, 3, 4, 5, 6}

A = {"apple", "banana", "cherry"}
B = {"banana", "cherry", "date"}
common = A & B
print(common)  # {'banana', 'cherry'}
# 多集合交集
C = {"cherry", "date", "elderberry"}
common_all = A.intersection(B, C)
print(common_all)  # {'cherry'}

user1_movies = {"Inception", "Interstellar", "Tenet"}
user2_movies = {"Interstellar", "Dunkirk", "Tenet"}
common_movies = user1_movies & user2_movies
print("共同喜好:", common_movies)  # {'Interstellar', 'Tenet'}

A = {10, 20, 30, 40}
B = {30, 40, 50}
only_in_A = A - B
print(only_in_A)  # {10, 20}
# 等效方法
only_in_A = A.difference(B)

yesterday_users = {"alice", "bob"}
today_users = {"bob", "charlie", "diana"}
new_users = today_users - yesterday_users
print("新用户:", new_users)  # {'charlie', 'diana'}

A = {"x", "y", "z"}
B = {"y", "z", "w"}
sym_diff = A ^ B
print(sym_diff)  # {'x', 'w'}
# 等效于 (A - B) | (B - A)

old_config = {"theme": "dark", "lang": "en", "zoom": 100}
new_config = {"theme": "light", "lang": "en", "zoom": 120}
# 提取键的变化（忽略值）
changed_keys = set(old_config.keys()) ^ set(new_config.keys())
print("变更的配置项:", changed_keys)  # {'theme', 'zoom'} → lang未变

A = {1, 2}
B = {1, 2, 3}
print(A <= B)  # True → A是B的子集
print(B >= A)  # True → B是A的超集
C = {4, 5}
print(A.isdisjoint(C))  # True → A和C无交集

渲染错误: Mermaid 渲染失败: Parse error on line 3: ...>|Union| U[Union: A | B] B[Set B -----------------------^ Expecting 'SQE', 'TAGEND', 'UNICODE_TEXT', 'TEXT', 'TAGSTART', got 'PIPE'

A = {1, 2, 3}
B = {2, 3, 4}
C = {3, 4, 5}
# (A ∪ B) ∩ C
result = (A | B) & C
print(result)  # {3, 4}
# A - (B ∩ C)
result = A - (B & C)
print(result)  # {1}

active_users = {"u1", "u2", "u3"}
paid_users = {"u2", "u3", "u4"}
churned_users = {"u3"}
# 找出活跃的付费用户（未流失）
target_users = (active_users & paid_users) - churned_users
print("目标用户:", target_users)  # {'u2'}

A = {1, 2, 3}
B = {3, 4, 5}
# 原地并集：A变为A|B
A.update(B)
print(A)  # {1, 2, 3, 4, 5} → B未变
# 原地差集：A变为A-B
A.difference_update(B)
print(A)  # {1, 2}

import csv
# 模拟从文件读取
comments = []
with open("reviews.csv") as f:
    reader = csv.reader(f)
    for row in reader:
        comments.append(row[0])
# 传统方式（低效）
unique_comments_loop = []
for c in comments:
    if c not in unique_comments_loop:  # O(n) per check!
        unique_comments_loop.append(c)
# set方式（高效）
unique_comments_set = list(set(comments))  # O(n)总时间
print("去重后评论数:", len(unique_comments_set))

# 初始化白名单（仅需一次）
whitelist = set()
with open("whitelist.csv") as f:
    for email in f:
        whitelist.add(email.strip())
# 登录验证（高频操作）
def check_access(email):
    return email in whitelist  # O(1)时间！
print(check_access("user@example.com"))  # True/False 立即返回

# 模拟数据库查询
bought_phone = {"u1", "u2", "u3", "u4"}
viewed_headphones = {"u3", "u4", "u5", "u6"}
# 目标用户 = 买手机用户 - 浏览耳机用户
target_users = bought_phone - viewed_headphones
print("推送广告给:", target_users)  # {'u1', 'u2'}
# 进阶：排除已流失用户
churned_users = {"u2", "u7"}
final_target = target_users - churned_users
print("最终目标:", final_target)  # {'u1'}

def jaccard_sim(text1, text2):
    # 转小写并拆分为词集合
    set1 = set(text1.lower().split())
    set2 = set(text2.lower().split())
    # 计算交集和并集大小
    intersection = len(set1 & set2)
    union = len(set1 | set2)
    return intersection / union if union > 0 else 0
# 测试
text_a = "Python is great for data science"
text_b = "Data science with Python is awesome"
similarity = jaccard_sim(text_a, text_b)
print(f"相似度: {similarity:.2f}")  # 0.57（57%）

# 模拟用户关系（字典：用户→好友集合）
graph = {
    "alice": {"bob", "charlie"},
    "bob": {"alice", "diana"},
    "charlie": {"alice", "diana", "eve"},
    "diana": {"bob", "charlie"},
    "eve": {"charlie"}
}
def second_degree(user):
    # 一度好友
    first_degree = graph[user]
    # 二度好友 = 一度好友的好友 - 一度好友 - 自身
    second_degree = set()
    for friend in first_degree:
        second_degree |= graph[friend]  # 并集
    return second_degree - first_degree - {user}
print(second_degree("alice"))  # {'diana', 'eve'}

# 旧配置（从数据库加载）
old_config = {
    "service_a": {"port": 8080, "timeout": 30},
    "service_b": {"port": 8000}
}
# 新配置（用户提交）
new_config = {
    "service_a": {"port": 8080, "timeout": 45},  # timeout变更
    "service_c": {"port": 9000}                # 新增服务
}
# 提取键的变化
old_keys = set(old_config.keys())
new_keys = set(new_config.keys())
changed_keys = old_keys ^ new_keys  # 对称差集
# 重启受影响服务
for service in changed_keys:
    print(f"重启服务: {service}")  # 输出: service_b, service_c
# 进阶：检测具体参数变化（需遍历）
for service in old_keys & new_keys:  # 交集：服务存在
    if old_config[service] != new_config[service]:
        print(f"参数变更: {service}")

# 活跃物品集合（动态更新）
active_items = {"coin1", "coin2", "gem"}
# 角色接触的物品ID（模拟）
touched_items = {"coin1", "gem"}
# 检测是否接触任何活跃物品
if touched_items & active_items:  # 交集非空
    print("获得物品！")
    # 移除已收集物品
    active_items -= touched_items

import timeit
# 生成100万唯一整数
data = list(range(1000000))
target = 999999  # 检查最后一个元素
# 测试列表
list_time = timeit.timeit(
    stmt="target in data",
    setup="from __main__ import data, target",
    number=100
)
# 测试集合
s = set(data)
set_time = timeit.timeit(
    stmt="target in s",
    setup="from __main__ import s, target",
    number=100
)
print(f"列表检查100次耗时: {list_time:.4f}秒")
print(f"集合检查100次耗时: {set_time:.4f}秒")
print(f"集合快 {list_time/set_time:.0f}倍")

import sys
# 100万整数
lst = list(range(1000000))
st = set(range(1000000))
print(f"列表内存: {sys.getsizeof(lst):,} 字节")
print(f"集合内存: {sys.getsizeof(st):,} 字节")

# 已知有100万元素
s = set(1000000)  # 避免多次哈希表重建

# 小数据用列表
if len(data) < 10:
    result = [x for x in data if x in small_list]
else:
    result = [x for x in data if x in set(small_list)]

# 作为字典键时更快
cache = {frozenset(["a","b"]): "value"}

# 慢：创建新set
result = A | B | C
# 快：原地更新
result = set(A)
result.update(B)
result.update(C)

empty = {}  # 实际是空字典！
print(type(empty))  # <class 'dict'>

empty_set = set()  # 唯一创建空set的方式

s = {"a", "b", "c"}
print(s[0])  # TypeError: 'set' object is not subscriptable

first = next(iter(s))  # 获取"随机"第一个元素
ordered = sorted(s)    # 排序后访问
print(ordered[0])      # 安全访问

s = {1, 2, 3}
for item in s:
    s.remove(item)  # RuntimeError: set changed size during iteration

s = {[1, 2], [3, 4]}  # TypeError: unhashable type: 'list'

s = {0.1 + 0.2, 0.3}
print(len(s))  # 输出：2（因0.1+0.2 != 0.3）

s = {1, 2, 3}
s.remove(4)  # KeyError: 4

# 尝试用set作为字典键
cache = {{1,2}: "value"}  # TypeError: unhashable type: 'set'

cache = {frozenset([1,2]): "value"}  # 正确

# set → dict（带默认值）
s = {"a", "b"}
d = dict.fromkeys(s, 0)  # {'a': 0, 'b': 0}
# dict → set（取键）
d = {"x": 1, "y": 2}
s = set(d)  # {'x', 'y'}