【0015】Python数据类型-可变集合类型详解

于 2025-03-10 17:13:15 发布
阅读量923 收藏 14
点赞数 10
分类专栏： 【007】Python 文章标签： Python集合 Python可变集合 集合运算符 Python集合方法 集合 集合并集 集合对称差集
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/cxyzxc0325/article/details/146158422
版权

如果你觉得我的文章写的不错，请关注我哟，请点赞、评论，收藏此文章，谢谢！

本文内容体系结构如下：
在这里插入图片描述

集合是Python中一种非常有用的数据类型，它支持多种操作，如并集、交集、差集等，广泛应用于数据去重、元素查找等场景。通过本文的学习，你将掌握集合的基本概念、创建方法以及各种常用操作，为后续的Python编程打下坚实的基础。

一、什么是集合（Set）

Python集合是一种内置的数据结构，与数学中的集合概念一致，它以无序、不重复的方式存储元素。集合中的元素类型只能是不可变数据类型，如整型、浮点型、字符串、元组等，不能是列表、字典等可变数据类型。集合也不能嵌套使用。集合中的每个元素都是唯一的，这使得它成为去重和快速查找的理想选择。

Python中的集合分为可变集合（Set）和不可变集合（Frozenset），本文只介绍可变集合，下一篇文章将介绍不可变集合。我们约定说到集合时，默认表示说的是可变集合。

集合使用大括号{}或set()函数来创建，支持添加、删除元素等操作。由于其无序性，集合不支持索引访问，但提供了丰富的集合运算，如并集、交集、差集等，这些运算使得集合在处理多个数据集合时非常高效。Python集合是可变的，意味着你可以在创建后修改它，添加或删除元素。总之，集合是Python中一个强大且灵活的数据结构，广泛应用于各种数据处理场景。

{100,200,300,400} # 存储4个int类型数据的集合
{'Hello','Python','Good'} # 存储3个字符串类型数据的集合
{'hi',9.9,10,100, 200} # 存储4个不同类型数据的集合
{'Hello',100,10,'Python', (11,22,33)} # 存储包含元组的集合

二、创建集合

要创建一个集合，可以使用花括号 {} 将一系列元素包围起来，元素之间用英文逗号 , 分隔。或者使用set()函数创建集合。

2.1 使用 {} 直接创建集合

使用{}创建集合后，一般使用=将它赋值给某个变量。具体格式如下：

setname = [valu1 , value2 , ... , valuen]

其中，setname表示集合变量名，value1~ valuen 表示集合元素。

注意：

  • 在Python中，创建一个空集合不能直接使用大括号 {}，因为这会创建一个空字典。要创建一个空集合，你需要使用 set() 函数。
  • 集合中的元素只能是整型、浮点型、字符串、元组等，不能是列表、字典等可变数据类型。集合也不能嵌套使用，否则会报错。
  • 集合中的元素是不重复的，若创建的时候输入了重复的元素，则会自动只保留一个。

示例代码：

# 使用{}直接创建集合
# 创建1个空集合
result01 = {}
print(result01) # {}
# 可以看到，不包含元素的{}创建的是一个空字典，不是空集合，要创建空集合使用set()函数
print(type(result01)) # <class 'dict'>

# 创建1个包含1个int类型数据的集合
set02  = {10}
print(set02) # {10}
print(type(set02)) # <class 'set'>

# 创建1个包含2个字符串类型数据的集合
set03  = {"Hello","Python"}
print(set03) # {'Hello', 'Python'}
print(type(set03)) # <class 'set'>

# 创建1个包含4个不同类型数据的集合
set04 = {100,"Hi",12.5,True}
# 输出的顺序和存储的顺序不同，说明集合无序
print(set04) # {True, 'Hi', 100, 12.5}
print(type(set04)) # <class 'set'>

# 创建1个包含元组的集合
set05 = {(10,20,30),("abc","qwe"),100}
# 输出的顺序和存储的顺序不同，说明集合无序
print(set05) # {('abc', 'qwe'), 100, (10, 20, 30)}
print(type(set05)) # <class 'set'>

