import time

large_list = list(range(1000000))
large_set = set(large_list)

start = time.time()
_ = 999999 in large_list  # 列表查找
list_time = time.time() - start

start = time.time()
_ = 999999 in large_set   # 集合查找
set_time = time.time() - start

print(f"列表查找耗時: {list_time:.6f}秒")
print(f"集合查找耗時: {set_time:.6f}秒")
# 典型輸出: 列表0.08秒 vs 集合0.000001秒！

set.update(iterable)

# 場景：向集合添加10000個元素
s1 = set()
s2 = set()

# 使用add方法（低效）
start = time.time()
for i in range(10000):
    s1.add(i)
add_time = time.time() - start

# 使用update方法（高效）
start = time.time()
s2.update(range(10000))  # 直接傳入可迭代對象
update_time = time.time() - start

print(f"add方法耗時: {add_time:.6f}秒")
print(f"update方法耗時: {update_time:.6f}秒")
print(f"速度提升: {add_time/update_time:.1f}倍")

def is_iterable(obj):
    try:
        iter(obj)
        return True
    except TypeError:
        return False

print(is_iterable([1, 2, 3]))  # True - 列表
print(is_iterable("hello"))    # True - 字符串
print(is_iterable(123))        # False - 整數(shù)不可迭代

fruits = {"apple", "banana"}
new_fruits = ["orange", "grape", "apple"]  # 包含重復(fù)項

fruits.update(new_fruits)
print(fruits) 
# 輸出: {'banana', 'apple', 'grape', 'orange'} 
# 注意: 1. 順序改變（集合無序） 2. 重復(fù)的'apple'被自動忽略

# 元組更新（高效且不可變）
codes = {100, 200}
codes.update((300, 400, 500)) 
print(codes)  # {100, 200, 300, 400, 500}

# 字符串更新（字符級拆分）
chars = {'a', 'b'}
chars.update("hello") 
print(chars)  # {'a', 'b', 'h', 'e', 'l', 'o'} 
# 注意: 'l'出現(xiàn)兩次但集合中只保留一個

user_data = {"name": "Alice", "age": 30}
s = {1, 2}

# 默認：添加鍵
s.update(user_data)
print(s)  # {1, 2, 'name', 'age'}

# 添加值
s.update(user_data.values())
print(s)  # {1, 2, 'name', 'age', 'Alice', 30}

# 添加鍵值對（作為元組）
s.update(user_data.items())
print(s)  # {1, 2, 'name', 'age', 'Alice', 30, ('name', 'Alice'), ('age', 30)}

main_set = {1, 2}
nested_sets = [{3, 4}, {4, 5}]  # 列表包含集合

# 直接update會添加集合對象本身
main_set.update(nested_sets)
print(main_set)  # {1, 2, {3, 4}, {4, 5}} → 包含子集合

# 正確做法：扁平化處理
main_set = {1, 2}
for subset in nested_sets:
    main_set.update(subset)  # 逐個更新子集
print(main_set)  # {1, 2, 3, 4, 5}

# 假設(shè)有l(wèi)arge_data.txt，每行一個整數(shù)
with open("large_data.txt", "r") as f:
    # 逐行讀取并轉(zhuǎn)換為int（生成器表達式）
    data_generator = (int(line.strip()) for line in f)
    
    unique_numbers = set()
    unique_numbers.update(data_generator)  # 流式添加，內(nèi)存友好

print(f"唯一數(shù)字數(shù)量: {len(unique_numbers)}")

import requests

def fetch_users():
    # 模擬API調(diào)用（真實項目替換為實際URL）
    response = requests.get("https://jsonplaceholder.typicode.com/users")
    return [user['id'] for user in response.json()]

active_users = {101, 102}
new_users = fetch_users()  # 假設(shè)返回[1, 2, 3, ...]

active_users.update(new_users)
print(f"總活躍用戶: {len(active_users)}")

class EvenNumbers:
    def __init__(self, limit):
        self.limit = limit
        self.current = 0
    
    def __iter__(self):
        return self
    
    def __next__(self):
        self.current += 2
        if self.current > self.limit:
            raise StopIteration
        return self.current

