Python3之集合set

1、定义及创建

集合是一个无序的不重复元素序列

创建集合可以使用{}或者set()函数，但创建一个空集合时只能使用set()函数，不能使用{}，因为{}用于创建一个空字典，当使用set()创建集合时，value为一个元组

语法：set(value)或setA = {value01,value02,...}

setA = set((1 , 2 , 3 ,4))
setB = {'a' , 'b' , 'c' , 'd' , 'a' , 'e' , 'f'}
print("集合setA为：", setA)
print("集合setB为：", setB) # 集合去重

集合setA为： {1, 2, 3, 4}
集合setB为： {'b', 'f', 'c', 'a', 'd', 'e'}

2、集合的基本操作

setA = set((1 , 2 , 3 ,4))

a、添加元素

方法1：setA.add(x)，将x添加到集合setA中，如setA中已存在元素，则不进行添加操作，

方法2：setA.update(x)，将元素x添加到集合setA中，且参数x可以是列表、元组、字典、数组等，如setA中已存在元素，则不进行添加操作

注：

1、字符串作为参数添加集合元素，字符串被拆分成一个个的字符作为集合的元素

2、字典作为参数添加集合元素，仅将字典的key添加至集合中

# 2、添加集合元素
# 1、set.add(x)添加集合元素，如集合中已有元素，则不再进行添加操作
# 2、set.update(x)添加集合元素，x可是字符串、列表、元组、字典
setA = set((1 , 2 , 3 ,4))
print("集合setA添加完元素前为：" , setA)
setA.add(4) # 集合中已有元素4，因此不再继续重复添加4
setA.add(5)
print("集合setA添加完元素5后为：" , setA)
# set.update(x)使用字符串添加集合
setA.update('1678')
# 使用字符串添加集合元素，字符串被拆分成一个个的字符作为集合的元素
print("set.update(x)使用字符串1678添加集合后为：" , setA)
# set.update(x)使用列表添加集合
setA.update(['a' , 'b' , 2 ])
print("set.update(x)使用列表['a' , 'b' , 2 ]添加集合后为：" , setA)
# set.update(x)使用元组添加集合
setA.update(('c' , 'd' , 3 ))
print("set.update(x)使用元组('c' , 'd' , 3 )添加集合后为：" , setA)
# set.update(x)使用字典添加集合
setA.update({'Kobe' : '24' , 'Curry' : '30' })
print("set.update(x)使用字典{'Kobe' : '24' , 'Curry' : '30' }添加集合后为：" , setA)

集合setA添加完元素前为： {1, 2, 3, 4}
集合setA添加完元素5后为： {1, 2, 3, 4, 5}
set.update(x)使用字符串1678添加集合后为： {1, 2, 3, 4, 5, '7', '1', '8', '6'}
set.update(x)使用列表['a' , 'b' , 2 ]添加集合后为： {1, 2, 3, 4, 5, '7', '1', '8', '6', 'b', 'a'}
set.update(x)使用元组('c' , 'd' , 3 )添加集合后为： {1, 2, 3, 4, 5, '7', 'c', '1', '8', '6', 'b', 'd', 'a'}
set.update(x)使用字典{'Kobe' : '24' , 'Curry' : '30' }添加集合后为： {1, 2, 3, 4, 5, '7', 'c', '1', '8', '6', 'Kobe', 'Curry', 'b', 'd', 'a'}

b、移除元素

方法1：setA.remove(x)，将元素x从集合setA中移除，如x不存在，报错

方法2：setA.discard(x)， 将元素x从集合setA中移除，如x不存在，不会报错

方法3：setA.pop()，随机删除集合中的一个元素；set集合的pop()方法会对集合进行无序排列，删除无序排列集合的左边第一个元素(每次移除结果不一样)