# 创建1个包含重复元素的集合
set06 = {10,20,30,40,50,10}
# 输出的结果中只有1个10，说明集合中的元素不重复，并且输出的顺序和存储的顺序不同，说明集合无序
print(set06) # {50, 20, 40, 10, 30}
print(type(set06)) # <class 'set'>

运行结果如下图所示：
在这里插入图片描述

创建包含列表、字典或者嵌套集合的代码，运行会报错

# 创建1个包含列表的集合
set01 = {[10,20,30],"abc","qwe"} # TypeError: unhashable type: 'list'
print(set01) 
print(type(set01))

在这里插入图片描述

# 创建1个包含字典的集合
set02 = {10,20,{"a":100,"b":200}} # TypeError: unhashable type: 'dict'
print(set02)
print(type(set02))

在这里插入图片描述

# 创建嵌套集合
set03 = {10,20,{30,40},{50,60}} # TypeError: unhashable type: 'set'
print(set03)
print(type(set03))

在这里插入图片描述

2.2 使用 set() 函数创建集合

Python 还提供了一个内置的函数 set()，使用它可以将其它数据类型转换为元组类型。例如：

# 使用set()函数创建集合
# 创建1个空集合
set01 = set()
print(set01) # set()
print(type(set01)) # <class 'set'>

# 将字符串转换成集合
set02 = set("hello")
# 从输出结果可知，字符串转换为集合，元素去重了并且无序
print(set02) # {'l', 'o', 'h', 'e'}
print(type(set02)) # <class 'set'>

# 将元组转换成集合
tuple01 = ('Python', 'Java', 'C++', 'JavaScript')
set03 = set(tuple01)
# 从输出结果可知，集合元素无序
print(set03) # {'C++', 'Java', 'Python', 'JavaScript'}
print(type(set03)) # <class 'set'>

# 将字典转换成集合，注意：是将字典的键存储在集合中。字典中的键具有唯一性
dict01 = {'a':100, 'b':42, 'c':9}
set04 = set(dict01)
# 从输出结果可知，集合元素无序
print(set04) # {'a', 'c', 'b'}
print(type(set04)) # <class 'set'>

# 将区间转换成集合
range01 = range(1, 6) #  range(1, 6)产生数字1,2,3,4,5
set05 = set(range01)
print(set05) # {1, 2, 3, 4, 5}
print(type(set05)) # <class 'set'>

# 将列表转换成集合
list01 = [10,20,30,40,50,10]
set06 = set(list01)
# 从输出结果可知，列表转换为集合，元素去重了并且无序
print(set06) # {40, 10, 50, 20, 30}
print(type(set06)) # <class 'set'>

运行结果如下图所示：
在这里插入图片描述


三、删除集合

当集合不再使用时，使用del命令删除整个集合。删除集合后，再次使用集合会报NameError错误。

set01 = {10,20,30,40,50}
print(set01) # {50, 20, 40, 10, 30}

del set01
print(set01) # NameError: name 'set01' is not defined

代码执行效果如下：
在这里插入图片描述


四、访问集合元素

在Python中，集合（set）是一种无序且不包含重复元素的数据结构。因此，你不能像访问列表（list）或元组（tuple）那样通过索引来获取集合中的某一个特定元素。不过，你可以使用一些方法来获取集合中的元素，例如通过迭代、随机选择等。

4.1 迭代集合

使用循环来遍历集合中的元素。

set01 = {1, 2, 3, 4, 5}
for element in set01:
    print(element)  # 逐个打印集合中的元素

运行结果如下图所示：
在这里插入图片描述

4.2 转换为列表并使用索引

将集合转换为列表，然后使用索引来访问元素。不过，这种方法并不推荐，因为它失去了集合无序且唯一的特性。

set01 = {10, 20, 30, 40, 50, 60, 70, 80, 90}
my_list = list(set01)
print(my_list[0])  # 访问转换为列表后的第一个元素（注意，这个元素不一定是最初插入的那个） 我这里第一次运行输出的是70，再次运行输出的可能就是其他元素

运行结果如下图所示：
在这里插入图片描述

每种方法都有其适用的场景，选择哪种方法取决于你的具体需求。


五、遍历集合元素

在Python中，集合（set）是一种无序且不重复的元素集合。要遍历一个集合，可以使用多种方法，包括使用for循环、列表推导式等。以下是一些常用的遍历集合的方法

