Python基础指南之集合set的创建与自动去重详解

ip_list = ['192.168.1.1', '10.0.0.5', '192.168.1.1', '172.16.0.3', '10.0.0.5']
unique_ips = set(ip_list)
print(unique_ips)  # {'192.168.1.1', '10.0.0.5', '172.16.0.3'}
print(f'独立IP数量: {len(unique_ips)}')  # 3

# 集合的三个核心特征
# 1. 元素唯一（自动去重）
s = {1, 2, 2, 3, 3, 3}
print(s)  # {1, 2, 3}——重复的2和3被自动去掉了

# 2. 无序——元素的存储顺序和插入顺序无关
s = {3, 1, 4, 1, 5, 9, 2, 6}
print(s)  # 输出顺序通常不是你插入的顺序

# 3. 可变——可以添加和删除元素（但元素本身必须是不可变的）
s = {1, 2, 3}
s.add(4)      # ✅ 可以添加
s.remove(1)   # ✅ 可以删除
print(s)      # {2, 3, 4}

# ✅ 这些可以放进集合——都是不可变类型
valid_set = {1, 3.14, 'hello', (1, 2), True, None, frozenset([1, 2])}
print(valid_set)

# ❌ 这些不能放进集合——是可变类型
# {[1, 2]}      # TypeError: unhashable type: 'list'
# {{'a': 1}}    # TypeError: unhashable type: 'dict'
# {{1, 2}}      # TypeError: unhashable type: 'set'（除非用frozenset）

# 最基本的方式——用花括号
fruits = {'apple', 'banana', 'orange'}
print(fruits)  # {'banana', 'orange', 'apple'}
print(type(fruits))  # <class 'set'>

# 空集合——⚠️ 必须用set()，因为{}是空字典！
empty_set = set()
print(type(empty_set))  # <class 'set'>

empty_dict = {}
print(type(empty_dict))  # <class 'dict'>——注意区别！

# 集合中的元素自动去重
numbers = {1, 2, 2, 3, 3, 3, 4, 4, 4, 4}
print(numbers)  # {1, 2, 3, 4}
print(len(numbers))  # 4（不是10）

# set()接受任何可迭代对象

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

# 从元组创建
s2 = set((10, 20, 30, 20))
print(s2)  # {10, 20, 30}

# 从字符串创建——每个字符成为一个元素
s3 = set('hello world')
print(s3)  # {'h', 'e', 'l', 'o', ' ', 'w', 'r', 'd'}
# 注意：两个'l'和两个'o'各只保留一个

# 从range对象创建
s4 = set(range(10))
print(s4)  # {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

# 从字典创建（取键）
s5 = set({'a': 1, 'b': 2, 'c': 3})
print(s5)  # {'a', 'b', 'c'}

# 从生成器表达式创建
s6 = set(x ** 2 for x in range(5))
print(s6)  # {0, 1, 4, 9, 16}

# 从文件对象创建（每行一个元素）
# with open('file.txt') as f:
#     lines = set(f)  # 自动去重的行集合

# 混合类型集合
mixed = {42, 'hello', 3.14, True, None, (1, 2)}
print(mixed)  # {False, 3.14, 'hello', 42, None, (1, 2)}

# ⚠️ 注意：True在集合中等于1，False等于0
# 因为bool是int的子类，True==1, False==0
numbers_with_bool = {1, True, 2, False, 0, 3}
print(numbers_with_bool)  # {0, 1, 2, 3}——True和1合并了，False和0合并了

# 验证
print(True == 1)   # True
print(False == 0)  # True
print({1, True})   # {1}——因为是同一个值
print({0, False})  # {0}——同理

# 去重流程：
# 1. 计算新元素的哈希值 hash(element)
# 2. 找到哈希表中对应位置
# 3. 如果该位置已有元素，用 == 比较
# 4. 如果相等，则不插入（去重）
# 5. 如果不等（哈希冲突），用开放地址法探测下一个位置

# 演示：自定义类的去重行为
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def __hash__(self):
        """定义哈希值——基于name"""
        return hash(self.name)
    
    def __eq__(self, other):
        """定义相等性——基于name和age"""
        if not isinstance(other, Person):
            return False
        return self.name == other.name and self.age == other.age
    
    def __repr__(self):
        return f'Person({self.name}, {self.age})'


