国外订房网站怎么和做四川城乡建设厅官方网站

Python 集合操作大全：从入门到精通，新手学习避坑指南

---

对话实录

小白：（崩溃）我写了s = {1,2}，为什么s[0]会报错？

专家：（推眼镜）集合是无序的，不支持索引访问！想访问元素？先转列表！

---

集合基础三连击

1. 创建与基础操作

# ✅ 标准创建
empty = set() # 创建一个空集合，注意不能用{}，因为这会创建一个空字典。
#集合是一个无序且不包含重复元素的数据结构，空集合的创建需要使用set()函数。nums = {1, 2, 3} # 创建一个包含整数1、2、3的集合。#  迷惑操作
wrong = {} # ❌ Python中，{}默认创建的是字典，而不是集合。
wrong = {1, 2, } # ✅ 合法但不推荐这种尾随逗号的写法，虽然语法上没问题，但不常见且不直观。# 添加/删除
nums.add(4) # 向集合nums中添加元素4，操作后nums变为{1,2,3,4}。#add()方法用于向集合中添加一个元素，如果元素已存在，集合不会发生变化。nums.update([4,5],[5,6]) #update方法添加多个可迭代对象的元素nums.remove(1) # 从集合nums中移除元素1，操作后nums变为{2,3,4}。#remove()方法用于从集合中移除指定元素，如果元素不存在，会引发KeyError异常。nums.discard(5) # 尝试从集合nums中移除元素5，若元素不存在也不会报错，操作后nums仍为{2,3,4}。
#discard()方法与remove()类似，但当指定元素不存在时，discard()不会引发异常。nums.pop()   #随机移除集合中的元素nums.clear()  #移除所有元素，清空集合

专家提醒：集合元素必须可哈希！这意味着元素只能是不可变数据类型，如数字、字符串、元组、冻结集合等，可变对象（如列表、字典）不能作为集合元素。可哈希性保证了集合能够高效地进行元素的存储和查找，因为集合内部通过哈希值来确定元素的位置。

2. 集合运算

a = {1,2,3}  
b = {3,4,5}
# 并集
print(a | b) # 计算集合a和b的并集，结果为{1,2,3,4,5}，即包含a和b中所有不重复的元素。
# 交集
print(a & b) # 计算集合a和b的交集，结果为{3}，即a和b中共同拥有的元素。
# 差集
print(a - b) # 计算集合a相对于b的差集，结果为{1,2}，即a中存在但b中不存在的元素。差集操作从第一个集合中去除与第二个集合相同的元素。
# 对称差集
print(a ^ b) # 计算集合a和b的对称差集，结果为{1,2,4,5}，即只在a或b中出现，不同时在两个集合中出现的元素。对称差集操作是将两个集合中不共有的元素合并在一起。

集合像泡泡，运算像泡泡合并、分离。并集是将两个泡泡的内容合并在一起；交集是找出两个泡泡重叠的部分；差集是从一个泡泡中去除与另一个泡泡重叠的部分；对称差集是去除两个泡泡重叠部分后，剩下的所有部分。

常用功能火力全开

1. 集合推导式

集合推导式是一种简洁的语法，它允许我们通过一个表达式和一个循环来创建集合，相比传统的循环添加方式，代码更加简洁和易读。

# 传统写法
squares = set()
for x in range(5):squares.add(x**2)# 推导式写法
squares = {x**2 for x in range(5)} # 使用集合推导式，更简洁地创建一个包含0到4的平方的集合，
#结果为{0,1,4,9,16}。# 带条件筛选
even_squares = {x**2 for x in range(10) if x%2==0} # 筛选出0到9中偶数的平方，结果为{0, 4, 16, 36, 64}。#在集合推导式中，可以通过if语句添加条件，只将满足条件的元素添加到集合中。

2. 集合方法三剑客

s = {1,2,3}  
# 检查子集print(s.issubset({1,2,3,4})) # 检查集合s是否是{1,2,3,4}的子集，因为s中的所有元素都在{1,2,3,4}中，所以返回True。#issubset()方法用于判断一个集合是否是另一个集合的子集，即该集合的所有元素是否都包含在另一个集合中。# 检查超集print(s.issuperset({1,2})) # 检查集合s是否是{1,2}的超集，由于s包含了{1,2}中的所有元素，所以返回True。#issuperset()方法用于判断一个集合是否是另一个集合的超集，即该集合是否包含另一个集合的所有元素。# 检查交集print(s.isdisjoint({4,5})) # 检查集合s与{4,5}是否没有交集，因为s和{4,5}没有共同元素，所以返回True。#isdisjoint()方法用于判断两个集合是否没有交集，即两个集合中是否没有共同的元素。

3. 冻结集合（frozenset）

# 创建
fs = frozenset([1,2,3]) # 创建一个冻结集合，其元素不可变，类似元组之于列表。frozenset()函数用于创建一个不可变的集合，一旦创建，其元素不能被修改、添加或删除。# 特性
fs.add(4) # ❌ 尝试向冻结集合fs中添加元素4，会报错，因为冻结集合不可变。由于冻结集合的不可变性，任何试图修改其元素的操作（如add()、remove()等）都会引发异常。
d = {fs: "value"} # ✅ 由于冻结集合不可变，所以可哈希，能作为字典的键。因为冻结集合的元素不可变，其哈希值在创建后不会改变，满足字典键可哈希的要求，所以可以作为字典的键。