5.1 使用 for 循环遍历集合

这是最直接和常用的方法。

set01 = {10, 20, 30, 40, 50, 60 ,70, 80, 90}

for element in set01:
    print(element,end=" ")

运行结果如下图所示：
在这里插入图片描述

5.2 使用enumerate()函数遍历集合

可以使用enumerate()函数和for循环遍历集合元素

set01 = {10, 20, 30, 40, 50, 60 ,70, 80, 90}

for index,value in enumerate(set01):
    print(f"第{index}个元素：{value}")

运行结果如下图所示：
在这里插入图片描述

5.3 使用列表推导式遍历集合

虽然列表推导式主要用于生成列表，但你也可以用它来遍历集合，并在遍历过程中将元素收集到一个列表中。

set01 = {10, 20, 30, 40, 50, 60 ,70, 80, 90}
# 将集合中的每个元素收集到一个列表中
squared_elements = [element for element in set01]
print(squared_elements)

运行结果如下图所示：
在这里插入图片描述


六、增加集合元素

在Python中，集合（set）是一种无序且不包含重复元素的数据结构。要向集合中添加元素，你可以使用add()方法或者update()方法。

6.1 使用 add() 方法增加元素

add() 方法用于向集合中添加单个不可变元素，例如Number类型数据、字符串和元组。如果元素已经存在于集合中，则操作不会有任何效果（集合中的元素是唯一的）。不能添加列表、集合和字典元素。

set01 = {10, 20, 30, 40, 50}
print(set01) # {50, 20, 40, 10, 30}
# 向集合中添加元素60
set01.add(60)
print(set01)  # {50, 20, 40, 10, 60, 30}

# 尝试添加已存在的元素
set01.add(30)  # 元素30已经存在，所以集合不会改变
print(set01)  # {50, 20, 40, 10, 60, 30}

# 向集合中添加一个字符串，字符串作为一个整体添加到集合中
set01.add("abc")
print(set01) # {50, 20, 'abc', 40, 10, 60, 30}

# 向集合中添加一个元组，元组作为一个整体添加到集合中
set01.add((100,200,300))
print(set01) # {50, 20, (100, 200, 300), 'abc', 40, 10, 60, 30}

运行结果如下图所示：
在这里插入图片描述

使用add()方法向集合中添加列表、集合、字典是不允许的，会报错。

向集合中添加列表代码：

set01 = {10, 20, 30, 40, 50}
print(set01) # {50, 20, 40, 10, 30}
# 向集合中添加列表
set01.add([100,200]) # TypeError: unhashable type: 'list'
print(set01)

运行结果如下图所示：
在这里插入图片描述

向集合中添加集合代码：

set01 = {10, 20, 30, 40, 50}
print(set01) # {50, 20, 40, 10, 30}
# 向集合中添加列表
set01.add({100,200}) # TypeError: unhashable type: 'set'
print(set01)

运行结果如下图所示：
在这里插入图片描述

向集合中添加字典代码：

set01 = {10, 20, 30, 40, 50}
print(set01) # {50, 20, 40, 10, 30}
# 向集合中添加列表
set01.add({"a":100,"b":200}) # TypeError: unhashable type: 'dict'
print(set01)

运行结果如下图所示：
在这里插入图片描述

6.2 使用 update() 方法增加元素

update() 方法用于向集合中添加一个或多个元素。你可以传递一个可迭代对象（如字符串、列表、元组、集合或字典的键等）给update()方法，它会将可迭代对象中的所有元素添加到集合中（如果它们尚不存在于集合中）。不可添加Number类型数据，会报错。

set01 = {10, 20, 30}
print(set01) # {10, 20, 30}
# 向集合中添加一个字符串,字符串会被拆分添加进集合，重复元素只添加一个
set01.update("abca")
print(set01) # {10, 'b', 'a', 'c', 20, 30}

# 向集合中添加一个列表，将列表中的元素一个一个添加进集合
set01.update([100,200,300])
print(set01) # {100, 200, 10, 'b', 300, 'a', 'c', 20, 30}

