Python集合学习笔记

1. 集合的简介与创建

集合（set）是一个无序的(字典也是无序的)不重复元素序列，其基本功能有：

• 将有重复元素的列表或元组等数据类型去重转变为集合
• 测试两组集合数据之间的交集、并集与差集等数据关系

• 集合的创建（集合特点：无序不重复）

# 空集合的创建
# 空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
a = set()
b = {}
print(type(a),type(b))

<class 'set'> <class 'dict'>

# 正常新建集合,有重复值则自动去重
set1 = {1,2,3,3,4,5,2}
set1

{1, 2, 3, 4, 5}

列表、元组转为集合

• 在列表在嵌套中转为集合会报错，元组在嵌套中不会改变，也不会去重

lst = ['a','b','a','a',1,2,True]
tup = (3,4,2,'b','a','a',1,2,True)
set_lst = set(lst)
set_tup = set(tup)
print(set_lst,type(lst),type(set_lst))
print(set_tup,type(tup),type(set_tup))

{1, 2, 'b', 'a'} <class 'list'> <class 'set'>
{1, 2, 3, 4, 'b', 'a'} <class 'tuple'> <class 'set'>

# 字符串也可以通过set 变为集合
a = 'string'
set(a)

{'g', 'i', 'n', 'r', 's', 't'}

# 对于嵌套列表，转为集合则会报错
lst = [1,2,[3,4,2],4]
set(lst)

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-13-a88772bd2e1f> in <module>()
      1 # 对于嵌套列表，转为集合则会报错
      2 lst = [1,2,[3,4,2],4]
----> 3 set(lst)


TypeError: unhashable type: 'list'

# 对于嵌套原组，转为集合时嵌套的元组会保持不变，也不会去重
tup = ('a',2,(3,'a',3,2,2),4,2)
set(tup)

{(3, 'a', 3, 2, 2), 2, 4, 'a'}

# 对于元组含有列表不可变为集合
lst = (1,2,[3,4,2],4)
set(lst)

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-21-1876a639285b> in <module>()
      1 lst = (1,2,[3,4,2],4)
----> 2 set(lst)


TypeError: unhashable type: 'list'

# 列表含有集合可变为元组
lst = [1,2,(3,4,2),4]
set(lst)

{(3, 4, 2), 1, 2, 4}

字典转为集合(实质上也是通过列表元组转为集合的)

dic = {'a':1,'b':2,'c':(3,4)}
set(dic.values())

{(3, 4), 1, 2}

2. 集合的基本操作

2.1 集合的增删

集合的增

• set.add(x)，将x(只能是单个值如：字符串、数值、布尔值等)添加在集合中，如果元素存在，则不进行任何操作
• set.update(x)，x可以是列表元组字典等，x也可以是多个，用’,'隔开，如set.update(x1,x2)

set1 = {'a','b'}
set1.add(None)
set1

{None, 'a', 'b'}

set_1 = {2,4}
lst = {'a','b'}
tup = (3,4)
set_1.update(lst,tup)
set_1

{2, 3, 4, 'a', 'b'}

集合的删

• set.remove(x)将元素x从集合中移除，如果元素不存在，则会发生错误
• set.discard(x)将元素x从集合中移除，元素不存在，不会发生错误
• set.pop()随机删除集合中的一个元素，同时可以用变量来接收随机删除的值
• set.clear()清空集合

BookName = {'marh','English'}
BookName.remove('English')
BookName

{'marh'}

BookName = {'marh','English'}
BookName.remove('Chinese')

---------------------------------------------------------------------------

KeyError                                  Traceback (most recent call last)

<ipython-input-40-4128c3d1b7d0> in <module>()
      1 BookName = {'marh','English'}
----> 2 BookName.remove('Chinese')


KeyError: 'Chinese'

BookName = {'marh','English'}
BookName.discard('English')
BookName

{'marh'}

BookName = {'marh','English'}
BookName.discard('Chinese')
BookName

{'English', 'marh'}

BookName = {'marh','English','Chinese','1','2'}
a = BookName.pop()
print(a,BookName)

1 {'Chinese', 'marh', 'English', '2'}

集合的 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。

