Python 集合set内置函数与方法

Python 集合set内置函数与方法

集合（set）是一个无序的不重复元素序列。

1、创建集合

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

1.1、使用大括号{}

set_a = {'b', 'c', 'd', 'e', 'f', 'g'}
print(type(set_a),'\n',set_a)

# 
# {'f', 'c', 'g', 'd', 'b', 'e'}

1.2、使用set()函数

set_a = set(['b', 'c', 'd', 'e', 'f', 'g','g'])
print(type(set_a),'\n',set_a)

# 
# {'e', 'b', 'f', 'c', 'g', 'd'}

2、运算符

两个集合之间的计算有4种运算，分别是 -、|、&、^。

2.1、集合减法-

set_a = set(['b', 'c', 'd', 'e', 'f', 'g'])
set_b = set(['b', 'c', 'h', 'j', 'k', 'm'])
print(type(set_a - set_b),'\n',set_a - set_b)
print('set_a:',set_a)
print('set_b:',set_b)

# 
# {'g', 'e', 'f', 'd'}
#set_a: {'d', 'c', 'e', 'g', 'b', 'f'}
#set_b: {'j', 'c', 'b', 'k', 'm', 'h'}

set_a - set_b ：返回集合 set_a 不在集合 set_b 中的元素，原集合set_a、set_b元素不变。

2.2 、集合并集|

set_a = set(['b', 'c', 'd', 'e', 'f', 'g'])
set_b = set(['b', 'c', 'h', 'j', 'k', 'm'])
print(type(set_a | set_b),'\n',set_a | set_b)
print('set_a:',set_a)
print('set_b:',set_b)

# 
# {'e', 'g', 'j', 'd', 'b', 'f', 'h', 'c', 'k', 'm'}
#set_a: {'e', 'g', 'd', 'b', 'f', 'c'}
#set_b: {'j', 'b', 'h', 'c', 'k', 'm'}

set_a | set_b ：返回在集合 set_a 或在集合 set_b 中的元素，原集合set_a、set_b元素不变。

2.3 、集合交集&

set_a = set(['b', 'c', 'd', 'e', 'f', 'g'])
set_b = set(['b', 'c', 'h', 'j', 'k', 'm'])
print(type(set_a & set_b),'\n',set_a & set_b)
print('set_a:',set_a)
print('set_b:',set_b)

# 
# {'b', 'c'}
#set_a: {'e', 'g', 'd', 'b', 'f', 'c'}
#set_b: {'j', 'b', 'h', 'c', 'k', 'm'}

set_a & set_b ：返回同时在集合 set_a 与 set_b 中的元素，原集合set_a、set_b元素不变。
 

2.4、集合 ^

set_a = set(['b', 'c', 'd', 'e', 'f', 'g'])
set_b = set(['b', 'c', 'h', 'j', 'k', 'm'])
print(type(set_a ^ set_b),'\n',set_a ^ set_b)
print('set_a:',set_a)
print('set_b:',set_b)

# 
# {'d', 'e', 'f', 'k', 'g', 'm', 'j', 'h'}
#set_a: {'e', 'g', 'd', 'b', 'f', 'c'}
#set_b: {'j', 'b', 'h', 'c', 'k', 'm'}

set_a ^ set_b ：返回集合 set_a 与 set_b 所有元素，再去掉同时在集合 set_a 与 set_b中出现的元素，原集合set_a、set_b元素不变。
 

3、访问集合

无法通过引用索引来访问 set 中的项目，因为 set 是无序的，项目没有索引。

但是可以使用 for 循环遍历 set 项目，或者使用 in 关键字查询集合中是否存在指定值。

4、常用内置函数与方法

概述