# 向集合中添加一个元组，将元组中的元素一个一个添加进集合
set01.update((400,500,600))
print(set01) # {100, 200, 10, 'b', 300, 'a', 400, 'c', 20, 500, 600, 30}

# 向集合中添加一个集合，将集合中的元素一个一个的添加进集合
set01.update({111,222})
print(set01) # {100, 200, 10, 'b', 300, 'a', 111, 400, 'c', 20, 500, 600, 222, 30}

# 向集合中添加一个字典，将字典中的键添加到集合中
set01.update({"m":1000,"n":2000})
print(set01) # {100, 'n', 200, 'm', 10, 'b', 300, 'a', 111, 400, 'c', 20, 500, 600, 222, 30}

运行结果如下图所示：
在这里插入图片描述

添加Number类型数据报错，这个自行验证。


七、删除集合元素

在Python中，集合（set）是一种无序且不包含重复元素的数据结构。要删除集合中的元素，你可以使用以下几种方法：

7.1 使用 remove() 方法删除集合元素

remove() 方法用于删除集合中的指定元素。如果集合中存在该元素，则删除它；如果不存在，则会引发一个 KeyError 异常。

set01 = {10, 20, 30, 40, 50}
print(set01) # {50, 20, 40, 10, 30}
# 使用remove()方法删除元素30
set01.remove(30)
print(set01) # {50, 20, 40, 10}

运行结果如下图所示：
在这里插入图片描述

尝试删除不存在的元素90将引发KeyError

set01 = {10, 20, 30, 40, 50}
print(set01) # {50, 20, 40, 10, 30}
# 尝试删除不存在的元素90,将引发KeyError
set01.remove(90) # KeyError: 90
print(set01)

运行结果如下图所示：
在这里插入图片描述

7.2 使用 discard() 方法删除集合元素

discard() 方法也用于删除集合中的指定元素。与 remove() 方法不同的是，如果集合中不存在要删除的元素，discard() 方法不会引发异常，而是默默地不做任何操作。

set01 = {10, 20, 30, 40, 50}
print(set01) # {50, 20, 40, 10, 30}
# 使用discard()方法删除元素30
set01.discard(30)
print(set01) # {50, 20, 40, 10}

my_set.discard(6)  # 尝试删除不存在的元素6，不会引发异常
print(my_set)  # 输出仍然是: {1, 2, 4, 5}

运行结果如下图所示：
在这里插入图片描述

尝试删除不存在的元素90，不会引发异常

set01 = {10, 20, 30, 40, 50}
print(set01) # {50, 20, 40, 10, 30}
# 尝试删除不存在的元素90，不会引发异常
set01.discard(90)
print(set01) # {50, 20, 40, 10, 30}

运行结果如下图所示：
在这里插入图片描述

7.3 使用 pop() 方法删除集合元素

pop() 方法用于随机删除集合中的一个元素，并返回被删除的元素。由于集合是无序的，因此 pop() 方法删除哪个元素是不确定的。

set01 = {10, 20, 30, 40, 50, 60 ,70 ,80, 90}
print("删除元素前集合：",set01) # 删除元素前集合： {70, 40, 10, 80, 50, 20, 90, 60, 30}
removed_element = set01.pop() # 删除的元素： 70
print("删除的元素：",removed_element)  # 打印被移除的元素
print("删除元素后集合：",set01) # 删除元素后集合： {40, 10, 80, 50, 20, 90, 60, 30}

运行结果如下图所示：
在这里插入图片描述

7.4 使用 clear() 方法删除集合元素

如果你想要删除集合中的所有元素，可以使用 clear() 方法。这将使集合变为空集。

set01 = {10, 20, 30, 40, 50}
print(set01) # {50, 20, 40, 10, 30}
# 清空集合
set01.clear()
print(set01) # set()

运行结果如下图所示：
在这里插入图片描述


八、查找集合元素

8.1 in运算符查询元素在集合中是否存在

使用in运算符查询某个元素在集合中是否存在，如果存在返回True，如果不在返回False。

语法格式如下：

result = 元素值 in 集合名

演示代码如下：

set01 = (10,20,30,40,50,60,70)

result01 = 10 in set01
print("元素10在集合set01中存在：",result01) # 元素10在集合set01中存在： True

