Python——集合

集合

1.定义：

        ①不同元素组成；②无序；③集合中元素必须是不可变类型

2.定义集合的两种方法：

       方法一：set()方法
       方法二：{}方法

3.举例：

（1）集合中元素为字符串时：两种方法都适用

#字符串
s=set('123456')
print(s)
#{'4', '5', '6', '2', '1', '3'}

s={'Alice','Bob','Candy'}
print(s)
#{'Alice', 'Candy', 'Bob'}等价于--->
s=set(['Alice','Bob','Candy'])
print(s)
#{'Alice', 'Candy', 'Bob'}

（2）集合中元素为数字时：只有{}方法适用

#数字
s={1,2,3,4,5,6}
print(s)
#{1, 2, 3, 4, 5, 6}

   而 set() 方法报错

'''
s=set(1)
print(s)
#报错'''

（3）集合中元素为列表时：只有set() 方法适用

#列表
s=set(['Alice','Bob',123])
print(s)
#{'Alice', 123, 'Bob'}

   而 {} 方法报错

'''
s={[123,456],[456,113]}
print(s)
#报错'''

4.对集合 s 进行添加、删除操作：

（1）添加—— s.add()

#添加
s={1,2,3,4,5,6,7}
#①添加字符串
s.add('s')
print(s)
#{1, 2, 3, 4, 5, 6, 7, 's'}

s={1,2,3,4,5,6,7}
s.add('3')
print(s)
{1, 2, 3, 4, 5, 6, 7, '3'}

#①添加集合中已经存在的数字
s={1,2,3,4,5,6,7}
s.add(3)
print(s)
#{1, 2, 3, 4, 5, 6, 7}

（2）删除：

随机删除：s.pop()
指定删除：s.remove()
指定删除元素在集合中不存在会报错：s.remove()
指定删除元素在集合中不存在但不会报错：s.discard()

#删除
s={'sb',1,2,3,4,5,6}
#①随机删
s.pop()
print(s)
#{2, 3, 4, 5, 6, 'sb'}

s={'sb',1,2,3,4,5,6}
#②指定删除
s.remove('sb')
print(s)
#{1, 2, 3, 4, 5, 6}

'''s={'sb',1,2,3,4,5,6}
#②删除元素不存在会报错
s.remove('hellol')
print(s)
#报错'''

s={'sb',1,2,3,4,5,6}
#②删除元素不存在不会报错
s.discard('sbbbb')
print(s)
#{1, 2, 3, 4, 5, 6}

5.集合的关系运算——交、并、差集：

引入：

python_l=['lcg','szw','zjw','lcg']
linux_l=['lcg','szw','sb']
python_and_linux_l=[]
for p_name in python_l:
    if p_name in linux_l:
        python_and_linux_l.append(p_name)
print(python_and_linux_l)
#['lcg', 'szw', 'lcg']  有重复元素出现

利用集合来求解：（已知两个集合 p_s 和 l_s ）
交集：p_s.intersection(l_s)           或          p_s&l_s
并集：p_s.union(l_s)                      或          p_s | l_s
差集：p_s.difference(l_s)               或          p_s - l_s
           l_s.difference(p_s)               或          l_s - p_s
交叉补集：p_s.symmetric_difference(l_s)               或          p_s^l_s

python_l=['lcg','szw','zjw','lcg']
linux_l=['lcg','szw','sb']
#集合可以用来去重，只是得到的结果时无序的
p_s=set(python_l)
l_s=set(linux_l)
print(p_s,l_s)
#{'zjw', 'szw', 'lcg'} {'szw', 'sb', 'lcg'}

# 求交集
print(p_s.intersection(l_s))
print(p_s&l_s)
#{'lcg', 'szw'}

# 求并集
print(p_s.union(l_s))
print(p_s|l_s)
#{'szw', 'lcg', 'zjw', 'sb'}

# 求差集
print(p_s-l_s)
print(p_s.difference(l_s))
print(l_s-p_s)
print(l_s.difference(p_s))
#{'sb'}

