python集合(set)

最新推荐文章于 2025-06-13 02:50:00 发布

木子林_

最新推荐文章于 2025-06-13 02:50:00 发布

阅读量1.4k

点赞数

CC 4.0 BY-SA版权

分类专栏： python 文章标签： python

本文链接：https://blog.youkuaiyun.com/lin_keys/article/details/114878566

python 专栏收录该内容

27 篇文章

订阅专栏

本文深入探讨Python中的集合数据类型，涵盖其定义、创建方法、元素访问与操作，以及与其他数据结构如字典的区别。同时，通过具体示例展示了集合在实际应用中的高效性能。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

前言

我们前面深入了解了字典 ,列表和元组,对这三个数据类型有了认识，今天我们了解下另外一种数据类型：集合。集合用来保存不重复的元素，即集合中的元素都是唯一的，元素只能是不可变的数据类型（包括整形、浮点型、字符串、元组），无法存储可变的数据类型（列表、字典、集合）。

集合

定义概念

集合是一个无序集合，没有重复元素。基本用途包括成员测试和消除重复的条目。集合对象还支持数学运算，如并集、交集、差集和对等差分

创建集合

1-使用 {} 创建

set_name = {1, 1.2, "字符串", (1,2)}
print("set_name:", set_name)

# 输出
# set_name: {'字符串', 1, (1, 2), 1.2}

2- set()函数创建集合

set_name1 = set("帅气的读者")
set_name2 = set([1, 2])
set_name3 = set((1, 2))
print("set_name1:", set_name1)
print("set_name2:", set_name2)
print("set_name3:", set_name3)

# 输出结果
# set_name1: {'读', '者', '的', '气', '帅'}
# set_name2: {1, 2}
# set_name3: {1, 2}

访问元素

set_name = set("帅气的读者")
for index, item in enumerate(set_name):
    print(index, item)

# 返回结果
# 0 气
# 1 读
# 2 者
# 3 的
# 4 帅

从上面的返回结果可以看出，集合是无序的

删除元素

remove

set_name = set("帅气的读者")
set_name.remove("的")
for index, item in enumerate(set_name):
    print(index, item)
set_name.remove("的")

# 返回结果
# 0 帅
# 1 气
# 2 者
# 3 读
# Traceback (most recent call last):
# File "/Users/linjian/MonitorCenter/MonitorCenter/apps/t6.py", line 5, in <module>
#    set_name.remove("的")
# KeyError: '的'

删除集合中元素，需要注意的是，如果被删除元素本就不包含在集合中，则此方法会抛出 KeyError 错误

discard

set_name = set("帅气的读者")
set_name.remove("的")
for index, item in enumerate(set_name):
    print(index, item)
set_name.discard("的")

# 返回结果
# 0 读
# 1 帅
# 2 者
# 3 气

和 remove() 方法的用法完全相同，唯一的区别就是，当删除集合中元素失败时，此方法不会抛出任何错误。

clear：清空 set1 集合中所有元素

set_name = set("帅气的读者")
set_name.clear()
print("set_name:", set_name)

# 返回结果
# set_name: set()

pop: 随机删除元素

set_name = set("帅气的读者")
set_name.pop()
print("set_name:", set_name)

# 返回结果
# set_name: {'者', '帅', '气', '读'}

添加元素

add

set_name = set("帅气的读者")
set_name.add("们")
for index, item in enumerate(set_name):
    print(index, item)

# 返回结果
# 0 气
# 1 帅
# 2 们
# 3 的
# 4 者
# 5 读

add() 方法添加的元素，只能是数字、字符串、元组或者布尔类型（True 和 False）值，不能添加列表、字典、集合这类可变的数据，否则报错

update

set_name = set("帅气的读者")
set_name.update("1")
for index, item in enumerate(set_name):
    print(index, item)


# 返回结果
# 0 帅
# 1 者
# 2 读
# 3 1
# 4 的
# 5 气

其他方法

copy: 拷贝一个集合(浅拷贝)

set_name = set("帅气的读者")
set_copy = set_name.copy()
print("set_name:", set_copy)

# 返回结果
# set_name: {'读', '气', '帅', '者', '的'}

difference: 返回集合的差集，即返回的集合元素包含在第一个集合中，但不包含在第二个集合(方法的参数)中