result02 = 100 in set01
print("元素100在集合set01中存在：",result02) # 元素100在集合set01中存在： False

运行结果如下图所示：
在这里插入图片描述

8.2 not in运算符查询元素在集合中是否不存在

使用not in运算符查询某个元素在集合中是否不存在，如果不存在返回True，如果存在返回False。

语法格式如下：

result = 元素值 not in 集合名

演示代码如下：

set01 = (10,20,30,40,50,60,70)

result01 = 10 not in set01
print("元素10不在集合set01中存在：",result01) # 元素10不在集合set01中存在： False

result02 = 100 not in set01
print("元素100不在集合set01中存在：",result02) # 元素100不在集合set01中存在： True

运行结果如下图所示：
在这里插入图片描述

九、集合推导式

9.1 什么是推导式

Python推导式（comprehension）是一种简洁而高效的构建容器（如列表、集合、字典）的方法。它允许你用一行代码来创建容器，并且可以通过循环和条件语句来生成容器中的元素。

推导式分为列表推导式（list comprehension）、集合推导式（set comprehension）、字典推导式（dictionary comprehension）以及生成器表达式（generator expression）。

推导式是Python中非常强大和常用的特性，可以使代码更加简洁和高效。

9.2 集合推导式

集合推导式提供了一种创建列表的简洁方法，通常是操作某个序列的每个元素，并将其结果作为新集合的元素，或者根据判定条件创建子序列。集合推导式一般由表达式及for语句构成，其后还可以有零个到多个for自居或if子句，返回结果是表达式在for语句和if语句的操作下生成的集合。

语法格式：

setname = {expression for variable in 对象（if condition）}
  • listname：新生成的集合名字。
  • expression：表达式。
  • variable：变量名。
  • （if condition）：用于从对象中选择符合要求的集合。

演示示例：

# 1：生成[0-10)之间的10个整数，存储在集合中
# 普通方式生成
list01 = []
for i in range(10):
   list01.append(i)
set01 = set(list01)
print("普通方式生成的集合：",set01) # 普通方式生成的集合： {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

# 集合推导式生成
set02 = {i for i in range(10)}
print("集合推导式生成的集合：",set02) # 集合推导式生成的集合： {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}


# 2：生成一个[1-10]之间所有整数的平方组成的集合
# 普通方式生成
list02 = []
for i in range(1,11):
    list02.append(i ** 2)
set03 = set(list02)
print("普通方式生成的集合：",set03) # 普通方式生成的集合： {64, 1, 4, 36, 100, 9, 16, 49, 81, 25}

# 集合推导式生成
set04 = {i**2 for i in range(1,11)}
print("集合推导式生成的集合：",set04) # 集合推导式生成的集合： {64, 1, 4, 36, 100, 9, 16, 49, 81, 25}


# 3:取出已有集合中的奇数值生成新集合
# 已有集合
set05 = {1,2,3,4,5,6,7,8,9,10}
# 普通方式生成
list03 = []
for i in set05:
    if i%2!=0:
        list03.append(i)
set06 = set(list03)
print("普通方式生成的集合：",set06) # 普通方式生成的集合： {1, 3, 5, 7, 9}

# 集合推导式生成
set07 = {i for i in set05 if i%2!=0}
print("集合推导式生成的集合：",set07) # 集合推导式生成的集合： {1, 3, 5, 7, 9}

运行结果如下图所示：
在这里插入图片描述

十、集合运算

集合运算是指对集合进行的一系列操作，如并集、交集、差集等。这些运算在数据处理、逻辑运算等领域有着广泛的应用。

以下是Python集合的运算操作符或方法的展示