名称	描述
len(set)	返回集合的长度（去掉重复元素后的）
del set	删除集合，删除后不能再访问
set.add(item)	将item添加到集合
set.update(set2)	将set2或一个元素添加到set,重复元素只会出现一次
set.remove(item)	移除集合中的指定元素item，移除一个不存在的元素时会发生错误。
set.discard(item)	移除集合中的指定元素item，移除一个不存在的元素时不会发生错误。
set.pop()	随机移除一个元素
set.clear()	清空集合中的元素，之后将是空集合。
set.union(set1, set2 ...)	返回两个集合元并集的新集合，重复的元素只会出现一次；原集合元素不会改变。
set.copy()	用于拷贝一个集合
set.isdisjoint(set2)	判断两个集合是否不包含相同的元素，无相同元素返回True，否则返回False
set.intersection(set1, set2 ... etc)	返回两个或更多集合中都包含的元素，即交集；返回的是新集合。原集合元素不改变。
set.intersection_update(set1, set2 ... etc)	获取两个或更多集合中都重叠的元素，即计算交集,在原集合set上移除不重叠的元素。
set.issubset(set2)	判断集合的所有元素是否都包含在指定集合中，如果set是set2的子集则返回 True，否则返回 False。
set.issuperset(set2)	判断指定集合的所有元素是否都包含在原始的集合中，如果set是set2的超集则返回 True，否则返回 False。
set.difference(set2)	返回集合的差集，即返回的是新集合，元素包含在第一个集合中，但不包含在第二个集合中。原集合set、set2元素不改变。
set.difference_update(set2)	在集合set移除两个集合中都存在的元素。集合set2元素不改变。
set.symmetric_difference(set2)	返回新集合，将两个集合做并集处理，再移除交集元素，即会移除两个集合中都存在的元素。原集合set、set2元素不改变。
set.symmetric_difference_update(set2)	移除集合set中在集合set2相同的元素，并将集合set2中不同的元素插入到集合set中。集合set元素改变，集合set2元素不改变。

4.1、 len()函数

计算集合元素数量，返回的是去除重复的元素数量。

语法

len(set)

4.2 、del()函数

集合删除

语法

del set

注意：使用完del()函数删除集合后，不能再使用了，否则会报错NameError: name 'fruit' is not defined。

4.3、add()方法-添加元素

add() 方法用于给集合添加元素，如果添加的元素在集合中已存在，则不执行任何操作。

语法

set.add(element)

参数          描述
element    必需。要添加到集合的元素。

如果该元素已存在，则 add() 方法就不会添加元素。

4.3、updata()方法-添加元素

update() 方法用于修改当前集合，添加新的元素或集合到当前集合中，如果添加的元素在集合中已存在，则该元素只会出现一次，重复的会忽略。

语法

set.update(set)
 

参数    描述
set    必需。插入当前集合的集合或一个元素。
实例

set_a = set(['b', 'c', 'd', 'e', 'g', 'g'])

print('set:',set_a)
set_a.update('h')
print('set2:',set_a)

set_b = set(['b', 'c', 'h', 'j', 'k', 'm'])
set_a.update(set_b)
print('set3:',set_a)


#set: {'c', 'b', 'g', 'd', 'e'}
#set2: {'c', 'b', 'g', 'd', 'e', 'h'}
#set3: {'c', 'k', 'b', 'g', 'd', 'j', 'm', 'e', 'h'}

4.4、remove()方法-移除元素

remove() 方法用于移除集合中的指定元素。

该方法不同于 discard() 方法，因为 remove() 方法在移除一个不存在的元素时会发生错误，而 discard() 方法不会。

语法

set.remove(item)

参数    描述
item    必需。需要检索并删除的项目。
实例

set_a = set(['b', 'c', 'd', 'e', 'g', 'g'])

print('set:',set_a)
set_a.remove('e')
print('set2:',set_a)

set_a.remove('h') 
#移除不存在的元素会报错


#set: {'d', 'g', 'c', 'e', 'b'}
#set2: {'d', 'g', 'c', 'b'}

4.5、discard()方法-移除元素

discard() 方法用于移除指定的集合元素。

该方法不同于 remove() 方法，因为 remove() 方法在移除一个不存在的元素时会发生错误，而 discard() 方法不会。

语法

set.discard(item)

参数    描述
value    必需。要检索并删除的项目。
实例

set_a = set(['b', 'c', 'd', 'e', 'g', 'g'])

