# 創(chuàng)建集合的多種方式
colors = {'red', 'green', 'blue', 'red'}  # 重復(fù)元素自動去重
print(colors)  # 輸出: {'green', 'blue', 'red'}

# 使用set()構(gòu)造函數(shù)
numbers = set([1, 2, 3, 3, 2, 1])
print(numbers)  # 輸出: {1, 2, 3}

# 原始數(shù)據(jù)包含大量重復(fù)項
raw_data = [23, 45, 23, 67, 45, 89, 23, 45, 67, 23, 12]

# 使用集合快速去重
unique_data = set(raw_data)
print(f"原始數(shù)據(jù)量: {len(raw_data)}")
print(f"去重后數(shù)據(jù)量: {len(unique_data)}")
print(f"唯一值集合: {sorted(unique_data)}")

class UserInterestManager:
    def __init__(self):
        self.user_interests = {}
    
    def add_interest(self, user_id, interests):
        """添加用戶興趣標(biāo)簽"""
        if user_id not in self.user_interests:
            self.user_interests[user_id] = set()
        self.user_interests[user_id].update(interests)
    
    def find_common_interests(self, user1_id, user2_id):
        """查找兩個用戶的共同興趣"""
        interests1 = self.user_interests.get(user1_id, set())
        interests2 = self.user_interests.get(user2_id, set())
        return interests1.intersection(interests2)
    
    def get_recommendations(self, user_id):
        """基于其他用戶興趣推薦新標(biāo)簽"""
        user_interests = self.user_interests.get(user_id, set())
        all_interests = set()
        
        for uid, interests in self.user_interests.items():
            if uid != user_id:
                all_interests.update(interests)
        
        # 推薦用戶還沒有的興趣標(biāo)簽
        return all_interests - user_interests

# 使用示例
manager = UserInterestManager()
manager.add_interest("user1", {"python", "AI", "data science"})
manager.add_interest("user2", {"python", "web development", "AI"})

common = manager.find_common_interests("user1", "user2")
print(f"共同興趣: {common}")  # 輸出: {'python', 'AI'}

# 創(chuàng)建不可變集合
immutable_colors = frozenset(['red', 'green', 'blue', 'red'])
print(immutable_colors)  # 輸出: frozenset({'green', 'blue', 'red'})

# 嘗試修改會引發(fā)錯誤
# immutable_colors.add('yellow')  # AttributeError: 'frozenset' object has no attribute 'add'

class SystemConfig:
    # 定義不可變的權(quán)限集合
    READ_PERMISSIONS = frozenset(['view', 'download', 'print'])
    WRITE_PERMISSIONS = frozenset(['create', 'edit', 'delete', 'upload'])
    ADMIN_PERMISSIONS = frozenset(['grant', 'revoke', 'audit'])
    
    # 權(quán)限組映射
    PERMISSION_GROUPS = {
        'reader': READ_PERMISSIONS,
        'editor': READ_PERMISSIONS | WRITE_PERMISSIONS,
        'administrator': READ_PERMISSIONS | WRITE_PERMISSIONS | ADMIN_PERMISSIONS
    }
    
    @classmethod
    def check_permission(cls, user_group, required_permission):
        """檢查用戶組是否擁有特定權(quán)限"""
        user_permissions = cls.PERMISSION_GROUPS.get(user_group, frozenset())
        return required_permission in user_permissions

# 使用示例
print(SystemConfig.check_permission('editor', 'edit'))  # True
print(SystemConfig.check_permission('reader', 'delete'))  # False

class Graph:
    def __init__(self):
        # 使用frozenset作為字典鍵，表示邊的關(guān)系
        self.edges = {}
    
    def add_edge(self, vertex_set, weight):
        """添加邊，頂點(diǎn)集合作為鍵"""
        if len(vertex_set) != 2:
            raise ValueError("邊必須連接兩個頂點(diǎn)")
        
        frozen_vertices = frozenset(vertex_set)
        self.edges[frozen_vertices] = weight
    
    def get_edge_weight(self, vertex1, vertex2):
        """獲取邊的權(quán)重"""
        key = frozenset([vertex1, vertex2])
        return self.edges.get(key, None)
    
    def find_connected_vertices(self, vertex):
        """查找與指定頂點(diǎn)相連的所有頂點(diǎn)"""
        connected = set()
        for edge in self.edges:
            if vertex in edge:
                connected.update(edge - {vertex})
        return connected

