Skip to content

集合类型set和frozenset

概念

  • set 是一个无序且不重复的集合。适合用于存储唯一值。可变的。

  • frozenset是不可变的集合类型 。

  • 无序性：集合中的元素没有特定的顺序，每次访问集合时元素的顺序可能不同。

唯一性：集合中不会存在重复的元素，如果尝试添加已经存在的元素，集合不会发生变化。

可变性（仅针对 set）：set 类型的集合是可变的，可以动态地添加、删除元素；而 frozenset 是不可变的，一旦创建就不能修改。

  • 集合的应用场景

  • 去除重复元素：可以将列表或其他可迭代对象转换为集合，自动去除其中的重复元素。

  • 成员检测：由于集合的查找效率较高，适合用于快速判断某个元素是否存在。
  • 集合运算：在需要进行交集、并集、差集等运算时，集合是非常有用的数据结构。

集合的创建方式

# 1 花括号内以逗号分隔元素的方式
fruits = {
    "apple", "banana", "orange", "grape", "strawberry", "pineapple", "mango", "watermelon", "kiwi", "peach"
}

# 2.类型构造器
fruits_set = set()

# 3.集合推导式
set_deduce = {c for c in 'abracadabra' if c not in 'abc'}

set 和 frozenset 的实例提供的操作

# 1. len(s) 返回集合 s 中的元素数量（即 s 的基数）。
print(len(fruits))

# 2. x in s 检测 x 是否为 s 中的成员。
print('apple' in fruits)

# 3. x not in s 检测 x 是否非 s 中的成员。
print('cherry' not in fruits)


# 4.isdisjoint(other) 如果集合中没有与 other 共有的元素则返回 True。 当且仅当两个集合的交集为空集合时，两者为不相交集合。
print(fruits.isdisjoint(fruits_set))

# 5.issubset(other) 是 isdisjoint(other) 取反
print(fruits.issubset(fruits_set))

# set <= other 检测是否集合中的每个元素都在 other 之中。
print(fruits <= fruits_set)

# set < other 检测集合是否为 other 的真子集，即 set <= other and set != other。
print(fruits < fruits_set)


# 6.issuperset(other)
print(fruits.issuperset(fruits_set))

# set >= other 检测是否 other 中的每个元素都在集合之中。
print(fruits >= fruits_set)

# set > other 检测集合是否为 other 的真超集，即 set >= other and set != other。
print(fruits > fruits_set)


# 7. union(*others)
# set | other | ...
# 返回一个新集合，其中包含来自原集合以及 others 指定的所有集合中的元素。
print(fruits.union(fruits_set))


# 8. intersection(*others)
# set & other & ...
# 返回一个新集合，其中包含原集合以及 others 指定的所有集合中共有的元素。

# 9. difference(*others)
# set - other - ...
# 返回一个新集合，其中包含原集合中在 others 指定的其他集合中不存在的元素。

# 10. symmetric_difference(other)
# set ^ other
# 返回一个新集合，其中的元素或属于原集合或属于 other 指定的其他集合，但不能同时属于两者。

# 11.copy()
# 返回原集合的浅拷贝。

set的方法

# 1. add()  向集合中添加一个元素。如果元素已经存在于集合中，则不会有任何操作。
set1 = {1, 2, 3}
set1.add(4)
print(set1)
set1.add(1)
print(set1)

# 2. clear()  移除集合中的所有元素，使集合变为空集合。
set2 = {1, 2, 3, (1, 2, 3)}
print(set2)
set2.clear()
print(set2)

# 3. pop() 随机移除并返回集合中的一个元素。由于集合是无序的，无法预测会移除哪个元素。如果集合为空，会引发 `KeyError` 异常。
set3 = {5, 1, 2, 3, 4}
print(set3.pop())
print(set3)

# 4. remove() 移除集合中的指定元素。如果元素不存在，会引发 `KeyError` 异常。
set4 = {1, 2, 3, 7}
set4.remove(1)
print(set4)