setA = {'1' , '2' , '3' , '4' , '5'}
setA.remove('1')
print('setA.remove(x)移除集合元素：' , setA)
# setA.remove(x)移除不存在的元素会报错
# setA.remove('1')
# print('setA.remove(x)移除集合元素：' , setA)
setA.discard('2')
print('setA.discard(x)移除集合元素：' , setA)
# setA.discard(x)移除不存在的元素2不会报错
setA.discard('2')
print('setA.discard(x)移除不存在的元素2不会报错：' , setA)
# setA.pop()每次移除的集合元素值不一样
setA.pop()
print('setA.pop()移除集合元素后为：' , setA)

setA.remove(x)移除集合元素： {'3', '2', '5', '4'}
setA.discard(x)移除集合元素： {'3', '5', '4'}
setA.discard(x)移除不存在的元素2不会报错： {'3', '5', '4'}
setA.pop()移除集合元素后为： {'5', '4'}

c、计算集合元素个数

len(setA)用于计算集合中元素个数

d、清空集合

setA.clear()

e、删除集合

del setA

f、判断元素是否存在于集合中

x in setA，判断元素 x 是否在集合 setA 中，存在返回 True，不存在返回 False

# 4、计算集合中长度
setA = {'1' , '2' , '3' , '4' , '5'}
print("集合setA中元素个数为：%d" % len(setA))

# 5、清空集合
setA = {'1' , '2' , '3' , '4' , '5'}
setA.clear()
print("setA.clear()清空集合setA后为：" , setA)

# 6、删除集合
del setA
print("del删除集合setA后为：" , setA)

# 7、判断元素是否在集合中
setA = {'1' , '2' , '3' , '4' , '5'}
print("'1'是否在集合setA中：" , '1' in setA)

3、集合内置方法

setA = {1 ,2 , 3, 4 ,5 , 6 ,7 ,8}

setB = {1 ,3, 5 , 7 ,8 ,9 , 10 ,11}

