集合

集合：
set是Python中一种基本数据类型，它分为可变集合（set）和不可变集合（frozenset）两种。类似于其他语言，集合是一个无序不重复元素集，包括创建集合set、向集合中添加元素、删除集合中的元素、求集合的交集、并集、差集等操作。

可变集合：
set集合类需要的参数必须是迭代器类型的，如：序列、字典等，然后转换成无序不重复的元素集。由于集合是不重复的，所以可以对字符串、列表、元组进行去重操作。

不可变集合：
集合中的元素不可以被改变，不能做插入和删除操作，其他方法和可变集合基本相同。

创建空的集合

s=set()
print(s)
set()

s=set([])
print(s)
set()

s=set(())
print(s)
set()

集合中set括号中需要的参数的数据类型有：序列（包括字符串、列表、元组），字典可以转为集合，注意数值类型不能作为集合的参数，如int类型。

s = set(‘createSet’)
print(s)
{‘c’, ‘S’, ‘a’, ‘t’, ‘e’, ‘r’}

s1 = set([1,2,3,1,3,4,5])
print(s1)
{1, 2, 3, 4, 5}

s2 = set((1,2,3,4,1))
print(s2)
{1, 2, 3, 4}

s = 2
s=set(2) #数值类型不能作为集合的参数，如int类型。
Traceback (most recent call last):
File “”, line 1, in
TypeError: ‘int’ object is not iterable

s3 = set({1:2,2:3}) #注意：字典转set集合，需要注意的是，只取了字典的key，相当于将字典中的dict.keys()列表转成set集合。
print(s3)
{1, 2}

st = set([2, 1, 3, 4, 5, 1, 12])
ss = set(st) #set集合做参数
print(ss)
{1, 2, 3, 4, 5, 12}

集合的添加有两种方式，分别是add和update。但是它们在添加元素时是有区别的。
add()方法是将要添加的元素作为一个整体添加到集合中。
update()方法是把要传入的元素拆分成单个字符，存于集合中，并去掉重复的

s1=set(‘one’)
s1
{‘e’, ‘o’, ‘n’}

s1.add(‘two’) #将要添加的元素作为一个整体添加到集合中
s1
{‘e’, ‘o’, ‘two’, ‘n’}

s2=set(‘one’)
s2
{‘e’, ‘o’, ‘n’}

s2.update(‘two’) #把要传入的元素拆分成单个字符，存于集合中，并去掉重复的
s2
{‘w’, ‘n’, ‘e’, ‘t’, ‘o’}

集合的删除操作使用的方法跟列表是一样的，使用的也是remove方法。

s3=set(‘hello’)
s3
{‘e’, ‘l’, ‘o’, ‘h’}

s3.remove(‘o’)
s3
{‘e’, ‘l’, ‘h’}

s4=set(‘ooa’)
s4
{‘o’, ‘a’}

type(s4)
<class ‘set’>

s4={‘o’,‘o’,‘a’} #规定集合是一个无序不重复元素集，不过这样子写它的类型也还是set
type(s4)
<class ‘set’>

s4.remove(‘o’) #会删除所有的
s4
{‘a’}

对集合进行遍历：

sTest = set([‘e’, ‘two’, ‘o’, ‘n’, ‘1’, ‘3’, ‘2’])
sTest
{‘2’, ‘n’, ‘e’, ‘two’, ‘o’, ‘3’, ‘1’}

for i in sTest:
… print(i)
…
2
n
e
two
o
3
1

sTest = set([‘e’, ‘two’, ‘o’, ‘n’, ‘1’, ‘3’, ‘2’])
sTest
{‘2’, ‘n’, ‘e’, ‘two’, ‘o’, ‘3’, ‘1’}

for index, elem in enumerate(sTest) :
… print (“元素的索引号为：”, index, “对应的元素为：”, elem)
…
元素的索引号为： 0 对应的元素为： 2
元素的索引号为： 1 对应的元素为： n
元素的索引号为： 2 对应的元素为： e
元素的索引号为： 3 对应的元素为： two
元素的索引号为： 4 对应的元素为： o
元素的索引号为： 5 对应的元素为： 3
元素的索引号为： 6 对应的元素为： 1

sTest[0]
Traceback (most recent call last):
File “”, line 1, in
TypeError: ‘set’ object does not support indexing

注：enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中
使用 enumerate() 方法的实例：

seasons = [‘Spring’, ‘Summer’, ‘Fall’, ‘Winter’]
list(enumerate(seasons))
[(0, ‘Spring’), (1, ‘Summer’), (2, ‘Fall’), (3, ‘Winter’)]

list(enumerate(seasons, start=1))
[(1, ‘Spring’), (2, ‘Summer’), (3, ‘Fall’), (4, ‘Winter’)]

seq = [‘one’, ‘two’, ‘three’]
enumerate(seq) #是一个迭代器
<enumerate object at 0x02D59D78>

for i, element in enumerate(seq):
… print(i, element)
…
0 one
1 two
2 three