# 交叉补集
print(p_s.symmetric_difference(l_s))
print(p_s^l_s)
#{'zjw', 'sb'}

注——其他用法：
①p_s=p_s-l_s    后得到的p_s 等价于    p_s.difference_update(l_s)

python_l=['lcg','szw','zjw','lcg']
linux_l=['lcg','szw','sb']
p_s=set(python_l)
l_s=set(linux_l)
print(p_s,l_s)
#{'zjw', 'lcg', 'szw'} {'sb', 'lcg', 'szw'}
print('差集',p_s-l_s)
#差集 {'zjw'}
print(p_s)
#{'zjw', 'szw', 'lcg'}  此时并没有改变p_s的值

python_l=['lcg','szw','zjw','lcg']
linux_l=['lcg','szw','sb']
p_s=set(python_l)
l_s=set(linux_l)
print(p_s,l_s)
#{'zjw', 'lcg', 'szw'} {'sb', 'lcg', 'szw'}
p_s=p_s-l_s
print('差集',p_s)
#差集 {'zjw'}
print(p_s)
#{'zjw'}  此时已经改变了p_s的值

同理，使用 p_s.difference_update(l_s)

python_l=['lcg','szw','zjw','lcg']
linux_l=['lcg','szw','sb']
p_s=set(python_l)
l_s=set(linux_l)
print(p_s,l_s)
#{'zjw', 'lcg', 'szw'} {'sb', 'lcg', 'szw'}
p_s.difference_update(l_s)
print('差集',p_s)
#差集 {'zjw'}
print(p_s)
#{'zjw'}  此时已经改变了p_s的值

②父、子集（已知两个集合s1和s2）
s1 是s2 的子集：s1.issubset(s2)
s1 是s2 的父集：s2.issuperset(s1)

s1={1,2}
s2={1,2,3}
print(s1.issubset(s2))#s1 是s2 的子集
# True
print(s2.issubset(s1))
# False
print(s2.issuperset(s1))#s1 是s2 的父集
# True

③s1和s2是否交集：s1.isdisjoint(s2)

#s1和s2没有交集时,为True
s1={1,2}
s2={3,5}
print(s1.isdisjoint(s2))
#True

#s1和s2有交集时,为False
s1={1,2}
s2={2,3,5}
print(s1.isdisjoint(s2))
#False

④s1.add   与   s1.union   与   s1.update的区别

原始：

s1={1,2}
s2={1,2,3}
print(s1)
#{1, 2}

使用    s1.add

s1={1,2}
s2={1,2,3}
s1.add(1,2,3,4) 
print(s1)
#报错，s.add()只能一次添加一个值

使用    s1.union

s1={1,2}
s2={1,2,3}
s1.union(s2)  #union只是求了一个并集，但并未给s1
print(s1)
#{1, 2}

使用    s1.update
该方法可以更新多个值（插入集合，列表，元组）

s1={1,2}
s2={1,2,3}
s1.update(s2)
print(s1)
#{1, 2, 3}

s1={1,2}
#插入列表
s1.update((3,4,5))
print(s1)
#{1, 2, 3, 4, 5}

s1={1,2}
#插入元组
s1.update(['Alice',4,5])
print(s1)
#{1, 2, 4, 5, 'Alice'}

补充：
（1）集合属于可变类型，但 frozenset() 方法可以定义不可变集合，该不可变集合没有添加以及删除方法了

s=frozenset('hello')
print(s)
#frozenset({'l', 'h', 'e', 'o'})

（2）使用集合对列表做简单去重

#在不考虑顺序的前提下对列表只做简单去重
names=['alex','alex','wupeiqi','Candy']
names=list(set(names))
print(names)
#['wupeiqi', 'Candy', 'alex']

6.总结：

       本章主要讲了Python中集合的操作，集合是可变类型，但可以通过frozenset() 方法让其变为不可变类型，上述文章对集合进行了添加 add()  和删除 pop() , remove() , discard() 操作，关系运算，有 &，|，-，^。