运算类型操作符方法说明
并集A|BA.union(B)并集，返回一个新集合，包括集合A和集合B中所有的元素
交集A&BA.intersection(B)交集，返回一个新集合，包括同时在集合A和集合B中的元素
差集A-BA.difference(B)差集，返回一个新集合，包括在集合A中但不在集合B中的元素
对称差集A^BA.symmetric_difference(B)对称差集，返回一个新集合，包括集合A和集合B中的元素，但是不包括同时在两集合中的元素
子集A<=BA.issubset(B)如果集合A与集合B相同或者A是B的子集，返回True，否则返回False
真子集A<B无如果集合A是集合B的真子集，返回True，否则返回False
超集A>=BA.issuperset(B)如果集合A与集合B相同或者A是B的超集，返回True，否则返回False
真超集A>B无如果集合A是集合B的真超集，返回True，否则返回False
集合相等A==B无如果集合A与集合B相同，返回True，否则返回False
集合不相等A!=B无如果集合A与集合B不 相同，返回True，否则返回False
空交集判断无A.isdisjoint(B)如果集合A与集合B没有公共元素，返回 True，否则返回 False。
更新A|=BA.update(B)更新集合，将集合B中的元素并入集合A中
更新无A.ntersection_update(B) 用集合A和集合B的交集来更新集合A
更新无 A.difference_update(B)从集合A中删除集合B的所有元素 来更新集合A
更新无 A.symmetric_difference_update(B)用集合A和另集合B的对称差来更新集合A

集合的并集、交集、差集、对称差集示意图：
在这里插入图片描述

集合的并集、交集、差集、对称差集运算代码：

# 在对集合做运算时，不会影响原来的集合，而是返回一个运算结果
# 创建2个集合
A = {10,20,30,40,50}
B = {30,40,50,60,70}
print("运算前集合A：",A) # 运算前集合A： {50, 20, 40, 10, 30}
print("运算前集合B：",B) # 运算前集合B： {50, 70, 40, 60, 30}

# 并集：使用 A | B 或 A.union(B)实现,返回一个新集合，包括集合A和集合B中所有的元素。
result01 = A | B
print("并集 A | B：",result01) # 并集 A | B： {70, 40, 10, 50, 20, 60, 30}
result02 = A.union(B)
print("并集 A.union(B)：",result02) # 并集 A.union(B)： {70, 40, 10, 50, 20, 60, 30}


# 交集：使用 A & B 或 A.intersection(B)实现返回一个新集合，包括同时在集合A和集合B中的元素。
result03 = A & B
print("交集 A & B：",result03) # 交集 A & B： {40, 50, 30}
result04 = A.intersection(B)
print("交集 A.intersection(B)：",result04) # 交集 A.intersection(B)： {40, 50, 30}


# 差集：使用 A - B 或 A.difference(B)实现返回一个新集合，包括在集合A中但不在集合B中的元素。
result05 = A - B
print("差集 A - B：",result05) # 差集 A - B： {10, 20}
result06 = A.difference(B)
print("差集 A.difference(B)：",result06) # 差集 A.difference(B)： {10, 20}


# 对称差集：使用 A ^ B 或 A.symmetric_difference(B)实现返回一个新集合，包括集合A和集合B中的元素，但是不包括同时在两集合中的元素。
result07 = A ^ B
print("对称差集 A ^ B：",result07) # 对称差集 A ^ B： {20, 70, 10, 60}
result08 = A.symmetric_difference(B)
print("对称差集 A.symmetric_difference(B)：",result08) # 对称差集 A.symmetric_difference(B)： {20, 70, 10, 60}

# 做完并集、差集、交集、对称差集运算之后的集合A和集合B
print("运算后集合A：",A) # 运算后集合A： {50, 20, 40, 10, 30}
print("运算后集合B：",B) # 运算后集合B： {50, 70, 40, 60, 30}

在这里插入图片描述

集合的子集、真子集、超集、真超集运算代码：

# 在对集合做运算时，不会影响原来的集合，而是返回一个运算结果
# 创建3个集合

A1 = {10,20,30}
B1 = {10,20,30}
B2 = {10,20,30,40,50}
print("运算前集合A1：",A1) # 运算前集合A1： {10, 20, 30}
print("运算前集合B1：",B1) # 运算前集合B1： {10, 20, 30}
print("运算前集合B2：",B2) # 运算前集合B2： {50, 20, 40, 10, 30}