BookName = {'marh','English','Chinese','1','2'}
a = BookName.pop()
print(a,BookName)
b = BookName.pop()
print(b,BookName)

1 {'Chinese', 'marh', 'English', '2'}
Chinese {'marh', 'English', '2'}

BookName = {'marh','English','Chinese','1','2'}
BookName.clear()
BookName

set()

集合无改和查，因为是无序的特性

2.2 集合常用方法

集合与列表、元组等类似

• len(set)查询集合元素的个数
• x in set判断元素x是否在集合中
• for 来遍历集合

set1 = {'a','b',(2,3)}
len(set1)

3

set1 = {'a','b',(2,3)}
(2,3) in set1

True

set1 = {'a','b',(2,3)}
for i in set1:
    print(i,end='\t')

(2, 3)	b	a	

集合的复制

s = {2,3,True}
c = s.copy()
print(s,c)

{True, 2, 3} {True, 2, 3}

判断是否 s 中的每一个元素都在 t 中

s = {'a','b','c'}
t = {'b','c','d'}
a = s.issubset(t)
b = (s <= t)
print(a,b)

False False

判断是否 t 中的每一个元素都在 s 中

s = {'a','b','c'}
t = {'b','c','d'}
a = s.issuperset(t)
b = (s >= t)
print(a,b)

False False

2.3 集合运算

2.3.1 并集相关运算

返回一个新的set包含s和t中的每一个元素

# t 和 s的并集
s = {'a','b','c'}
t = {'b','c','d'}
print(s.union(t),t | s )

{'c', 'b', 'd', 'a'} {'c', 'b', 'd', 'a'}

返回两集合的并集

s = {'a','b','c'}
t = {'b','c','d'}
s.update(t)
print(s,t)

s = {'a','b','c'}
t = {'b','c','d'}
s |= t
print(s,t)

{'c', 'b', 'd', 'a'} {'c', 'd', 'b'}
{'c', 'b', 'd', 'a'} {'c', 'd', 'b'}

2.3.2 交集相关运算

返回一个新的 set 包含 s 和 t 中的公共元素

# t 和 s的交集
s = {'a','b','c'}
t = {'b','c','d'}
print(s.intersection(t),t & s)

{'c', 'b'} {'c', 'b'}

返回两集合的公共部分

s = {'a','b','c'}
t = {'b','c','d'}
s.intersection_update(t)
print(s,t)

s = {'a','b','c'}
t = {'b','c','d'}
s &= t
print(s,t)

{'c', 'b'} {'c', 'd', 'b'}
{'c', 'b'} {'c', 'd', 'b'}

2.3.3 差集相关运算

返回一个新的 set 包含 s 中有但是 t 中没有的元素

# 求差集（项在t中，但不在s中）
s = {'a','b','c'}
t = {'b','c','d'}
print(t.difference(s),t - s )

{'d'} {'d'}

返回s集合中在t集合中没有的元素

s = {'a','b','c'}
t = {'b','c','d'}
s.difference_update(t)
print(s,t)

s = {'a','b','c'}
t = {'b','c','d'}
s -= t
print(s,t)

{'a'} {'c', 'd', 'b'}
{'a'} {'c', 'd', 'b'}

2.3.4 对称差集相关运算

返回一个新的集合包含s和t中不重复的元素

s = {'a','b','c'}
t = {'b','c','d'}
print(s.symmetric_difference(t),t ^ s )

{'d', 'a'} {'d', 'a'}

返回两集合非公共的部分

s = {'a','b','c'}
t = {'b','c','d'}
s.symmetric_difference_update(t)
print(s,t)

s = {'a','b','c'}
t = {'b','c','d'}
s ^= t
print(s,t)

{'d', 'a'} {'c', 'd', 'b'}
{'d', 'a'} {'c', 'd', 'b'}

3. 集合的简单应用

去掉列表中的重合的元素

a = [1,2,3,4,2,3,2,4,2,1]
b = set(a)
c = [i for i in b]
print(a,type(a),'\n',b,type(b),'\n',c,type(c))

[1, 2, 3, 4, 2, 3, 2, 4, 2, 1] <class 'list'> 
 {1, 2, 3, 4} <class 'set'> 
 [1, 2, 3, 4] <class 'list'>

---

【参考链接一】

【参考链接二】