print('set:',set_a)
set_a.discard('e')
print('set2:',set_a)

set_a.discard('h')
print('set3:',set_a)


#set: {'c', 'd', 'b', 'e', 'g'}
#set2: {'c', 'd', 'b', 'g'}
#set3: {'c', 'd', 'b', 'g'}

4.6、pop()方法 - 移除元素

pop() 方法将删除最后一个元素；因集合set是无序的，是随机移除一个元素。空集合使用此方法会报错。

语法

set.pop()

无参数。

实例

set_a = set(['b', 'c', 'd', 'e', 'g', 'g'])

print('set:',set_a)
set_a.pop()
print('set2:',set_a)

set_a.pop()
print('set3:',set_a)


#set: {'g', 'e', 'c', 'd', 'b'}
#set2: {'e', 'c', 'd', 'b'}
#set3: {'c', 'd', 'b'}

4.7、clear()方法-清空集合

clear() 方法用于移除集合中的所有元素。del 功能是删除集合。

语法

set.clear()

参数值

无参数。

4.8、union()方法-合并集合

union() 方法返回两个集合元并集的新集合，即包含了所有集合的元素，重复的元素只会出现一次；原集合元素不会改变。也可以使用 update() 方法将一个集合中的所有项目插入另一个集合中。

语法

set.union(set1, set2 ...)

参数    描述
set1    必需。要整合的集合。
set2    可选。要整合的另一集合。您能够比较任意多的集合。集合由逗号分隔。
实例

set_a = set(['b', 'c', 'd', 'e', 'g'])
set_b = set(['b', 'c', 'h', 'j', 'k', 'm'])
set_c = set('123')
set_d = set_a.union(set_b,set_c)
print('Union:',set_d)
print('set_a:',set_a)
print('set_b:',set_b)
print('set_c:',set_c)

#Union: {'d', 'j', '3', 'k', '1', 'c', 'h', 'e', 'm', '2', 'g', 'b'}
#set_a: {'d', 'c', 'e', 'g', 'b'}
#set_b: {'j', 'k', 'c', 'h', 'm', 'b'}
#set_c: {'3', '1', '2'}

4.9、copy()方法 - 拷贝集合

copy() 方法用于拷贝一个集合。

语法

set.copy()

无参数。

4.10、isdisjoint()方法-判断是否包含相同元素 

isdisjoint() 方法用于判断两个集合不包含相同的元素，如果不包含返回 True，否则返回 False。

语法

set.isdisjoint(set2)

参数    描述
set    必需。要在其中检索相同项目的集合。
实例

set_a = set(['b', 'c', 'd', 'e', 'g'])
set_b = set(['b', 'c', 'h', 'j', 'k', 'm'])
set_c = set('123')
result = set_a.isdisjoint(set_c)
print('result:',result)

#result: True

4.11、 intersection() 方法-返回交集

intersection() 方法用于返回两个或更多集合中都包含的元素，即交集；返回的是新集合。原集合元素不改变。

语法

set.intersection(set1, set2 ... etc)

参数    描述
set1    必需。要在其中检索相同项目的集合。
set2    可选。其他需要在其中检索相同项目的集合。您可以比较任意多的集合。集合之间由逗号分隔。

4.12、intersection_update()方法-返回交集

intersection_update() 方法，在集合set上仅保留两个或更多集合中都重叠的元素，即计算交集。只改变集合set的元素，其他集合元素不改变。

语法

set.intersection_update(set1, set2 ... etc)

参数    描述
set1    必需。要在其中检索相等项目的集合。
set2    可选。要在其中检索相等项目的另一集合。您能够比较任意多的集合。集合由逗号分隔。
实例

set_a = set(['b', 'c', 'd', 'e', 'g'])
set_b = set(['b', 'c', 'h', 'j', 'k', 'm'])

result = set_a.intersection_update(set_b)
print('result:',result)
print('set_a:',set_a)
print('set_b:',set_b)

#result: None
#set_a: {'c', 'b'}
#set_b: {'h', 'm', 'j', 'b', 'k', 'c'}