# 子集：使用 A <= B 或 A.issubset(B)实现，如果集合A中的元素全部都在集合B中出现，那么集合A就是集合B的子集，返回True，否则返回False
# 超集：使用 A >= B 或 A.issuperset(B)实现，如果集合B中的元素全部都在集合A中，那么集合A就是集合B的超集，返回True，否则返回False
# 真子集：特殊的子集，使用 A < B 或 实现，如果超集B中含有子集A中所有元素，并且集合B中还有集合A中没有的元素，那么集合A是集合B的真子集，返回True，否则返回False
# 真超集：特殊的超集，使用A > B 或 实现，如果超集A中包含有自己B中所有㢝，并且集合A中还有集合B中没有的元组，那么集合A是集合B的真超集，返回True，否则返回False
print("集合A1是集合B1的子集：",A1 <= B1) # 集合A1是集合B1的子集： True
print("集合A1是集合B1的真子集：",A1 < B1) # 集合A1是集合B1的真子集： False
print("集合A1是集合B2的子集：",A1 <= B2) # 集合A1是集合B2的子集： True
print("集合A1是集合B2的真子集：",A1 < B2) # 集合A1是集合B2的真子集： True

print("集合B1是集合A1的超集：",B1 >= A1) # 集合B1是集合A1的超集： True
print("集合B1是集合A1的真超集：",B1 > A1) # 集合B1是集合A1的真超集： False
print("集合B2是集合A1的超集：",B2 >= A1) # 集合B2是集合A1的超集： True
print("集合B2是集合A1的真超集：",B2 > A1) # 集合B2是集合A1的真超集： True

运算结果如下图所示：
在这里插入图片描述

集合相等和不相等判断、集合空交集判断代码：

# 在对集合做运算时，不会影响原来的集合，而是返回一个运算结果
# 创建两个集合

A = {10,20,30}
B1 = {10,20,30}
B2 = {40,50,60}

# 集合相等判断、集合不相等判断：使用==和!=实现
print("集合A=集合B1：",A == B1) # 集合A=集合B1： True
print("集合A=集合B2：",A == B2) # 集合A=集合B2： False
print("集合A!=集合B1：",A != B1) #集合A!=集合B1： False
print("集合A!=集合B2：",A != B2) # 集合A!=集合B2 True

# 集合空交集判断：
print("集合A和集合B1没有交集：",A.isdisjoint(B1)) # 集合A和集合B1没有交集： False
print("集合A和集合B2没有交集：",A.isdisjoint(B2)) # 集合A和集合B2没有交集： True

集合相等和不相等判断、集合空交集判断运行结果如下：
在这里插入图片描述

更新操作代码：

# update()：用自己和另一个的并集来更新这个集合
s1 = {'p', 'y'}
print("原始集合s1：",s1) # 原始集合s1： {'p', 'y'}

s1.update("python")
print("添加字符串后的集合s1：",s1) # 添加字符串后的集合s1： {'o', 't', 'h', 'n', 'p', 'y'}

s1.update(['t', 'h', 'o', 'n'])    # 添加多个元素
print("添加列表后的集合s1：",s1)  # 添加列表后的集合s1： {'o', 't', 'h', 'n', 'p', 'y'}

s1.update((10,20))
print("添加元组后的集合s1：",s1) # 添加元组后的集合s1： {'o', 't', 10, 'h', 'n', 20, 'p', 'y'}

s1.update({111,222})
print("添加集合后的集合s1：",s1) # 添加集合后的集合s1： {'o', 't', 10, 'h', 'n', 111, 20, 'p', 222, 'y'}
s1.update(['H', 'e'], {'l', 'l', 'o'})    # 添加列表和集合
print("添加列表和集合后的集合s1：",s1) # 添加列表和集合后的集合s1： {'e', 'o', 'l', 't', 10, 'h', 'n', 111, 20, 'H', 'p', 222, 'y'}

# intersection_update()：用自己和另一个的交集来更新这个集合
s = {'a', 'b', 'c', 'd', 'q'}
s2 = {'c', 'd', 'e', 'f'}
s.intersection_update(s2)   # 相当于s = s - s2
print("intersection_update()：",s) # intersection_update()： {'d', 'c'}


# difference_update()：从这个集合中删除另一个集合的所有元素
s = {1, 2, 3}
s1 = {1, 2, 3, 4}
s2 = {2, 3}
s.difference_update(s2)
print("s.difference_update(s2)：",s) # s.difference_update(s2)： {1}
s1.difference_update(s2)
print("s1.difference_update(s2)：",s1) # s1.difference_update(s2)： {1, 4}