# 哈希相同但==不相等 → 两个元素都保留（哈希冲突）
p1 = Person('Alice', 25)  # hash基于'Alice'
p2 = Person('Alice', 30)  # hash还是基于'Alice'，但age不同
s = {p1, p2}
print(s)  # {Person(Alice, 25), Person(Alice, 30)}——两个都保留

# 哈希相同且==相等 → 去重
p3 = Person('Alice', 25)  # 和p1一模一样
p4 = Person('Alice', 25)  # 也和p1一模一样
s2 = {p1, p3, p4}
print(s2)  # {Person(Alice, 25)}——只有一个

# 整数——按数值去重
s = {1, 2, 3, 1, 2}
print(s)  # {1, 2, 3}

# 浮点数——按数值去重
s = {1.0, 2.0, 1.0, 3.0}
print(s)  # {1.0, 2.0, 3.0}

# ⚠️ 注意：1和1.0在集合中是一样的！
s = {1, 1.0, 2, 3}
print(s)  # {1, 2, 3}——1和1.0被视为相同
print(1 == 1.0)  # True
print(hash(1))   # 1
print(hash(1.0)) # 1——相同的哈希值！

# 字符串——按内容去重
s = {'hello', 'world', 'hello', 'HELLO'}
print(s)  # {'hello', 'world', 'HELLO'}——'hello'被去重，'HELLO'不同

# 元组——按内容去重
s = {(1, 2), (3, 4), (1, 2), (2, 1)}
print(s)  # {(1, 2), (3, 4), (2, 1)}——(1,2)去重，(2,1)是不同元组

# None——只有一个None
s = {None, None, None}
print(s)  # {None}

import time
import random

# 生成10万个有重复的整数
data = [random.randint(1, 10000) for _ in range(100000)]

# 方法一：手动去重（用列表 + in 检查）
start = time.perf_counter()
unique_list = []
for x in data:
    if x not in unique_list:  # O(n)每次
        unique_list.append(x)
print(f'手动去重: {time.perf_counter() - start:.4f}s，结果数量: {len(unique_list)}')

# 方法二：用集合去重
start = time.perf_counter()
unique_set = set(data)  # O(1)每次，总共O(n)
print(f'集合去重: {time.perf_counter() - start:.4f}s，结果数量: {len(unique_set)}')

# 性能差异通常有数百倍到数千倍！

s = {1, 2, 3}

# add()——添加单个元素
s.add(4)
print(s)  # {1, 2, 3, 4}

# 添加重复元素——静默忽略，不报错
s.add(4)
print(s)  # {1, 2, 3, 4}——还是原来的样子

# update()——批量添加（从可迭代对象）
s.update([5, 6, 7])
print(s)  # {1, 2, 3, 4, 5, 6, 7}

s.update({8, 9}, (10, 11))
print(s)  # {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}

# update也可以接受字符串（逐个字符添加）
s2 = set()
s2.update('abc')
print(s2)  # {'a', 'b', 'c'}

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

# remove()——删除指定元素，不存在则报错
s.remove(3)
print(s)  # {1, 2, 4, 5}
# s.remove(99)  # KeyError: 99

# discard()——删除指定元素，不存在也不报错
s.discard(4)
print(s)  # {1, 2, 5}
s.discard(99)  # 不报错

# pop()——随机删除并返回一个元素
# ⚠️ 注意：集合无序，pop()删除的是"任意"一个元素
popped = s.pop()
print(f'弹出: {popped}, 剩余: {s}')

# clear()——清空集合
s.clear()
print(s)  # set()

# 集合最大的性能优势：成员检测是O(1)
# 列表的成员检测是O(n)，集合是O(1)

s = set(range(100000))

import time

# 集合查找
start = time.perf_counter()
for _ in range(1000):
    _ = 99999 in s
print(f'集合in: {time.perf_counter() - start:.6f}s')

# 列表查找（对比）
lst = list(range(100000))
start = time.perf_counter()
for _ in range(1000):
    _ = 99999 in lst
print(f'列表in: {time.perf_counter() - start:.6f}s')

# 实际示例：快速过滤
all_users = {'alice', 'bob', 'charlie', 'david', 'eve', 'frank', 'grace'}
vip_users = {'alice', 'charlie', 'grace'}