set_a = {"python", "java", "go"}
set_b = {"duck", "fish", "python"}

print(set_a.difference(set_b))
print(set_a - set_b)

# 返回结果
# {'go', 'java'}
# {'go', 'java'}

difference_update: 移除两个集合中都存在的元素

set_a = {"python", "java", "go"}
set_b = {"duck", "fish", "python"}

set_a.difference_update(set_b)
print("set_a:", set_a)

# 返回结果
# set_a: {'go', 'java'}

intersection: 返回两个或更多集合中都包含的元素，即交集

set_a = {"python", "java", "go"}
set_b = {"duck", "fish", "python"}

print(set_a.intersection(set_b))
print(set_a & set_b)

# 返回结果
# {'python'}
# {'python'}

intersection_update：获取两个或更多集合中都重叠的元素，即计算交集

set_a = {"python", "java", "go"}
set_b = {"duck", "fish", "python"}

set_a.intersection_update(set_b)
print("set_a:", set_a)

# 返回结果
# set_a: {'python'}

isdisjoint ：判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。

set_a = {"python", "java", "go"}
set_b = {"duck", "fish", "python"}

print(set_a.isdisjoint(set_b))

# 返回结果
# False

issubset 判断集合的所有元素是否都包含在指定集合中，如果是则返回 True，否则返回 False

set_a = {"python", "java", "go"}
set_b = {"duck", "fish", "python"}

print(set_a.issubset(set_b))

# 返回结果
# False

issuperset 判断指定集合的所有元素是否都包含在原始的集合中，如果是则返回 True，否则返回 False

set_a = {"python", "java", "go"}
set_b = {"duck", "fish", "python"}

print(set_a.issuperset(set_b))

# 返回结果
# False

symmetric_difference：返回两个集合中不重复的元素集合，即会移除两个集合中都存在的元素

set_a = {"python", "java", "go"}
set_b = {"duck", "fish", "python"}

print(set_a.issuperset(set_b))
print(set_a ^ set_b)

# 返回结果
# {'go', 'java', 'duck', 'fish'}
# {'go', 'java', 'duck', 'fish'}

symmetric_difference_update：移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。

set_a = {"python", "java", "go"}
set_b = {"duck", "fish", "python"}

set_a.symmetric_difference_update(set_b)
print(set_a)


# 返回结果
#{'go', 'fish', 'java', 'duck'}

union: 返回两个集合的并集，即包含了所有集合的元素，重复的元素只会出现一次。

set_a = {"python", "java", "go"}
set_b = {"duck", "fish", "python"}

print(set_a.union(set_b))


# 返回结果
# {'python', 'java', 'duck', 'go', 'fish'}

集合和字典的区别

python字典和集合都是有哈希表实现的，两者区别就在于，对于字典而言，这张表存储了哈希值（hash）、键和值这 3 个元素，而对集合来说，哈希表内只存储单一的元素。具体的实现原理可以查看详解python-----字典。

集合和字典的性能测试

首先这个测试来源于网上，我觉得还不错就分享过来

# 统计时间需要用到 time 模块中的函数，了解即可
import time


def find_unique_price_using_list(products):
    unique_price_list = []
    for _, price in products:  # A
        if price not in unique_price_list:  # B
            unique_price_list.append(price)
    return len(unique_price_list)


id = [x for x in range(0, 100000)]
price = [x for x in range(200000, 300000)]
products = list(zip(id, price))

# 计算列表版本的时间
start_using_list = time.perf_counter()
find_unique_price_using_list(products)
end_using_list = time.perf_counter()
print("time elapse using list: {}".format(end_using_list - start_using_list))


# 使用集合完成同样的工作
def find_unique_price_using_set(products):
    unique_price_set = set()
    for _, price in products:
        unique_price_set.add(price)
    return len(unique_price_set)


# 计算集合版本的时间
start_using_set = time.perf_counter()
find_unique_price_using_set(products)
end_using_set = time.perf_counter()
print("time elapse using set: {}".format(end_using_set - start_using_set))

返回结果

time elapse using list: 43.95403001100203
time elapse using set: 0.009717649998492561

可以发现，仅仅十万的数据量，两者的速度差异就如此之大，大家想想如果数据量在大一点呢？

学习链接

python中的字典和集合

set是如何实现的

list和set的区别