# discard()  如果元素存在于集合中，则移除该元素。如果元素不存在，不会引发 `KeyError` 异常。
set4.discard(2)
set4.discard(1)
print(f'set4:{set4}')

# 5. update() 将其他给定集合中的所有元素添加到原集合中，去除重复元素，直接修改原集合。
set5 = {7, 8, 9}
set5.update(set4)
print(set5)

# 6. copy() 返回集合的浅拷贝。浅拷贝意味着新集合和原集合是不同的对象，但它们包含相同的元素。
print(id(set2))
print(set2.copy())
print(id(set2.copy()))

set6 = {1, 2, 3}
s_copy = set6.copy()
set6.clear()
print(s_copy)

# 7. union(*others)  返回一个新集合，该集合包含原集合和所有给定集合中的所有元素，去除重复元素。
set7 = {'1', '2', '3'}
print(set7.union(s_copy))

# 8. difference(*others)  返回一个新集合，该集合包含原集合中存在但在其他所有给定集合中不存在的元素。
set8 = {1, 2, 3}
set88 = {3, 4, 5}
print(set8.difference(set88))

# 9. difference_update(*others)  从原集合中移除所有在其他给定集合中也存在的元素，直接修改原集合。
set9 = {1, 2, 3}
set99 = {2, 3, 4}
set9.difference_update(set99)
print(set9)

# 10. symmetric_difference(other)  返回一个新集合，该集合包含原集合和另一个集合中不共同存在的元素。
set10 = {1, 2, 3}
set100 = {2, 3, 4}
print(set10.symmetric_difference(set100))

# 11. symmetric_difference_update(other)  将原集合更新为包含原集合和另一个集合中不共同存在的元素，直接修改原集合。
set11 = {1, 2, 3}
set111 = {2, 3, 4}
set11.symmetric_difference_update(set111)
print(set11)

# 12. intersection(*others)  返回一个新集合，该集合包含所有给定集合的交集元素。
set12 = {1, 2, 3}
set120 = {2, 3, 4}
print(set12.intersection(set120))

# 13. intersection_update(*others)  只保留原集合中同时也存在于其他所有给定集合中的元素，直接修改原集合。
set13 = {1, 2, 3}
set130 = {2, 3, 4}
set13.intersection_update(set130)
print(set13)

# 14. isdisjoint(other)  如果两个集合没有共同元素，则返回 `True`，否则返回 `False`
set14 = {1, 2, 3}
set140 = {2, 3, 4}
set1400 = {4, 5, 6}
print(set14.isdisjoint(set140))
print(set14.isdisjoint(set1400))

# 15. issubset(other)  如果原集合是另一个集合的子集（即原集合的所有元素都在另一个集合中），则返回 `True`，否则返回 `False`。
set15 = {2, 3, 4}
set150 = {1, 2, 3, 4, 5}
set1500 = {1, 4}
print(set15.issubset(set150))
print(set15.issubset(set1500))

# 16. issuperset(other)  如果原集合是另一个集合的超集（即另一个集合的所有元素都在原集合中），则返回 `True`，否则返回 `False`。
set16 = {1, 2, 3, 4, 5}
set160 = {1, 2, 3}
set1600 = {6}
print(set16.issuperset(set160))
print(set16.issuperset(set1600))


{1, 2, 3, 4}
{1, 2, 3, 4}
{1, 2, 3, (1, 2, 3)}
set()
1
{2, 3, 4, 5}
{2, 3, 7}
set4:{3, 7}
{3, 7, 8, 9}
1742515698624
set()
1742515697280
{1, 2, 3}
{'2', 1, 2, 3, '3', '1'}
{1, 2}
{1}
{1, 4}
{1, 4}
{2, 3}
{2, 3}
False
True
True
False
True
False

frozenset

['copy', 'difference', 'intersection', 'isdisjoint', 'issubset', 'issuperset', 'symmetric_difference', 'union']