# 检查是否是VIP——O(1)
print('alice' in vip_users)    # True
print('bob' in vip_users)      # False

# 检查是否有访问权限
def has_access(username):
    return username in all_users

print(has_access('hacker'))  # False

s = {'apple', 'banana', 'orange', 'grape', 'mango'}

# for循环遍历——顺序不保证！
print('遍历集合:')
for fruit in s:
    print(f'  {fruit}', end='')
print()

# 排序后遍历
print('排序后遍历:')
for fruit in sorted(s):
    print(f'  {fruit}', end='')
print()

# 按长度排序遍历
print('按长度排序:')
for fruit in sorted(s, key=len):
    print(f'  {fruit}({len(fruit)})', end='')
print()

# enumerate遍历（带序号）
print('带序号遍历:')
for i, fruit in enumerate(s, 1):
    print(f'  {i}. {fruit}')

# ⚠️ 遍历时不能修改集合！
# for item in s:
#     s.add('new')  # RuntimeError: Set changed size during iteration

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

# len()——元素个数
print(len(s))  # 5

# max() / min()——最大/最小元素
print(max(s))  # 5
print(min(s))  # 1

# sum()——求和
print(sum(s))  # 15

# any() / all()
print(any({0, False, 1}))  # True（至少有一个为真）
print(all({1, True, 2}))   # True（全部为真）
print(all({0, 1, 2}))      # False（0为假）

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

# 判断子集
print(a.issubset(b))      # True——a是b的子集
print(a <= b)             # True——运算符写法
print(a < b)              # True——真子集（a⊂b，不等于b）

# 判断超集
print(b.issuperset(a))    # True——b是a的超集
print(b >= a)             # True——运算符写法
print(b > a)              # True——真超集

# 判断相等（内容相同）
print(a == c)             # True
print(a == b)             # False

# 判断不相交
d = {4, 5, 6}
print(a.isdisjoint(d))    # True——没有公共元素
print(a.isdisjoint(b))    # False——有公共元素(1,2,3)

# 场景：从用户行为日志中提取不同的操作类型
log_entries = [
    'LOGIN - alice',
    'LOGOUT - alice',
    'LOGIN - bob',
    'PURCHASE - alice',
    'LOGIN - alice',      # 重复操作
    'VIEW_PAGE - charlie',
    'LOGIN - bob',         # 重复操作
    'PURCHASE - bob',
    'VIEW_PAGE - alice',
    'LOGOUT - bob',
]

# 提取所有不同的操作类型
action_types = {entry.split(' - ')[0] for entry in log_entries}
print(f'操作类型: {action_types}')
# {'LOGIN', 'LOGOUT', 'PURCHASE', 'VIEW_PAGE'}

# 提取所有不同的用户
users = {entry.split(' - ')[1] for entry in log_entries}
print(f'活跃用户: {users}')
# {'alice', 'bob', 'charlie'}

# 场景：API接口的IP黑白名单
class IPFilter:
    """IP黑白名单过滤器——用集合实现O(1)查找"""
    
    def __init__(self):
        self._whitelist = set()  # 白名单（优先）
        self._blacklist = set()  # 黑名单
    
    def add_whitelist(self, ip):
        self._whitelist.add(ip)
    
    def add_blacklist(self, ip):
        self._blacklist.add(ip)
    
    def remove_whitelist(self, ip):
        self._whitelist.discard(ip)
    
    def remove_blacklist(self, ip):
        self._blacklist.discard(ip)
    
    def is_allowed(self, ip):
        """判断IP是否允许访问"""
        # 白名单优先——白名单中的IP即使同时在黑名单中也允许
        if ip in self._whitelist:
            return True
        # 在黑名单中
        if ip in self._blacklist:
            return False
        # 都不在——默认允许
        return True
    
    def load_from_file(self, filename, list_type):
        """从文件加载IP列表"""
        target = self._whitelist if list_type == 'whitelist' else self._blacklist
        with open(filename) as f:
            for line in f:
                ip = line.strip()
                if ip:
                    target.add(ip)
        print(f'已加载 {len(target)} 个IP到{list_type}')


# 使用示例
ip_filter = IPFilter()
ip_filter.add_blacklist('10.0.0.99')
ip_filter.add_blacklist('192.168.1.100')
ip_filter.add_whitelist('10.0.0.1')  # 管理员IP，始终允许

