Python-集合

Python-集合

1. 集合的概述
   1. Python集合的优势
2. 集合的概述与创建
3. 集合的相关操作
4. 集合的删除操作
5. 集合的关系
6. 集合生成式

---

1.集合的概述

集合的定义

1. Python语言提供的内置数据结构
2. 与列表、字典一样都属于可变类型的序列
3. 集合是没有value的字典       

      

注意：

1. 创建一个空集合必须用set()，而不是{}，因为{}是用来创建一个空字典
2. 集合的元素有数字，字符，元组组成；集合、列表，字典都不能称为集合的元素
3. 集合的元素是唯一的，不重复的

1.1Python集合的优势

由于集合中的元素不能出现多次，这使得集合在很大程度上能够高效地从列表或元组中删除重复值，并执行取并集、交集等常见的的数学操作。

本教程将向你介绍一些关于 Python 集合和集合论的话题：

如何初始化空集和带有数值的集合

如何向集合中添加值或者从集合中删除值

如何高效地使用集合，用于成员检测、从列表中删除重复值等任务。

如何执行常见的集合操作，例如求并集、交集、差集以及对称差。

可变集合和不可变集之间的区别

2.集合的创建形式：

           可以使用大括号{}或者使用内置函数set（）创建集合

代码演示：

'''第一种创建方式使用：{}'''
s={'I','love','Python'}
print(s)
print(type(s))


'''第二种创建的方式使用set（）'''
s1=set{'人生苦短，我用Python'}
print(s1)
print(type(s1))



s=set(range(6))
print(s,type(s))
s1=set([1,2,3,4,5,6,7,77,7,7,8,10,9,])      #将列表当中的元素转换成集合，去除重复元素
print(s1,type(s1))

s3=set((1,2,3,4,5,6,7,543))                 #将元组中的元素转换成集合，去除重复元素，集合中的元素是无序的
print(s3,type(s3))

s4=set('Python')                            #将字符串转换成集合，集合是无序的
print(s4,type(s4))

s5=set({12,543,5657,8,9,9,75,43,5})        #将字典转换成集合
print(s5,type(s5))

#定义空集合
s6={}               #这样子书写表示的是字典类型
print(s6,type(s6))

#使用以下方式定义空集合
s7=set({})          #这样子书写是表示空集合
print(s7,type(s7))

 

 

结果为：

{'I','love','Python'}
<class 'set'>


{'h', 'y', '短', '我', '用', 't', 'o', 'n', '苦', '，', '生', 'P', '人'}
<class 'set'>



{0, 1, 2, 3, 4, 5} <class 'set'>
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 77} <class 'set'>
{1, 2, 3, 4, 5, 6, 7, 543} <class 'set'>
{'h', 't', 'o', 'n', 'P', 'y'} <class 'set'>
{5, 8, 9, 75, 12, 43, 5657, 543} <class 'set'>
{} <class 'dict'>
set() <class 'set'>

 3.集合的相关操作

1. 集合元素的判断操
   1. in 或  not  in            
2. 集合元素的新增操作
   1. 调用add（）方法，一次只能添加一个元素
   2. 调用update（）方法，一次至少添加一个元素

代码演示：

#集合元素的判断操作
s={10,20,30,40,50,60,70}
print(10 in s)          #True
print(100 in s)         #False
print(9 not in s )      #True
print(100 not in s)     #True


#集合元素的新增操作
'''调用add（）方法,一次添加一个元素'''
a={10,435,745,7,8,8,6}
a.add(200)
print(a)

'''调用update()方法，至少一次添加一个元素'''
b={10,20,30,40,50,60,70}
b.update({100,200,300})         #批量添加元素添加到集合
print(b,type(b))
b.update([100,99,1000])         #批量添加元组元素
b.update((78,123,456,678))      #批量添加字典元素
print(b)

结果为：

True
False
True
True
{6, 7, 8, 745, 10, 200, 435}
{100, 70, 40, 200, 10, 300, 50, 20, 60, 30} <class 'set'>
{99, 100, 70, 678, 40, 200, 10, 1000, 300, 456, 78, 50, 20, 123, 60, 30}

