python之集合set

一、定义

集合是由不同元素组成，无序的，且元素必须是不可变的数据类型

1、不同元素组成：集合中有相同的元素会被去重；

s={1,2,3,5,3,'adb','a',(1,2),'a'}
print(s)
#输出结果为：{(1, 2), 1, 2, 3, 5, 'a', 'adb'} 其中int型数据3与str型数据‘a’被去重

2、元素没有顺序：定义的顺序与打印出来的顺序是不一致的；

从标题1中的代码可以看出定义的顺序和打印的顺序是不一致的；

3、集合中的元素不可变：不可变的数据类型有：str，int，tuple

二、集合的方法

1、add：添加

s = {1,2,3,4,5,6}
s.add('s')
s.add('3')
s.add(3)
print(s) #打印的结果为：{1, 2, 3, 4, 5, 6, 's', '3'}
#添加一个整型数字3的为什么没有打印出来：集合是有去重功能的，因为集合中有一个int类型的3，所以重新添加一个int类型的3，就被集合自动去重了；

2、clear：清除

s = {1,2,3,4,5,6}
s.add('s')
s.add('3')
s.add(3)
print(s) #打印的结果为：{1, 2, 3, 4, 5, 6, 's', '3'}
s.clear();
print(s)  #打印结果为：set()


# s = {}
# print(s,type(s)) #打印结果为：{} <class 'dict'>

 备注：为什么我将一个有元素的集合清空打印的结果与定义的空集合打印的结果不一样啊？

3、copy：拷贝

s = {1,2,3,4,5,6}
s1 = s.copy()
s2 = s.copy()
print(s1)   #{1, 2, 3, 4, 5, 6}
print(s2)  #{1, 2, 3, 4, 5, 6}

4、pop：删除，随机删除集合中的元素；

因为集合中元素是无序的，所以集合的pop删除功能只能是随机删除；

s = {1,'d',2, 3, 4, 5, 6,'s','a',(1,23,4)}
print(s)   #{1, 2, 3, 'd', 4, 5, 6, 's', 'a', (1, 23, 4)}
s.pop()
print(s) #{2, 3, 'd', 4, 5, 6, 's', 'a', (1, 23, 4)}

a、remove:指定参数删除，删除的元素不存在会报错

s = {1,'d',2, 3, 4, 5, 6,'s','a',(1,23,4)}
s.remove('a')
print(s)
# s.remove(s) #这样会报错KeyError: {'s', 1, 2, 3, 4, 5, 6, 'd', (1, 23, 4)}
# s.remove(s,1) #也会报错TypeError: remove() takes exactly one argument (2 given}

print(s)

b、discard：指定参数删除，删除的元素不存在不会报错

s = {1,'d',2, 3, 4, 5, 6,'s','a',(1,23,4)}
# s_dis = s.discard('adb')  #None
# s_dis1 = s.discard('d')  #输出结果为：None
s_dis2 = s.pop()   #输出结果为：d
print(s)
print(s_dis2)

备注：从代码中可以看出：

a、remove、discard指定删除的值赋值给一个变量，打印变量的值为：None，可知集合的这两个方法不能将指定删除的值输出出来；

b、pop方法可以将删除的值赋值为变量输出出来

三、集合关系运算交、差、并集

1、交集：将集合中的相同部分求出

a、采用for循环的方式

python_l = ['张三','李四','王麻子']
linux_l = ['张三','赵云','二道杠']
python_and_linux = []
for p_name in python_l:
    if p_name in linux_l:
        python_and_linux.append(p_name)
print(python_and_linux)

b、采用set中的intersection方法

python_l = ['张三','李四','王麻子']
linux_l = ['张三','赵云','二道杠']
#将列表python_l,linux_l转化为集合，再采用集合set内置的intersection方法；
p_n = set(python_l) 
l_n = set(linux_l)
print(p_n,l_n)
print(p_n.intersection(l_n)) # {'张三'}
print(p_n&l_n) #{'张三'}

2、并集：将两个集合的元素合并在一起；

python_l = ['张三','李四','王麻子']
linux_l = ['张三','赵云','二道杠']
p_n = set(python_l)
l_n = set(linux_l)
print(p_n.union(l_n))#{'张三', '赵云', '李四', '二道杠', '王麻子'}
print(p_n|l_n) #{'张三', '赵云', '李四', '二道杠', '王麻子'}

3、差集：将集合a中的不在集合b中的元素筛选出来