集合set_a移除了不相同的元素，集合set_b中的元素不改变。

注：
intersection_update() 方法不同于 intersection() 方法，因为 intersection() 方法是返回一个新的集合，而 intersection_update() 方法是在原始的集合上移除不重叠的元素。

4.13、 issubset() -判断子集

issubset() 方法用于判断集合的所有元素是否都包含在指定集合中，如果set是set2的子集则返回 True，否则返回 False。

语法

set.issubset(set2)

参数    描述
set    必需。在其中检索相等项目的集合。

4.14、issuperset()-判断超集

issuperset() 方法用于判断指定集合的所有元素是否都包含在原始的集合中，如果set是set2的超集则返回 True，否则返回 False。

语法

set.issuperset(set2)

参数    描述
set    必需。要在其中检索相等项目的集合。
实例

set_a = set('123456')
set_b = set('123')

result = set_b.issubset(set_a)
result2 = set_a.issuperset(set_b)
print('result:',result)
print('result2:',result2)
print('set_a:',set_a)
print('set_b:',set_b)

#result: True
#result2: True
#set_a: {'2', '1', '5', '6', '4', '3'}
#set_b: {'1', '3', '2'}

4.15、 difference() -差集

difference() 方法用于返回集合的差集，即返回的是新集合，元素包含在第一个集合中，但不包含在第二个集合(方法的参数)中。原集合set、set2元素不改变。

语法

set.difference(set2)

参数    描述
set    必需。要检查其中差异的项目。
 

4.16、difference_update()-差集

difference_update() 方法在集合set移除两个集合中都存在的元素。集合set2元素不改变。

语法

set.difference_update(set2)

参数    描述
set    必需。要检查其中差异的集合。
实例

set_a = set('123456')
set_b = set('123789')
result = set_a.difference(set_b)
print('difference result:',result)
print('set_a:',set_a)
print('set_b:',set_b)

set_a = set('123456')
set_b = set('123789')
result = set_a.difference_update(set_b)
print('difference_update result:',result)
print('set_a:',set_a)
print('set_b:',set_b)

#difference result: {'5', '6', '4'}
#set_a: {'5', '3', '1', '6', '4', '2'}
#set_b: {'8', '3', '9', '7', '1', '2'}

#difference_update result: None
#set_a: {'5', '6', '4'}
#set_b: {'8', '3', '9', '7', '1', '2'}

difference_update() 方法与 difference() 方法的区别在于 difference() 方法返回一个移除相同元素的新集合，而 difference_update() 方法是直接在原来的集合中移除元素，没有返回值。

4.17、 symmetric_difference()-移除交集元素

symmetric_difference() 方法返回新集合，将两个集合做并集处理，再移除交集元素，即会移除两个集合中都存在的元素。原集合set、set2元素不改变。

语法

set.symmetric_difference(set2)

参数    描述
set    必需。用于检查匹配项的集合。

4.18、 symmetric_difference_update()-移除交集元素

symmetric_difference_update() 方法移除集合set中在集合set2相同的元素，并将集合set2中不同的元素插入到集合set中。集合set元素改变，集合set2元素不改变。

语法

set.symmetric_difference_update(set2)

参数    描述
set    必需。用于检查匹配项的集合。
实例

set_a = set('123456')
set_b = set('123789')
result = set_a.symmetric_difference(set_b)
print('symmetric result:',result)
print('set_a:',set_a)
print('set_b:',set_b)

set_a = set('123456')
set_b = set('123789')
result = set_a.symmetric_difference_update(set_b)
print('symmetric_update result:',result)
print('set_a:',set_a)
print('set_b:',set_b)

#symmetric result: {'6', '7', '4', '5', '8', '9'}
#set_a: {'4', '5', '3', '6', '1', '2'}
#set_b: {'8', '3', '7', '1', '9', '2'}

#symmetric_update result: None
#set_a: {'4', '8', '5', '7', '6', '9'}
#set_b: {'8', '3', '7', '1', '9', '2'}

————————————————————————————————————
参考文章：https://blog.csdn.net/m0_70885101/article/details/125948550