内置方法	说明	例子
set.add(x)	add(elmnt) 方法用于给集合添加元素，如果添加的元素在集合中已存在，则不执行任何操作 语法： set.add(elmnt) 参数： elmnt -- 必填，要添加的元素 注：set集合是hash存储(所以是无序的)，必须存储不变的对象，例如字符串、数字、元组等，不能储存字典、集合、列表	setA.add(9)返回：{1 ,2 , 3, 4 ,5 , 6 ,7 ,8 ,9} setA.add(8)返回：{1 ,2 , 3, 4 ,5 , 6 ,7 ,8 } setA.add('abcd')返回：{1 ,2 , 3, 4 ,5 , 6 ,7 ,8 , 'abcd' }
set.update(x)	update(x)用于修改set集合，可以添加新的元素(可以是字符串、元祖、列表、集合和字典)到当前集合中，如果添加的元素在集合中已存在，则重复的元素不会添加至集合中 语法： set.update(set) 参数： x -- 必需，可以是字符串、元祖、列表、集合和字典 注：update()不能添加数字，update(1)报错 注： set.update( {"字符串"} ) 将字符串整体添加到集合中，有重复的会忽略 set.update( "字符串" ) 将字符串拆分成单个字符后再一个个添加到集合中，有重复的会忽略	# 13、update(x)用于修改set集合，可以添加新的元素(可以是字符串、数字、元祖、列表、集合和字典)到当前集合中， # 如果添加的元素在集合中已存在，则重复的元素不会添加至集合中 # 添加字典时，仅添加key，不添加value setA = {1 , 2} str1 = 'Kobe' tup1 = (2 , 3 , 4) listA = [1 , 5 , 6] setB = {1 , 7 , 8 , 'NBA'} dictA = {'name':'Gavin'} setA.update(str1) print("update()添加字符串：" , setA) setA.update(tup1) print("update()添加元组：" , setA) setA.update(listA) print("update()添加列表：" , setA) setA.update(setB) print("update()添加集合：" , setA) setA.update(dictA) print("update()添加字典：" , setA) update()添加字符串： {1, 'o', 2, 'K', 'b', 'e'} update()添加元组： {1, 'o', 2, 3, 4, 'K', 'b', 'e'} update()添加列表： {1, 'o', 2, 3, 4, 5, 6, 'K', 'b', 'e'} update()添加集合： {1, 'o', 2, 3, 4, 5, 6, 8, 7, 'K', 'NBA', 'b', 'e'} update()添加字典： {1, 'o', 2, 3, 4, 5, 6, 8, 7, 'K', 'NBA', 'b', 'name', 'e'}
set.clear()	clear() 方法用于移除集合中的所有元素 语法： set.clear()	setA.clear()返回：set()
set.copy()	copy() 方法用于拷贝一个集合 语法：set.copy() 注：集合set的拷贝无浅拷贝、深拷贝的区别	# 3、set.copy()拷贝一个集合 setA = {1 ,2 , 3, 4 ,5 , 6 ,7 ,8 , ('a' , 'b')} # 浅拷贝 setC = copy.copy(setA) # 拷贝 setE = setA.copy() # 赋值 setB = setA # 深拷贝 setD = copy.deepcopy(setA) setA.add(9) print('更新setA元素后：' , setA) print('赋值setB：' , setB) print('浅拷贝setC：' , setC) print('深拷贝setD：' , setD) print('拷贝setE：' , setE) 更新setA元素后： {1, 2, 3, 4, 5, 6, 7, 8, 9, ('a', 'b')} 赋值setB： {1, 2, 3, 4, 5, 6, 7, 8, 9, ('a', 'b')} 浅拷贝setC： {1, 2, 3, 4, 5, 6, 7, 8, ('a', 'b')} 深拷贝setD： {1, 2, 3, 4, 5, 6, 7, 8, ('a', 'b')} 拷贝setE： {1, 2, 3, 4, 5, 6, 7, 8, ('a', 'b')}
set.difference(set1)	difference(set1) 方法用于返回集合的差集，即返回的集合元素包含在第一个集合set中，但不包含在第二个集合(方法的参数set1)中 语法： set.difference(set1) 参数： set1 -- 必需，用于计算差集的集合 返回值： 返回一个新的集合	setA = {1 ,2 , 3, 4 ,5 , 6 ,7 } setB = {1 ,3 , 5 , 7 ,8 ,9 , 10 ,11} print("输出包含在集合setA中，但不包含在setB中的集合：" , setA.difference(setB)) 输出包含在集合setA中，但不包含在setB中的集合： {2, 4, 6}
set.difference_update(set1)	difference_update(set1) 方法用于删除两个集合中都存在的元素 语法： set.difference_update(set1) 参数： set1 -- 必需，用于计算差集的集合 返回值： 无返回值	# 4、difference_update(set1) 方法用于删除两个集合中都存在的元素 setA = {1 ,2 , 3, 4 ,5 , 6 ,7 } setB = {1 ,3 , 5 , 7 ,8 ,9 , 10 ,11} setA.difference_update(setB) print("difference_update(set1) 方法删除两个集合中都存在的元素后剩余的集合setA为：" , setA) difference_update(set1) 方法删除两个集合中都存在的元素后剩余的集合setA为： {2, 4, 6}
set.discard(x)	discard() 方法用于移除指定的集合元素 语法： set.discard(value) 参数： value -- 必需，要移除的元素 注： discard()方法不同于 remove() 方法，remove() 方法在移除一个不存在的元素时会发生错误，而 discard() 方法不会	setA = {1 ,2 , 3, 4 ,5 , 6 ,7 } setA.discard(1) print("setA集合删除元素后为：" , setA) # 删除一个不存在的集合元素，不会报错 setA.discard(1) print("setA集合删除元素后为：" , setA) setA集合删除元素后为： {2, 3, 4, 5, 6, 7} setA集合删除元素后为： {2, 3, 4, 5, 6, 7}
set.intersection(set1)	intersection() 方法用于返回两个或更多集合的交集，返回一个新的集合 语法： set.intersection(set1, set2 ... etc) 参数： set1 -- 必需，要查找相同元素的集合 set2 -- 可选，其他要查找相同元素的集合，可以多个，多个使用逗号 , 隔开 返回值： 返回一个新的集合	# 6、set.intersection(set1 , set2 , ... etc )函数用于计算两个或多个集合的交集，返回一个新集合 setA = {1 ,2 , 3, 4 ,5 , 6 ,7 , 13} setB = {1 ,3 , 5 , 7 ,8 ,9 , 10 ,11} print("setA集合的内存地址为：" , id(setA) ) setA = setA.intersection(setB) print("setA和setB取交集后的新集合的内存地址为：" , id(setA) ) print("setA和setB取交集后的新集合setA为：" , setA ) setA集合的内存地址为： 2475811536008 setA和setB取交集后的新集合的内存地址为： 2475811976584 setA和setB取交集后的新集合setA为： {1, 3, 5, 7}
set.intersection_update(set1)	set.intersection_update(set1) 方法用于获取两个或更多集合中都重叠的元素，即计算交集。intersection() 方法是返回一个新的集合，而intersection_update()是在原有set集合的基础上返回交集，该函数无返回值 语法： set.intersection_update(set1, set2 ... etc) 参数： set1 -- 必需，要查找相同元素的集合 set2 -- 可选，其他要查找相同元素的集合，可以多个，多个使用逗号 , 隔开	# 7、set.intersection_update(set1 , set2 , ... etc )函数用于计算两个或多个集合的交集，在set集合的基础上返回一个集合 setA = {1 ,2 , 3, 4 ,5 , 6 ,7 , 13} setB = {1 ,3 , 5 , 7 ,8 ,9 , 10 ,11} print("setA集合的内存地址为：" , id(setA) ) setA.intersection_update(setB) print("setA和setB取交集后的新集合的内存地址为：" , id(setA) ) print("setA和setB取交集后的新集合setA为：" , setA ) setA集合的内存地址为： 1457543314568 setA和setB取交集后的新集合的内存地址为： 1457543314568 setA和setB取交集后的新集合setA为： {1, 3, 5, 7}
set.isdisjoint(set1)	isdisjoint() 方法用于判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False(这个逻辑有些变态...) 语法： set.isdisjoint(set1) 参数： set -- 必需，要比较的集合 返回值： 返回布尔值，如果不包含返回 True，否则返回 False	# 8、isdisjoint() 方法用于判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False setA = {1 ,2 , 3, 4 ,5 , 6 ,7 , 13} setB = {1 ,3 , 5 , 7 ,8 ,9 , 10 ,11} print("setA和setB集合中是否含有相同的元素，有返回False，没有的话返回True：" , setA.isdisjoint(setB)) setA和setB集合中是否含有相同的元素，有返回False，没有的话返回True： False
set.issubset(set1)	issubset() 方法用于判断集合set的所有元素是否都包含在指定集合set1中，如果是则返回 True，否则返回 False 语法： set.issubset(set1) 参数： set1 -- 必需，要比查找的集合 返回值： 返回布尔值，如果都包含返回 True，否则返回 False	# 9、issubset() 方法用于判断集合set的所有元素是否都包含在指定集合set1中，如果是则返回 True，否则返回 False setA = {1 ,2 , 3, 4 ,5 , 6 ,7 , 13} setB = {1 ,3 , 5 , 7 ,8 ,9 , 10 ,11} print("setA的所有元素是否均包含在setB集合中，是返回True，不是则返回False：" , setA.issubset(setB)) setA的所有元素是否均包含在setB集合中，是返回True，不是则返回False： False
set.issuperset(set1)	issuperset() 方法用于判断指定集合set1的所有元素是否都包含在原始的集合set中，如果是则返回 True，否则返回 False 语法： set.issuperset(set1) 参数： set -- 必需，要比查找的集合 返回值： 返回布尔值，如果都包含返回 True，否则返回 False	# 10、issuperset() 方法用于判断指定集合set1的所有元素是否都包含在原始的集合set中，如果是则返回 True，否则返回 False setA = {1 ,2 , 3, 4 ,5 , 6 ,7 , 13} setB = {1 ,3 , 5 , 7 ,8 ,9 , 10 ,11} print("issuperset()判断setA的所有元素是否均包含在setB集合中，是返回True，不是则返回False：" , setA.issuperset(setB)) issuperset()判断setA的所有元素是否均包含在setB集合中，是返回True，不是则返回False： False
set.symmetric_difference(set1)	set.symmetric_difference(set1)函数用于将集合set1和set合并，去除两个集合的交集部分，返回一个新集合 语法： set.symmetric_difference(set1) 参数： set -- 必需，要比查找的集合 返回值： 返回一个新集合	# 11、set.symmetric_difference(set1) 方法用于将set和set1合并，同时去除两者的交集部分，返回一个新的集合 setA = {1 ,2 , 3, 4 ,5 , 6 ,7 , 13} setB = {1 ,3 , 5 , 7 ,8 ,9 , 10 ,11} print("setA原来为：" , setA) print("setA原来的内存地址为：" , id(setA)) setA = setA.symmetric_difference(setB) print("set.symmetric_difference(set1) 方法用于将set和set1合并，同时去除两者的交集部分，返回一个新的集合" ,setA ) print("setA新的内存地址为：" , id(setA)) setA原来为： {1, 2, 3, 4, 5, 6, 7, 13} setA原来的内存地址为： 2314451614856 set.symmetric_difference(set1) 方法用于将set和set1合并，同时去除两者的交集部分，返回一个新的集合 {2, 4, 6, 8, 9, 10, 11, 13} setA新的内存地址为： 2314481153416
set.symmetric_difference_update(set1)	set.symmetric_difference(set1)函数用于将集合set1合并到set中，去除两个集合的交集部分，结果保留在set中，无返回值 语法： set.symmetric_difference_update(set1) 参数： set -- 要合并的集合	# 12、set.symmetric_difference_update(set1) 方法用于将set1合并到set中，去除两者的交集部分，结果保留在set集合中，无返回值 setA = {1 ,2 , 3, 4 ,5 , 6 ,7 , 13} setB = {1 ,3 , 5 , 7 ,8 ,9 , 10 ,11} print("setA原来为：" , setA) print("setA原来的内存地址为：" , id(setA)) setA.symmetric_difference_update(setB) print("set.symmetric_difference_update(set1) 方法用于将set和set1合并，同时去除两者的交集部分，返回一个新的集合" ,setA ) print("setA新的内存地址为：" , id(setA)) setA原来为： {1, 2, 3, 4, 5, 6, 7, 13} setA原来的内存地址为： 1995585860104 set.symmetric_difference_update(set1) 方法用于将set和set1合并，同时去除两者的交集部分，返回一个新的集合 {2, 4, 6, 8, 9, 10, 11, 13} setA新的内存地址为： 1995585860104
set.pop()	pop() 方法用于随机移除一个元素 语法： set.pop() 返回值： 返回删掉的元素 注： 当集合中元素是由字典、字符转换的集合时，删除是随机删除元素的；当集合中元素是由数字、列表、元组、集合组成时，set.pop()删除是从左边开始删除元素的	setA = {1 , 2 , 3 , 4} print("set.pop()删除的元素为：" , setA.pop()) print("set.pop()删除后的集合为：" , setA) set.pop()删除的元素为： 1 set.pop()删除后的集合为： {2, 3, 4} # 当集合中元素是由字典和字符(串)转换的集合时，删除是随机删除元素的； # 当集合中元素是由列表和元组组成时，set.pop()删除是从左边开始删除元素的 # 数字 setA = {1 , 2 , 3 , 4 , 5} # 列表 setC = set([1 , 2 , 3 , 4 , 5]) # 元组 setD = set((1 , 2 , 3 , 4 , 5)) # 字典 setE = set({'Kobe':24 , "Curry":"30" , "KD" :"7"}) # 字符串 setB = {"apple", "banana", "cherry"} # 集合 setF = set({"huawei", "oppo", "xiaomi"}) # 当集合中元素是由数字、列表、元组、集合组成时，set.pop()删除是从左边开始删除元素的 print("setA.pop()删除前为：" , setA) setA.pop() print("数字：setA.pop()删除后的为：" , setA) print("setC.pop()删除前为：" , setC) setC.pop() print("列表：setC.pop()删除后的为：" , setC) print("setD.pop()删除前为：" , setD) setD.pop() print("元组：setD.pop()删除后的为：" , setD) print("setF.pop()删除前为：" , setF) setF.pop() print("集合：setF.pop()删除后的为：" , setF) print("----------------分割线--------------------") # 当集合中元素是由字典、字符转换的集合时，删除是随机删除元素的 print("setE.pop()删除前为：" , setE) setE.pop() print("字典：setE.pop()删除后的为：" , setE) print("setB.pop()删除前为：" , setB) setB.pop() print("字符：setB.pop()删除后的为：" , setB) setA.pop()删除前为： {1, 2, 3, 4, 5} 数字：setA.pop()删除后的为： {2, 3, 4, 5} setC.pop()删除前为： {1, 2, 3, 4, 5} 列表：setC.pop()删除后的为： {2, 3, 4, 5} setD.pop()删除前为： {1, 2, 3, 4, 5} 元组：setD.pop()删除后的为： {2, 3, 4, 5} setF.pop()删除前为： {'xiaomi', 'huawei', 'oppo'} 集合：setF.pop()删除后的为： {'huawei', 'oppo'} ----------------分割线-------------------- setE.pop()删除前为： {'Kobe', 'Curry', 'KD'} 字典：setE.pop()删除后的为： {'Curry', 'KD'} setB.pop()删除前为： {'cherry', 'banana', 'apple'} 字符：setB.pop()删除后的为： {'banana', 'apple'} setA.pop()删除前为： {1, 2, 3, 4, 5} 数字：setA.pop()删除后的为： {2, 3, 4, 5} setC.pop()删除前为： {1, 2, 3, 4, 5} 列表：setC.pop()删除后的为： {2, 3, 4, 5} setD.pop()删除前为： {1, 2, 3, 4, 5} 元组：setD.pop()删除后的为： {2, 3, 4, 5} setF.pop()删除前为： {'xiaomi', 'huawei', 'oppo'} 集合：setF.pop()删除后的为： {'huawei', 'oppo'} ----------------分割线-------------------- setE.pop()删除前为： {'Curry', 'KD', 'Kobe'} 字典：setE.pop()删除后的为： {'KD', 'Kobe'} setB.pop()删除前为： {'apple', 'banana', 'cherry'} 字符：setB.pop()删除后的为： {'banana', 'cherry'}
set.remove(x)	set.remove(x)用于移除指定的元素，当元素不存在时，报错 语法： set.remove(x) 参数： x -- 要移除的元素	# 15、set.remove(x)用于移除指定的元素，当元素不存在时，报错；remove()函数无返回值 setA = {1 , 2 , 3 , 4 , 'name'} print("set.pop()删除元素name：" , setA.remove('name')) print("set.pop()删除name后的集合为：" , setA) set.pop()删除元素name： None set.pop()删除name后的集合为： {1, 2, 3, 4}
set.union(set1 , set2 , ... , etc)	set.union(set1,set2,...,etc)函数用于计算集合set和set1的并集，重复元素只保留一次 语法： set.union(set1 , set2 , ... , etc) 参数： set1 -- 必需，合并的目标集合 set2 -- 可选，其他要合并的集合，可以多个，多个使用逗号 , 隔开 返回值： 返回一个新集合(结果保留在set中，内存地址不变)	# 16、set.union(set1,set2,...,etc)函数用于计算集合set和set1的并集，重复元素只保留一次 setA = {1 ,2} setB = {1 ,2 , 3 , 4} setC = {2 , 4 , 6} print("setA并集前的内存地址为：" , id(setA)) print("并集后的集合为：" , setA.union(setB , setC)) print("setA并集后的内存地址为：" , id(setA)) setA并集前的内存地址为： 2845953358984 并集后的集合为： {1, 2, 3, 4, 6} setA并集后的内存地址为： 2845953358984