# symmetric_difference_update() 用自己和另一个的对称差来更新这个集合
s = {1, 2, 3}
s1 = {1, 2, 3, 4}
s2 = {2, 3}
s1.symmetric_difference_update(s)
print("s1.symmetric_difference_update(s)：",s1) # s1.symmetric_difference_update(s)： {4}
s.symmetric_difference_update(s2)
print("s.symmetric_difference_update(s2)",s) # s.symmetric_difference_update(s2) {1}

运行结果如下图所示：
在这里插入图片描述

需要注意的是，集合中的元素是无序且唯一的，因此在进行集合运算时，结果集合中的元素顺序可能与示例中的顺序不同，但元素本身是相同的。此外，集合运算的结果也是集合类型，可以使用集合的相关方法和操作符进行进一步的操作。


十一、集合其他操作

函数描述
all()如果集合中的所有元素都是 True（或者集合为空），则返回 True。
any()如果集合中的所有元素都是 True，则返回 True；如果集合为空，则返回 False。
max()返回集合中的最大项
min()返回集合中的最小项
sorted()从集合中的元素返回新的排序列表（不排序集合本身）
sum()返回集合的所有元素之和

代码如下所示：

# all():如果集合中的所有元素都是 True（或者集合为空），则返回 True。
print("all()：",all({10,20})) # all()： True
print("all()：",all({0})) # all()： False
print("all()：",all({})) # all()： True
print("all()：",all({False})) # all()： False

# any():如果集合中的所有元素都是 True，则返回 True；如果集合为空，则返回 False。
print("any()：",any({10,20})) # any()： True
print("any()：",any({0})) # any()： False
print("any()：",any({})) # any()： False
print("any()：",any({False})) # any()： False

# max():返回集合中的最大项
print("max()：",max({10,40,20,90,60})) # max()： 90

# min():返回集合中的最小项
print("min()：",min({10,40,20,90,60})) # min()： 10

# sum():返回集合的所有元素之和
print("sum()：",sum({10,40,20,90,60})) # sum()： 220

# sorted() 从集合中的元素返回新的排序列表（不排序集合本身）
set01 = {10,40,90,20,30,50,80,60,70}
print(set01) # {70, 40, 10, 80, 50, 20, 90, 60, 30}
# sorted()默认进行升序排序，返回一个升序排序的列表
result01 = sorted(set01) 
print(result01) # [10, 20, 30, 40, 50, 60, 70, 80, 90]
print(type(result01)) # <class 'list'>

result02 = sorted(set01,reverse=True)
print(result02) # [90, 80, 70, 60, 50, 40, 30, 20, 10]
print(type(result02)) # <class 'list'>

运行结果如下图所示：
在这里插入图片描述


十二、总结

在Python编程的世界里，集合（Set）作为一种独特且强大的数据结构，扮演着举足轻重的角色。集合由唯一、无序的元素组成，它利用哈希表实现，因此在进行元素查找、添加和删除等操作时，具有极高的效率。

在本文中，我们深入了解了集合的基本概念、创建方法以及丰富的操作方法。集合可以通过大括号{}直接创建，也可以通过set()函数将其他可迭代对象转换为集合。集合中的元素是唯一的，这意味着集合会自动去除重复的元素。

我们学习了如何利用集合进行高效的数学集合运算，如并集、交集、差集和对称差集等。这些运算不仅简化了代码逻辑，还提高了数据处理的效率和准确性。同时，集合还提供了许多实用的方法，如add()用于添加元素，remove()用于删除元素，clear()用于清空集合，以及len()用于获取集合中元素的个数等。

此外，集合在数据去重、关系测试等实际应用场景中发挥着巨大的作用。例如，在处理大量数据时，我们可以利用集合快速去除重复项；在判断两个集合之间的关系时，集合运算也能提供极大的便利。

综上所述，Python集合是一种功能强大、易于使用的数据结构。通过本文的学习，我们掌握了集合的基本概念和操作方法，为今后的编程实践打下了坚实的基础。希望大家在今后的编程过程中，能够灵活运用集合这一工具，提升编程效率和代码质量。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序员张小厨

你的鼓励将是我持创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值