4.集合删除的操作

1. remove（）方法
2. discard（）方法
3. pop（）方法
4. clear（）方法

'''调用remove（）方法，一次删除一个指定元素，如果指定的元素不存在就会报错：KeyError: 'manba'''''
c={123,'asd','fdhgfgh',200,'gewgf','fjwehui',123}
c.remove('asd')
#c.remove('manba')       #当集合中不存的话，就会提示以下错误：KeyError: 'manba'
print(c)
'''#调用discard（）方法，一次删除一个指定元素，如果指定的元素不存在不会报错，不会有任何的异常、'''
c.discard('manba')
print(c)
'''调用pop（）方法，一次只删除一个任意元素'''
print('原集合:',c)
c.pop()         #pop()：括号里面不跟参数，跟了参数会报错，提示该函数里面是没有参数
'''pop()：表示删除最前面的那个元素[第一个]'''
print('删除之后的集合',c)

'''clear（）方法，是删除整个集合'''
c.clear()       #删除整个集合
print(c)

结果为：

{'fjwehui', 'fdhgfgh', 200, 'gewgf', 123}
{'fjwehui', 'fdhgfgh', 200, 'gewgf', 123}
原集合: {'fjwehui', 'fdhgfgh', 200, 'gewgf', 123}
删除之后的集合 {'fdhgfgh', 200, 'gewgf', 123}
set()

5.集合的关系

1. 并集：union或|
2. 交集：intersection或&
3. 差集：difference
4. 对等差分（并集-交集）：sysmmetric_difference或^
5. 判断超集：issuperset
6. 判断子集：issubset
7. 判断两个集合是不是不相交：isdisjoint

代码演示：

'''集合的关系'''
'''并集：union或|'''
print('并集：',s1.union(s2))
print('并集：',s1 | s2)

'''交集：intersection或&'''
print('交集：',s1.intersection(s2))
print('交集：',s1 & s2)

'''差集：difference'''
print('差集：',s1.difference(s2))     #差集是去除公共不存，比较两个集合之间的不同，并打印出来，S1.difference（s2）:表示S1中减去（s1和S2）的所有集合进行减法
print('差集：',s2.difference(s1))

'''对等差分（并集-交集）：sysmmetric_difference或^'''
s10={1,2,3,4,5}
s11={2,3,4}
print('对等差分：',s2.symmetric_difference(s1))
print('对等差分：',s1^s2)

'''判断超集：issuperset'''
s13={1,2,3}
s15={1,2,3}
s14={2,3,4,5,6}
print('超集：',s13.issuperset(s14))        #False
print('超集：',s14.issuperset(s13))        #False
print('超集：',s13.issuperset(s15))        #True

'''判断子集：issubset'''
a={1,2,3,4,5}
b={2,3,4,5,6,7}
c={1,2,3,4,5}
print('判断子集：',a.issuperset(b))          #False
print('判断子集：',b.issuperset(a))          #False
print('判断子集：',c.issuperset(a))          #True

'''
判断两个集合是不是不相交：isdisjoint
    注意：isdisjoint()用来判断两个集合是否包含相同元素，没有返回True，否则返回False
'''
c={1,2}
a={5,6,7,8,9}
d={1,2,3}
print(a.isdisjoint(d))      #False
print(d.isdisjoint(c))      #False
print(c.isdisjoint(a))      #c和a进行对比，没有包含相同元素，所以输出的是True

结果为：

并集： {40, 10, 50, 20, 90, 60, 30}
并集： {40, 10, 50, 20, 90, 60, 30}
交集： {40, 50, 60, 30}
交集： {40, 50, 60, 30}
差集： {10, 20}
差集： {90}
对等差分： {20, 90, 10}
对等差分： {10, 20, 90}
超集： False
超集： False
超集： True
判断子集： False
判断子集： False
判断子集： True
True
False
True

6.集合生成式

代码演示:

#列表生成式
lst=[i*i for i in range(10)]
print(lst)

#集合生成式
s={i*i for i in range(10)}
print(s))

结果为：

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
{0, 1, 64, 4, 36, 9, 16, 49, 81, 25}

总结：