evens = EvenNumbers(10)
number_set = {1, 3}
number_set.update(evens)  # 傳入自定義迭代器
print(number_set)  # {1, 3, 2, 4, 6, 8, 10}

s = {1, 2}

# 錯誤1: 傳遞非可迭代對象
try:
    s.update(123)  # 整數(shù)不可迭代
except TypeError as e:
    print(f"錯誤類型: {type(e).__name__}")
    print(f"錯誤信息: {e}")
    # 修復(fù): 包裝成可迭代對象
    s.update([123])
    print(f"修復(fù)后: {s}")  # {1, 2, 123}

# 錯誤2: 傳遞不可哈希元素
try:
    s.update([[1, 2]])  # 列表不可哈希
except TypeError as e:
    print(f"錯誤信息: {e}")
    # 修復(fù): 轉(zhuǎn)換為元組
    s.update([(1, 2)])
    print(f"修復(fù)后: {s}")  # {1, 2, 123, (1, 2)}

from itertools import chain

set_a = {1, 2}
set_b = {2, 3}
set_c = {3, 4}

# 傳統(tǒng)方式（低效）
combined = set_a.copy()
combined.update(set_b)
combined.update(set_c)

# 高效方式（單次update）
combined = set_a.copy()
combined.update(chain(set_b, set_c))  # 等效于set_b.update(set_c)

print(combined)  # {1, 2, 3, 4}

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

# 兩種等效寫法
a.update(b)
# 等價于
a |= b  # 并集賦值運算符

print(a)  # {1, 2, 3}

# 但注意: a = a | b 會創(chuàng)建新集合（非原地修改）

tags = {"python"}
tags.update("django")  # 期望添加"django"，實際添加了d,j,a,n,g,o
print(tags)  # {'python', 'd', 'j', 'a', 'n', 'g', 'o'} → 錯誤！

# 方法1: 包裝成列表
tags.update(["django"])

# 方法2: 使用add添加單個字符串
tags.add("django")

config = {"theme": "dark", "font": "Arial"}
s = set()

s.update(config)        # 添加鍵 → {'theme', 'font'}
s.update(config.values()) # 添加值 → {'theme', 'font', 'dark', 'Arial'}
s.update(config.items())  # 添加元組 → 包含('theme','dark')等

s = set()
s.update([[1, 2]])  # 列表不可哈希 → TypeError

# 轉(zhuǎn)換為元組
s.update([(1, 2)])  # 成功添加元組(1,2)

# 或使用frozenset
s.update([frozenset([1, 2])])

# 錯誤：先創(chuàng)建大列表再update
big_list = list(range(1000000))
s = set()
s.update(big_list)  # 額外占用列表內(nèi)存

# 正確：直接使用生成器
s = set()
s.update(range(1000000))  # range是輕量級迭代器

import sys
print(sys.getsizeof(list(range(1000000))))  # 約8,000,056字節(jié)
print(sys.getsizeof(range(1000000)))        # 僅48字節(jié)！

s = {1, 2, 3}
for item in s:
    if item % 2 == 0:
        s.update([item * 10])  # 危險！可能跳過元素

for item in set(s):  # 迭代副本
    if item % 2 == 0:
        s.update([item * 10])

from collections import deque
import requests

class Crawler:
    def __init__(self):
        self.visited = set()  # 已訪問URL
        self.queue = deque()  # 待爬取隊列
    
    def crawl(self, start_url, max_pages=100):
        self.queue.append(start_url)
        
        while self.queue and len(self.visited) < max_pages:
            url = self.queue.popleft()
            
            # 跳過已訪問
            if url in self.visited:
                continue
                
            try:
                response = requests.get(url, timeout=5)
                self.visited.add(url)  # 標記為已訪問
                
                # 提取新鏈接（簡化版）
                new_links = self.extract_links(response.text)
                
                # 批量添加新鏈接（高效去重）
                self.queue.extend(new_links)
                self.visited.update(new_links)  # 關(guān)鍵：批量更新
                
            except Exception as e:
                print(f"爬取{url}失敗: {str(e)}")
    
    def extract_links(self, html):
        # 實際項目用BeautifulSoup解析
        return ["https://example.com/page1", "https://example.com/page2"]