# 創(chuàng)建圖結(jié)構(gòu)
graph = Graph()
graph.add_edge({'A', 'B'}, 5)
graph.add_edge({'B', 'C'}, 3)
graph.add_edge({'A', 'C'}, 7)

print(f"A-B權(quán)重: {graph.get_edge_weight('A', 'B')}")  # 輸出: 5
print(f"與B相連的頂點(diǎn): {graph.find_connected_vertices('B')}")  # 輸出: {'A', 'C'}

# 傳統(tǒng)方式
squares_set = set()
for i in range(10):
    squares_set.add(i ** 2)

# 使用集合推導(dǎo)式（更Pythonic）
squares_set = {i ** 2 for i in range(10)}
even_squares = {i ** 2 for i in range(10) if i % 2 == 0}

print(f"所有平方數(shù): {squares_set}")
print(f"偶數(shù)平方數(shù): {even_squares}")

import time

def find_common_elements_list(list1, list2):
    """使用列表查找共同元素（低效）"""
    common = []
    for item in list1:
        if item in list2 and item not in common:
            common.append(item)
    return common

def find_common_elements_set(list1, list2):
    """使用集合查找共同元素（高效）"""
    set1 = set(list1)
    set2 = set(list2)
    return list(set1.intersection(set2))

# 性能測試
large_list1 = list(range(10000))
large_list2 = list(range(5000, 15000))

start = time.time()
result_list = find_common_elements_list(large_list1, large_list2)
list_time = time.time() - start

start = time.time()
result_set = find_common_elements_set(large_list1, large_list2)
set_time = time.time() - start

print(f"列表方法耗時: {list_time:.4f}秒")
print(f"集合方法耗時: {set_time:.4f}秒")
print(f"性能提升: {list_time/set_time:.1f}倍")

class ProductRecommender:
    def __init__(self):
        # 用戶購買歷史：用戶ID -> 購買商品ID集合
        self.purchase_history = {}
        # 商品相似度：商品ID -> 相似商品ID集合
        self.product_similarity = {}
    
    def record_purchase(self, user_id, product_ids):
        """記錄用戶購買記錄"""
        if user_id not in self.purchase_history:
            self.purchase_history[user_id] = set()
        self.purchase_history[user_id].update(product_ids)
    
    def calculate_similarity(self, product_id1, product_id2, common_buyers):
        """計算商品相似度"""
        buyers1 = set()
        buyers2 = set()
        
        for user_id, products in self.purchase_history.items():
            if product_id1 in products:
                buyers1.add(user_id)
            if product_id2 in products:
                buyers2.add(user_id)
        
        # 使用Jaccard相似度系數(shù)
        intersection = len(buyers1.intersection(buyers2))
        union = len(buyers1.union(buyers2))
        
        if union == 0:
            return 0
        
        similarity = intersection / union
        if similarity >= 0.1:  # 相似度閾值
            if product_id1 not in self.product_similarity:
                self.product_similarity[product_id1] = set()
            self.product_similarity[product_id1].add(product_id2)
            
            if product_id2 not in self.product_similarity:
                self.product_similarity[product_id2] = set()
            self.product_similarity[product_id2].add(product_id1)
        
        return similarity
    
    def recommend_products(self, user_id, max_recommendations=5):
        """為用戶推薦商品"""
        if user_id not in self.purchase_history:
            return []
        
        purchased = self.purchase_history[user_id]
        recommendations = set()
        
        for product_id in purchased:
            similar = self.product_similarity.get(product_id, set())
            # 排除已購買的商品
            recommendations.update(similar - purchased)
        
        # 返回推薦列表（按某種規(guī)則排序）
        return list(recommendations)[:max_recommendations]

# 模擬電商推薦系統(tǒng)
recommender = ProductRecommender()

# 模擬購買記錄
recommender.record_purchase("user1", {"p1", "p2", "p3"})
recommender.record_purchase("user2", {"p2", "p3", "p4"})
recommender.record_purchase("user3", {"p1", "p3", "p5"})

# 計算商品相似度
recommender.calculate_similarity("p1", "p2", 2)
recommender.calculate_similarity("p2", "p3", 3)

# 獲取推薦
recs = recommender.recommend_products("user1")
print(f"為用戶1推薦的商品: {recs}")