python_l = ['张三','李四','王麻子']
linux_l = ['张三','赵云','二道杠']
p_n = set(python_l)
l_n = set(linux_l)
print(p_n-l_n)#{'李四', '王麻子'}
print(p_n.difference(l_n))# {'李四', '王麻子'}
print(p_n) #{'张三', '李四', '王麻子'}
print(p_n.difference_update(l_n))#None
print(p_n) #{'李四', '王麻子'}

备注：difference方法将将集合a中的不在集合b中的元素筛选出来，并没有影响到集合a或者集合b的元素

difference_update方法将将集合a中的不在集合b中的元素筛选出来，并将结果更新到集合a中

4、交叉补集：symetric_difference：两个集合合并减去交集

python_l = ['张三','李四','王麻子']
linux_l = ['张三','赵云','二道杠']
p_n = set(python_l)
l_n = set(linux_l)
print(p_n.symmetric_difference(l_n)) #{'李四', '二道杠', '赵云', '王麻子'}

5、集合运算差集更新操作：difference_update

python_l = ['张三','李四','王麻子']
linux_l = ['张三','赵云','二道杠']
p_n = set(python_l)
l_n = set(linux_l)
p_l = p_n - l_n  #{'李四', '王麻子'}
p_l_li = list(p_l) # ['李四', '王麻子']
print(p_l)
print(p_l_li)
print(p_n)  #{'李四', '王麻子', '张三'}
p_n.difference_update(l_n)  #将集合p_n与l_n差集求出并将差集结果更新为p_n
print(p_n) #  {'李四', '王麻子'}  

6、集合运算交集更新操作：intersection_update

python_l = ['张三','李四','王麻子']
linux_l = ['张三','赵云','二道杠']
p_n = set(python_l)
l_n = set(linux_l)
p_n.intersection_update(l_n)
print(p_n)  #{'张三'}

7、isdisjoint：判断两个是否有交集；没有交集返回True；有交集返回False

python_l = ['李四','王五','赵六']
linux_l = ['张三','赵云','二道杠']
p_l = set(python_l)
l_l =  set(linux_l)
a = p_l.isdisjoint(linux_l) # True
print(a)

8、issuperset：判断集合a是否是集合b的父集合；如果是则为True；如果否则为False

python_l = ['李四','王五','赵六']
linux_l = ['张三','赵云','二道杠']
p_l = set(python_l)
l_l =  set(linux_l)
print(p_l.issuperset(l_l) #False

9、issubset：半段集合a是否是集合b的子集合；如果是则为True；如果否则为False

python_l = ['李四','王五','赵六']
linux_l = ['张三','赵云','二道杠']
p_l = set(python_l)
l_l =  set(linux_l)
python_linux_l = p_l&l_l
print(p_l.issubset(l_l))  #False
print(python_linux_l.issubset(l_l)) #True

10、update：更新多个值

　　add：增加一个值

linux_l = {'张三','赵云','二道杠'}
#add()只能添加一个值，而在下面的add()方法中添加了两个值
# linux_l.add('李四','钱六')  #TypeError: add() takes exactly one argument (2 given)
#下面添加的是一个值为元组（'李四','钱六'）
linux_l.add(('李四','钱六'))  #{'张三', '赵云', ('李四', '钱六'), '二道杠'}
print(linux_l)

python_l = {'李四','王五','赵六'}
linux_l = {'张三','赵云','二道杠'}
#将元素拆分成一个一个添加进来
# linux_l.update('李四','钱六') #{'二道杠', '四', '张三', '钱', '赵云', '六', '李'}
python_l.update(['李四','钱六'])
# python_l.update(linux_l) #{'赵云', '二道杠', '王五', '赵六', '张三', '李四'}
print(python_l)  #{'王五', '赵六', '李四', '钱六'}

四、集合set补充

1、frozenset()定义不可变集合，将列表转换为不可变集合后，不可变集合就没有add、update、pop等方法

python_l = ['李四', '王五', '赵六']
p_l = frozenset(python_l)
#提示的是forzenset对象没有add方法
# p_l.add({'adb','王麻子'})  #AttributeError: 'frozenset' object has no attribute 'add'
p_l.pop() #AttributeError: 'frozenset' object has no attribute 'pop'
print(p_l)

2、对列表list进行去重处理

python_l =  ['张三','李四','王麻子','李四']
#列表python_l有重复元素
print(python_l)  #['张三', '李四', '王麻子', '李四']
#先将list转换为集合，利用的集合的去重特点将集合中的重复元素去掉，再讲集合转换为列表
names = list(set(python_l)) #['张三', '王麻子', '李四']
print(names)