Python使用for循环遍历无序元素的方法步骤

# 创建集合的多种方式
fruits = {"apple", "banana", "cherry"}
numbers = set([1, 2, 3, 2, 1])  # 自动去重 → {1, 2, 3}
mixed = {True, 42, "hello"}     # 混合类型（注意：True=1可能冲突）

print(f"水果集合: {fruits}")
print(f"数字集合（去重后）: {numbers}")
print(f"混合集合: {mixed}")

# 尝试用索引访问 → 会报错！
try:
    print(fruits[0])
except TypeError as e:
    print(f"错误: {e}")  # 输出: 'set' object is not subscriptable

水果集合: {'cherry', 'apple', 'banana'}
数字集合（去重后）: {1, 2, 3}
混合集合: {True, 42, 'hello'}
错误: 'set' object is not subscriptable

for element in my_set:
    # 处理 element

colors = {"red", "green", "blue"}

print("遍历颜色集合:")
for color in colors:
    print(f"• 颜色: {color} 🎨")

遍历颜色集合:
• 颜色: blue 🎨
• 颜色: red 🎨
• 颜色: green 🎨

def show_set_order():
    s = {"a", "b", "c", "d", "e", "f"}
    print("本次遍历顺序:", end=" ")
    for char in s:
        print(char, end=" ")
    print()

# 运行5次观察变化
for i in range(5):
    show_set_order()

本次遍历顺序: e a f c d b 
本次遍历顺序: c b f d e a 
本次遍历顺序: d b f c e a 
本次遍历顺序: f b d c e a 
本次遍历顺序: b f d c e a 

names = {"Zoe", "Adam", "Charlie"}

# 方法1：转换为排序列表后遍历
print("按字母顺序遍历:")
for name in sorted(names):  # sorted()返回新列表
    print(f"• {name}")

# 方法2：使用sorted()直接处理（更高效）
print("\n高效排序遍历:")
for name in sorted(names, reverse=True):  # 降序
    print(f"• {name} (倒序)")

按字母顺序遍历:
• Adam
• Charlie
• Zoe

高效排序遍历:
• Zoe (倒序)
• Charlie (倒序)
• Adam (倒序)

numbers = {1, 2, 3, 4, 5}

# 危险！可能引发RuntimeError或逻辑错误
for num in numbers:
    if num % 2 == 0:
        numbers.remove(num)  # ❌ 大忌！

RuntimeError: Set changed size during iteration

numbers = {1, 2, 3, 4, 5}
for num in set(numbers):  # 创建副本
    if num % 2 == 0:
        numbers.remove(num)  # ✅ 安全

print("删除偶数后:", numbers)  # 输出: {1, 3, 5}

numbers = {1, 2, 3, 4, 5}
numbers = {num for num in numbers if num % 2 != 0}  # ✅ 一行解决
print("奇数集合:", numbers)

numbers = {1, 2, 3, 4, 5}
temp_list = list(numbers)
for num in temp_list:
    if num > 3:
        numbers.discard(num)  # discard()安全删除（无元素不报错）
print("小于等于3的数:", numbers)  # 输出: {1, 2, 3}

languages = {"Python", "Java", "C++"}

print("语言排名（基于当前顺序）:")
for index, lang in enumerate(languages, start=1):
    print(f"{index}. {lang} 🔢")

语言排名（基于当前顺序）:
1. Java 🔢
2. C++ 🔢
3. Python 🔢

for index, lang in enumerate(sorted(languages), 1):
    print(f"{index}. {lang} (字母顺序)")

set1 = {"a", "b", "c"}
set2 = {10, 20, 30}

print("配对元素:")
for x, y in zip(set1, set2):
    print(f"{x} ↔ {y}")

配对元素:
b ↔ 20
a ↔ 10
c ↔ 30

# 先转换为排序列表
for x, y in zip(sorted(set1), sorted(set2)):
    print(f"{x} ↔ {y} (有序配对)")

raw_emails = ["user1@example.com", "user2@example.com", "user1@example.com"]
unique_emails = set(raw_emails)  # 自动去重

print("有效邮箱列表:")
for email in unique_emails:
    if "@" in email:  # 简单验证
        print(f"• {email} ✉️")

有效邮箱列表:
• user1@example.com ✉️
• user2@example.com ✉️

group_a = {"sports", "music", "travel"}
group_b = {"music", "cooking", "travel"}

common_interests = group_a & group_b  # 交集

print("共同兴趣点:")
for interest in common_interests:
    print(f"🌟 {interest}")

共同兴趣点:
🌟 travel
🌟 music

all_user_ids = range(1, 1000001)  # 模拟100万个ID
valid_ids = {1001, 2002, 3003, 4004}  # 有效ID集合