集合和序列之间的转换跟序列之间互转是一样的，唯一不同的就是序列转成集合后，重复的元素被去掉了

集合与字符串互转

testStr = ‘python is good’
st=set(testStr) #会除去重复的单词
st
{‘s’, ‘h’, ‘n’, ‘p’, ‘d’, ‘t’, ‘i’, ‘o’, ‘y’, ’ ', ‘g’}

str1=str(st) #直接使用str()函数进行转换，得到的将是集合的字符串形式
str1
“{‘s’, ‘h’, ‘n’, ‘p’, ‘d’, ‘t’, ‘i’, ‘o’, ‘y’, ’ ', ‘g’}”

str2="".join(st) #借助join()函数完成真正转换成字符串
str2
‘shnpdtioy g’

集合与列表互转

listTest = [1, 2, 3, 2, ‘a’, ‘b’]
s1=set(listTest) #会对列表中重复的元素去重
s1
{1, 2, 3, ‘b’, ‘a’}

l1=list(s1)
l1
[1, 2, 3, ‘b’, ‘a’]

集合与元组互转

tupTest = (1, 2, 3, 2, ‘a’, ‘b’, ‘a’)
s1=set(tupTest) #会对元组中重复的元素去重
s1
{1, 2, 3, ‘b’, ‘a’}

t1=tuple(s1)
t1
(1, 2, 3, ‘b’, ‘a’)

集合函数：
1）查找元素并删除，discard()函数
函数原型：
setVar.discard(element)
参数说明：
setVar :为一个set类型的变量
element :表示要查找并删除的元素
函数作用：
在集合setVar中查找element元素，如果存在则删除；如果没找到，则什么也不做。该函数没有返回值

sList = set([1, 2, 3, 4, 5])
sList
{1, 2, 3, 4, 5}

sList.discard(1)
sList
{2, 3, 4, 5}

sList.discard(1)
sList
{2, 3, 4, 5}

b=sList.discard(2) #该函数没有返回值
b

sList
{3, 4, 5}

2）pop函数
函数原型：
s.pop()
参数说明：
s：为set类型的变量
函数作用：
删除并返回集合s中的第一个元素，如果为空引发KeyError错误

sList = set([1, 2, 3, 4, 5])
element = sList.pop()
element
1

sList
{2, 3, 4, 5}

element2=sList.pop(1) #没有参数
Traceback (most recent call last):
File “”, line 1, in
TypeError: pop() takes no arguments (1 given)

element2=sList.pop()
element2
2

sList
{3, 4, 5}

sList.pop()
3

sList.pop()
4

sList.pop()
5

sList.pop() #当set为空时，会报错
Traceback (most recent call last):
File “”, line 1, in
KeyError: ‘pop from an empty set’

clear、 copy和len函数
clear 方法用于清空集合中的所有元素
copy方法用于集合拷贝
len函数跟求序列的长度的函数len()是一样的，返回的是集合中有多少个元素。

sList = set([1, 2, 3, 4, 5])
sList
{1, 2, 3, 4, 5}

len(sList)
5

s2=sList.copy() #s2与sList的内存地址不一样
s2
{1, 2, 3, 4, 5}

id(s2)
47516048

id(sList)
47516408

sList.clear()
sList
set()

s2.clear()
s2
set()

交集
Python中求集合的交集使用的符号是“&” ，返回两个集合的共同元素组成的集合，即集合的交集。
并集
Python中求集合的并集用的是符号“|” ，返回的是两个集合所有的并去掉重复的元素组成的集合。
差集
Python中差集使用的符号是减号“-” ，返回的是在集合1但不在集合2中的元素组成的集合。

st1 = set(‘python’)
st1
{‘h’, ‘n’, ‘p’, ‘t’, ‘o’, ‘y’}

st2 = set(‘htc’)
st2
{‘t’, ‘h’, ‘c’}

st3=st1&st2 #交集
st3
{‘t’, ‘h’}

st4=st1|st2 #并集
st4
{‘o’, ‘h’, ‘n’, ‘p’, ‘y’, ‘t’, ‘c’}

st4=st1-st2 #返回的是在集合1但不在集合2中的元素组成的集合
st4
{‘o’, ‘n’, ‘y’, ‘p’}

st5=st2-st1 #返回的是在集合2但不在集合1中的元素组成的集合
st5
{‘c’}

两个集合的不同之处
查看两个集合的不同之处，使用的difference函数，等价于差集。如：s1.difference(s2)
这种不同指的是集合s1相对于集合s2，不同的地方，也就是所有在集合s1中，而不再集合s2中的的元素组成的新集合。

st1 = set(‘python’)
st1
{‘h’, ‘n’, ‘p’, ‘t’, ‘o’, ‘y’}

st2 = set(‘htc’)
st2
{‘t’, ‘h’, ‘c’}

st3 = st1.difference(st2)
st3
{‘o’, ‘n’, ‘y’, ‘p’}

st4=st1-st2
st4
{‘o’, ‘n’, ‘y’, ‘p’}

运算符判断集合间关系
集合可以使用大于（>）、小于（<）、大于等于（>=）、小于等于（<=）、等于（==）、不等于（！=）来判断某个集合是否完全包含于另一个集合，也可以使用子父集判断函数。

1）大于（>）或大于等于（>=）,表示左边集合是否完全包含右边集合，如集合s1是否完全包含集合s2。
2）小于（<）或小于等于（<=）,表示左边的集合是否完全包含于右边的集合，如集合s1是否完全包含于集合s2。
3）等于（==）、不等于（！=）,判断两个集合是否完全相同。

s1 = set([1, 2, 3, 4, 5])
s1
{1, 2, 3, 4, 5}

s2 = set([1, 2, 3, 4])
s2
{1, 2, 3, 4}

s3 = set([‘1’, ‘8’, ‘9’, ‘5’])
s3
{‘9’, ‘5’, ‘1’, ‘8’}

s1>=s2
True

s2<=s1
True

s1==s3
False

s1!=s3
True

函数判断集合间关系
issuperset方法所用是判断集合st1是否是集合st2的父集，如果是返回True，否则返回False。
issubset()函数的作用是判断集合s1是否是集合s2的子集，如果是返回True，否则返回False。

s1 = set([1, 2, 3, 4, 5])
s1
{1, 2, 3, 4, 5}

s2 = set([2, 3])
s2
{2, 3}

s1.issuperset(s2)
True

s2.issuperset(s1)
False

s1.issubset(s2)
False

s2.issubset(s1)
True

集合的成员运算符
集合里也可以使用成员运算符，in和not in，判断某个对象是否是集合中的成员。

s1 = set([1, 2, 3, 4, 5])
s1
{1, 2, 3, 4, 5}

1 in s1
True

0 in s1
False

不可变集合：
Python中还有一种不可改变的集合，那就是 frozenset，不像set集合，可以增加删除集合中的元素，该集合中的内容是不可改变的，类似于字符串、元组。如果试图改变不可变集合中的元素，就会报AttributeError错误。不可变集合，除了内容不能更改外，其他功能及操作跟可变集合set一样。

f1 = frozenset(‘python’)
f1
frozenset({‘h’, ‘n’, ‘p’, ‘t’, ‘o’, ‘y’})

f1.add(‘two’)
Traceback (most recent call last):
File “”, line 1, in
AttributeError: ‘frozenset’ object has no attribute ‘add’

f1.update(‘two’)
Traceback (most recent call last):
File “”, line 1, in
AttributeError: ‘frozenset’ object has no attribute ‘update’

f1.remove(‘h’)
Traceback (most recent call last):
File “”, line 1, in
AttributeError: ‘frozenset’ object has no attribute ‘remove’

f1.pop()
Traceback (most recent call last):
File “”, line 1, in
AttributeError: ‘frozenset’ object has no attribute ‘pop’

练习题目：
1、能够熟练进行字符串、列表、元组和set之间的转换。

str1=“abnckkdk24”
set(str1)
{‘k’, ‘2’, ‘n’, ‘4’, ‘d’, ‘b’, ‘a’, ‘c’}

“”.join(set(str1))
‘k2n4dbac’

list1=[1,2,4,5,6,6,7,0,0]
set(list1)
{0, 1, 2, 4, 5, 6, 7}

list(set(list1))
[0, 1, 2, 4, 5, 6, 7]

tuple1=(1,3,4,4,5,5,5,8)
set(tuple1)
{1, 3, 4, 5, 8}

tuple(set(tuple1))
(1, 3, 4, 5, 8)

2、结合set对象，统计某个list出现的重复元素个数

list=[1,2,2,1,1,4]
s1=set(list)

count=len(list)-len(s1)
print(“list出现的重复元素个数为%d”%count)

执行结果：
list出现的重复元素个数为3

3、定义一个不可变集合，向不可变集合中添加元素或者修改已有元素，并捕获异常

f1 = frozenset(‘python’)

try:
f1.add(‘one’)
except Exception as e:
print(e)

try:
f1.update(‘o’)
except Exception as e:
print(e)

执行结果：
‘frozenset’ object has no attribute ‘add’
‘frozenset’ object has no attribute ‘update’

4、列出你所有知道的排重方法

L=[12,8,9,10,10,9,8,2,4,2]

第一种：使用set的特型，python的set和其他语言类似, 是一个无序不重复元素集；该方法结果是没有保持原来的顺序。

L=[12,8,9,10,10,9,8,2,4,2]
result=list(set(L))
result
[2, 4, 8, 9, 10, 12]

result.sort(key=L.index) #按照索引对去重后的结果进行再次排序
result
[12, 8, 9, 10, 2, 4]

第二种：使用keys()方法。

L=[12,8,9,10,10,9,8,2,4,2]
result= list({}.fromkeys(L).keys())
result
[12, 8, 9, 10, 2, 4]

第三种：循环遍历法

L=[12,8,9,10,10,9,8,2,4,2]
result=[]
for i in L:
if i not in result:
result.append(i)
print(result)

执行结果：
[12, 8, 9, 10, 2, 4]