新增实用案例展示

案例一：数据分析之去除重复数据

在数据分析中，经常会遇到需要处理大量重复数据的情况。例如，有一份销售数据列表，其中包含了重复的订单编号。

sales_data = [101, 102, 101, 103, 102, 104]
unique_sales = list(set(sales_data))
print(unique_sales)
# 输出: [104, 101, 102, 103]

这里通过将销售数据列表转换为集合，利用集合自动去重的特性，快速得到了不重复的订单编号，再转换回列表方便后续处理。

但是大家可以看到上面的处理有个问题，去重后元素的顺序变了，那是因为集合是无序的。如果想让去重后顺序与原来一致，大家可以使用另一种方式：

我们可以通过有序字典
collections.OrderedDict.fromkeys()功能，对列表去重并保持有序

from collections import OrderedDict
sales_data = list(OrderedDict.fromkeys(sales_data))
print(sales_data)
#结果：[101, 102, 103, 104]

案例二：文本处理之提取关键词

假设我们有一段文本，需要提取其中出现的所有不同的单词作为关键词。

text = "Python is a powerful language. Python is easy to learn."
words = text.lower().split()
unique_words = set(words)
print(unique_words)# 输出: {'a', 'easy', 'is', 'language', 'learn', 'powerful', 'Python', 'to'}

首先将文本转换为小写并按空格分割成单词列表，然后使用集合去重，得到了文本中的所有关键词，方便进行文本分析、信息检索等操作。

案例三：数据比对之找出差异

假设有两个数据集，分别存储了不同时间段内用户购买的商品 ID，需要找出在第一个时间段购买但在第二个时间段未购买的商品 ID。

first_period_purchases = {10, 20, 30, 40}
second_period_purchases = {20, 30, 50}
diff_purchases = first_period_purchases - second_period_purchases
print(diff_purchases)# 输出: {10, 40}

通过集合的差集运算，轻松找出了两个时间段购买行为的差异，为进一步分析用户购买习惯的变化提供了数据支持。

高阶操作

1. 集合与字典的完美结合

# 统计频率
words = ["a", "b", "a", "c", "b", "a"]
freq = {word: words.count(word) for word in set(words)}
# 先将单词列表转换为集合去重，再统计每个单词在原列表中的出现次数，结果为{'a':3, 'b':2, 'c':1}。# 集合运算应用
valid_users = {"Alice", "Bob"}
active_users = {"Bob", "Cathy"}
inactive_users = valid_users - active_users
# 通过集合差集运算，找出有效用户中未活跃的用户，结果为{'Alice'}。

2. 集合与生成器的完美结合

# 生成器表达式（处理海量数据）
big_data = (x for x in range(1000000))
unique_nums = set(big_data) 
# 使用生成器表达式生成大量数据，再转换为集合去重，避免一次性将大量数据加载到内存。# 内存对比测试（集合省内存！）
import sys
print(sys.getsizeof(list(range(1000000)))) # 输出创建包含一百万个整数的列表所需的内存大小，约8448728字节。列表会将所有元素存储在内存中，随着元素数量增加，内存占用快速增长。
print(sys.getsizeof(set(range(1000000)))) # 输出创建包含一百万个整数的集合所需的内存大小，约4194504字节，可见集合在存储大量不重复数据时更省内存。集合在存储元素时，通过哈希值来组织数据，对于不重复数据，其内存使用效率更高。

闭坑指南（血泪总结）

可变对象陷阱：

s = {[1,2]}  # ❌ 列表是可变对象，不能作为集合元素，会报错。
s = {frozenset([1,2])} # ✅ 冻结集合是不可变的，可以作为集合元素。冻结集合一旦创建，其内容不可更改，哈希值固定，符合集合元素的条件。

无序性陷阱：

s = {1,2,3}  
print(list(s))
# 集合是无序的，将集合转换为列表时，元素顺序不确定，可能是[1,2,3]，也可能是[2,3,1]等其他顺序。
#在需要保证元素顺序的场景中，不能直接依赖集合，若要顺序处理集合元素，可先转换为有序的数据结构，如列表并自行排序。

性能误区：

# 创建百万级数据测试

%timeit [i for i in range(1000000)] 

# 测试创建包含一百万个元素的列表所需时间，约50ms。列表的创建过程相对简单，直接按顺序将元素添加到内存中。

%timeit set(i for i in range(1000000)) 

# 测试创建包含一百万个元素的集合所需时间，约100ms。集合创建时需要计算每个元素的哈希值，并进行冲突处理等操作，所以时间开销更大。

# 结论：集合创建更慢！优势在去重和查找 虽然集合创建时间比列表长，但在去重和查找元素时，集合具有更高的效率。集合利用哈希表实现，查找元素的时间复杂度接近O(1)，而列表查找元素的时间复杂度为O(n)，在数据量较大时，集合在去重和查找方面的优势明显。