crawler = Crawler()
crawler.crawl("https://example.com")
print(f"成功爬取 {len(crawler.visited)} 個頁面")

error_codes = set()

with open("server.log", "r") as log_file:
    # 生成器表達式：僅提取錯誤行的錯誤碼
    error_gen = (
        line.split()[5]  # 假設(shè)錯誤碼在第6列
        for line in log_file 
        if "ERROR" in line
    )
    
    error_codes.update(error_gen)  # 流式添加

print(f"發(fā)現(xiàn) {len(error_codes)} 種唯一錯誤碼:")
print(", ".join(sorted(error_codes)))

class Inventory:
    def __init__(self):
        self.items = set()
    
    def sync_warehouse(self, warehouse_id):
        """從API同步指定倉庫庫存"""
        api_url = f"https://api.warehouse.com/{warehouse_id}/stock"
        response = requests.get(api_url)
        stock_data = response.json()
        
        # 提取商品ID（假設(shè)API返回列表）
        item_ids = [item['id'] for item in stock_data]
        
        # 原子化更新：避免部分更新問題
        new_set = self.items.copy()
        new_set.update(item_ids)
        self.items = new_set  # 替換為新集合（線程安全）
    
    def sync_all(self, warehouse_ids):
        """同步所有倉庫"""
        for wid in warehouse_ids:
            self.sync_warehouse(wid)
        print(f"總庫存商品: {len(self.items)}")

inv = Inventory()
inv.sync_all([101, 102, 103])

# 從多個列表創(chuàng)建集合
sources = [
    ["apple", "banana"],
    ("orange", "grape"),
    "hello"
]

# 傳統(tǒng)方式
result = set()
for src in sources:
    result.update(src)

# 更Pythonic的方式
result = {item for src in sources for item in src}
print(result)  # {'a', 'p', 'l', 'e', 'b', 'n', 'o', 'r', 'g', 'h'}

def batch_add(collection, *iterables):
    """向集合批量添加多個可迭代對象"""
    for it in iterables:
        collection.update(it)
    return collection

# 使用示例
users = {"admin"}
batch_add(users, ["user1", "user2"], ("user3",))
print(users)  # {'admin', 'user1', 'user2', 'user3'}

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

# 傳統(tǒng)：多次update
a.update(b)
a.update(c)

# 鏈式運算符（更簡潔）
a |= b | c  # 等價于 a = a | b | c

print(a)  # {1, 2, 3, 4, 5}

def safe_update(target_set, iterable, skip_errors=True):
    """安全添加元素，跳過不可哈希項"""
    for item in iterable:
        try:
            # 嘗試添加（觸發(fā)哈希計算）
            target_set.add(item)
        except TypeError:
            if not skip_errors:
                raise

# 使用示例
s = {1, 2}
safe_update(s, [3, [4,5], 6])  # 跳過列表[4,5]
print(s)  # {1, 2, 3, 6}

import timeit

setup = """
s = set(range(1000))
new_data = range(1000, 2000)
"""

# 測試1: update
time_update = timeit.timeit("s.update(new_data)", setup, number=1000)

# 測試2: union
time_union = timeit.timeit("s.union(new_data)", setup, number=1000)

print(f"update 1000次耗時: {time_update:.4f}s")
print(f"union 1000次耗時: {time_union:.4f}s")
# 典型輸出: update 0.003s vs union 0.12s → 快40倍！

# 場景: 添加多個數(shù)據(jù)源
final_set = set()
final_set.update(source1)  # 列表/元組
final_set.update(source2)  # 生成器
final_set.update(source3)  # 字典.values()

# 替代低效寫法
# final_set = set(source1) | set(source2) | set(source3)  # 創(chuàng)建3個臨時集合