# 高效遍历并检查成员资格（O(1)操作）
print("找到的有效用户:")
for user_id in all_user_ids:
    if user_id in valid_ids:  # 集合的in检查极快
        print(f"✅ 用户 {user_id}")
        # 实际项目中这里可能调用API或写入数据库

data = [10, 20, 30]
ordered_set = set(data)  # 无序
ordered_list = list(data) # 有序

print("列表遍历（固定顺序）:")
for x in ordered_list:
    print(x, end=" ")  # 总是 10 20 30

print("\n\n集合遍历（随机顺序）:")
for x in ordered_set:
    print(x, end=" ")  # 可能 20 10 30 或其他

列表遍历（固定顺序）:
10 20 30 

集合遍历（随机顺序）:
20 10 30 

import timeit

# 创建10万元素的集合和列表
large_set = set(range(100000))
large_list = list(range(100000))

# 测试遍历速度
set_time = timeit.timeit(
    "for x in s: pass", 
    setup="from __main__ import large_set as s", 
    number=100
)

list_time = timeit.timeit(
    "for x in lst: pass", 
    setup="from __main__ import large_list as lst", 
    number=100
)

print(f"集合遍历100次耗时: {set_time:.4f}秒")
print(f"列表遍历100次耗时: {list_time:.4f}秒")
print(f"集合比列表快 {list_time/set_time:.1f}倍")

集合遍历100次耗时: 0.2153秒
列表遍历100次耗时: 0.2201秒
集合比列表快 1.0倍

# 测试"检查最后元素是否存在"
set_check = timeit.timeit(
    "99999 in s", 
    setup="from __main__ import large_set as s", 
    number=100000
)

list_check = timeit.timeit(
    "99999 in lst", 
    setup="from __main__ import large_list as lst", 
    number=100000
)

print(f"集合成员检查10万次: {set_check:.4f}秒")
print(f"列表成员检查10万次: {list_check:.4f}秒")
print(f"集合检查快 {list_check/set_check:.0f}倍")

集合成员检查10万次: 0.0087秒
列表成员检查10万次: 7.8421秒
集合检查快 901倍

words = {"hello", "world", "python"}
processed = []

print("逐步遍历:")
for word in words:
    processed.append(word.upper())
    print(f"当前: {word} → 处理后: {processed}")

逐步遍历:
当前: world → 处理后: ['WORLD']
当前: hello → 处理后: ['WORLD', 'HELLO']
当前: python → 处理后: ['WORLD', 'HELLO', 'PYTHON']

order_log = []
for item in {"a", "b", "c"}:
    order_log.append(item)
print("本次遍历顺序记录:", order_log)

本次遍历顺序记录: ['c', 'a', 'b']

# ⚠️ 仅用于调试！生产环境勿用
for item in sorted(words, key=lambda x: hash(x)):
    print(f"伪固定顺序: {item}")

active_users = set()  # 存储当前活跃用户ID

def process_user_activity(activity_stream):
    """处理实时用户活动流"""
    for event in activity_stream:
        user_id = event["user_id"]
        
        # 新用户加入活跃集合
        if event["type"] == "login":
            active_users.add(user_id)
        
        # 登出时移除（安全操作：遍历副本）
        elif event["type"] == "logout":
            # 创建副本避免RuntimeError
            for uid in set(active_users):
                if uid == user_id:
                    active_users.remove(uid)
    
    # 遍历活跃用户发送通知（高效！）
    for user in active_users:
        send_notification(user, "Your session is active")

# 模拟活动流
activity_stream = [
    {"user_id": 101, "type": "login"},
    {"user_id": 102, "type": "login"},
    {"user_id": 101, "type": "logout"}
]

process_user_activity(activity_stream)
print("最终活跃用户:", active_users)  # 输出: {102}

def process_large_data(file_path):
    unique_records = set()
    
    with open(file_path, "r") as f:
        for line in f:
            record = line.strip()
            # 跳过空行和无效数据
            if not record or record.startswith("#"):
                continue
            unique_records.add(record)
    
    # 遍历唯一记录进行处理
    for record in unique_records:
        process_record(record)  # 自定义处理函数
    
    print(f"处理完成！共 {len(unique_records)} 条唯一记录")

# 模拟处理10GB日志文件（内存高效）
process_large_data("server_logs.txt")

# ❌ 错误示范：不要这样做！
s = {1, 2, 3}
i = 0
while i < len(s):
    print(s[i])  # 报错：set不可索引！
    i += 1

# ⚠️ 低效且不推荐
temp_list = list(s)
i = 0
while i < len(temp_list):
    print(temp_list[i])
    i += 1

s = {(1, 2), (3, 4)}
for t in s:
    t[0] = 99  # ❌ 元组不可变，报错TypeError

s = {1, 2, 3}
size = len(s)  # 先记录
for x in s:
    print(f"处理 {x} (总元素: {size})")