# 检查
print(ip_filter.is_allowed('10.0.0.99'))     # False——黑名单
print(ip_filter.is_allowed('10.0.0.1'))      # True——白名单优先
print(ip_filter.is_allowed('172.16.0.5'))    # True——不在任何名单中

# 场景：分析两篇文章的词汇差异
article1 = """
Machine learning is a subset of artificial intelligence that enables
systems to learn and improve from experience without being explicitly
programmed machine learning focuses on the development of computer
programs that can access data and use it to learn for themselves
"""

article2 = """
Deep learning is a subset of machine learning in artificial intelligence
that has networks capable of learning unsupervised from data that is
unstructured or unlabeled deep learning is also known as deep neural
network learning
"""

# 提取单词集合
def extract_words(text):
    return {word.strip('.,;:!?()[]{}\'"').lower() for word in text.split() if len(word) > 1}

words1 = extract_words(article1)
words2 = extract_words(article2)

print(f'文章1不同单词数: {len(words1)}')
print(f'文章2不同单词数: {len(words2)}')

# 文章1独有的单词
only_in_1 = words1 - words2
print(f'\n文章1独有的词 ({len(only_in_1)}个): {only_in_1}')

# 文章2独有的单词
only_in_2 = words2 - words1
print(f'文章2独有的词 ({len(only_in_2)}个): {only_in_2}')

# 两篇文章共有的单词
common = words1 & words2
print(f'两篇共有的词 ({len(common)}个): {common}')

# 所有出现过的单词
all_words = words1 | words2
print(f'总词汇量: {len(all_words)}')

# 场景：统计一个论坛帖子里有多少不同的参与者
# 包括发帖人和所有回复人

posts = [
    {'author': 'alice', 'replies': ['bob', 'charlie', 'bob']},
    {'author': 'bob', 'replies': ['alice', 'david']},
    {'author': 'charlie', 'replies': ['alice', 'eve', 'alice', 'david']},
    {'author': 'david', 'replies': ['eve']},
]

# 统计所有参与者（去重）
all_participants = set()
for post in posts:
    all_participants.add(post['author'])      # 发帖人
    all_participants.update(post['replies'])  # 回复人

print(f'参与者总数: {len(all_participants)}')
print(f'参与者名单: {all_participants}')

# 统计谁发了帖（有帖子但没回复？）
authors = {post['author'] for post in posts}
repliers = set()
for post in posts:
    repliers.update(post['replies'])

print(f'只发帖没回复的人: {authors - repliers}')
print(f'只回复没发帖的人: {repliers - authors}')
print(f'又发帖又回复的人: {authors & repliers}')

# 查看元素的哈希值
print(hash('hello'))   # 某个整数（每次运行可能不同）
print(hash(42))        # 42（整数的哈希就是自己）
print(hash((1, 2, 3))) # 某个整数

# 哈希表的工作流程：
# 1. 对元素x计算 hash(x)
# 2. 用 hash(x) % table_size 确定存储槽位
# 3. 如果槽位为空，直接存储
# 4. 如果槽位已被占用（哈希冲突），用开放地址法探测下一个位置
# 5. 如果发现相等的元素（__eq__返回True），则不插入（去重）

# 集合的无序不是"随机"，而是"按哈希值分布"
# 元素的存储位置由哈希值决定，不是插入顺序

s = set()
s.add(1)
s.add(2)
s.add(3)
print(s)  # 输出顺序通常看起来"有序"，是因为小整数的哈希就是自己

# 但对字符串就不一定了
s = {'banana', 'apple', 'cherry'}
print(s)  # 输出顺序不可预测

# ⚠️ 如果你需要保序的集合，可以：
# 1. 使用字典的键（Python 3.7+保序）
ordered_unique = dict.fromkeys([3, 1, 4, 1, 5, 9, 2, 6])
print(list(ordered_unique))  # [3, 1, 4, 5, 9, 2, 6]——保序去重

# 2. 使用sorted()排序输出
print(sorted(s))  # ['apple', 'banana', 'cherry']——字母序

import sys

# 集合有一定的内存开销（维护哈希表）
numbers = list(range(1000))
lst = numbers
s = set(numbers)

print(f'列表内存: {sys.getsizeof(lst)} 字节')
print(f'集合内存: {sys.getsizeof(s)} 字节')
# 集合通常占用更多内存——这是哈希表结构的代价
# 换取的是O(1)的查找和去重能力

# 实际内容的内存还包括元素本身
# sys.getsizeof只测量容器对象本身
# 如果需要精确测量，可以用更专业的工具

# ❌ 这不是空集合！
empty = {}
print(type(empty))  # <class 'dict'>——这是字典！

# ✅ 这才是空集合
empty_set = set()
print(type(empty_set))  # <class 'set'>

# 为什么？因为Python用{}初始化空字典的历史更早
# set字面量语法是后来添加的，必须避免歧义

# ❌ 列表不能放入集合
# s = {[1, 2, 3]}  # TypeError: unhashable type: 'list'

# ❌ 字典不能放入集合
# s = {{'a': 1}}   # TypeError: unhashable type: 'dict'

# ❌ 集合不能放入集合
# s = {{1, 2}}     # TypeError: unhashable type: 'set'

# ✅ 但可以用frozenset
s = {frozenset([1, 2]), frozenset([3, 4])}
print(s)  # {frozenset({1, 2}), frozenset({3, 4})}

# ❌ 包含可变元素的元组也不能放入集合
# s = {(1, [2, 3])}  # TypeError: unhashable type: 'list'
# 因为元组中的列表是可变的，导致整个元组不可哈希

# ✅ 纯不可变元素的元组可以
s = {(1, 2), (3, 4)}
print(s)  # {(1, 2), (3, 4)}

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

# ❌ 遍历时修改集合——会引发RuntimeError
# for x in s:
#     if x % 2 == 0:
#         s.remove(x)  # RuntimeError: Set changed size during iteration

# ✅ 正确方式一：遍历副本
for x in s.copy():
    if x % 2 == 0:
        s.remove(x)
print(s)  # {1, 3, 5}

# ✅ 正确方式二：用集合推导式创建新集合
s = {1, 2, 3, 4, 5}
s = {x for x in s if x % 2 != 0}
print(s)  # {1, 3, 5}

# ✅ 正确方式三：先收集要删除的，再统一删
s = {1, 2, 3, 4, 5}
to_remove = {x for x in s if x % 2 == 0}
s -= to_remove
print(s)  # {1, 3, 5}

s = {10, 20, 30, 40, 50}

# ❌ 集合不支持索引访问
# print(s[0])  # TypeError: 'set' object is not subscriptable

# ❌ 集合不支持切片
# print(s[1:3]) # TypeError

# 如果你需要"第n个元素"——先转为列表
# 但注意：转为列表后的顺序不确定！
lst = list(s)
print(lst[0])  # 可以访问，但不知道是哪个元素

# 如果需要有序集合，用sorted
for i, item in enumerate(sorted(s)):
    print(f'{i}: {item}')

# ⚠️ 在集合中，True==1，False==0
s = {1, True, 0, False}
print(s)  # {0, 1}——只有两个元素

# 含义：True和1在集合中被视为同一个值
# 同理False和0也被视为同一个值
# 这是因为 bool 是 int 的子类

# 验证
print(issubclass(bool, int))  # True
print(True == 1)              # True
print(False == 0)             # True
print(hash(True))             # 1
print(hash(1))                # 1
print(hash(False))            # 0
print(hash(0))                # 0

# 选型决策树
def choose_collection(requirements):
    """
    根据需求选择合适的集合类型
    """
    needs_order = requirements.get('order')      # 需要保持顺序
    needs_unique = requirements.get('unique')    # 需要唯一性
    needs_index = requirements.get('index')      # 需要按位置访问
    needs_search = requirements.get('search')    # 需要快速查找
    needs_modify = requirements.get('modify')    # 需要频繁修改
    
    if needs_unique and needs_search:
        if needs_order:
            return 'dict（Python 3.7+保序，键唯一，用作有序集合）'
        return 'set'  # 去重 + 快速查找
    elif needs_order and needs_index:
        return 'list'  # 保序 + 索引访问
    elif needs_unique and needs_order:
        return 'OrderedDict的键 或 dict.fromkeys()'
    else:
        return '根据具体情况选择'


# 示例
print(choose_collection({'unique': True, 'search': True}))
# set

print(choose_collection({'order': True, 'index': True}))
# list

print(choose_collection({'unique': True, 'order': True}))
# dict（Python 3.7+）