Python学习笔记（5）-数据类型之集合

发表于 | 分类于
| 字数统计: 2,375 | 阅读时长 ≈ 11

集合的定义

集合是无序可变序列，使用一对大括号（这一点和字典比较类似）作为界定符，元素之间使用逗号分隔，同一个集合内的每个元素都是唯一的，元素之间不允许重复。

集合的英文是set，其特点是：

  1. 有的可变，有的不可变；元素无次充，不可重复。
  2. 元组(tuple）是列表（list）和字符串（str）的杂合，集合(set）是list和dict的杂合。
  3. 集合用{}来定义 ，其中的元素没有序列，并且集合中的元素不可重利，类似于dict的键。
  4. 集合可以在原处修改。

集合的创建

使用set()进行创建

可以使用set()直接创建集合，如下所示：

1
2
3
4
5
>>> s1 = set("qiwsir")
>>> print(s1)
{'s', 'i', 'r', 'q', 'w'}
>>> print(type(s1))
<class 'set'>

从结果可以看出，qiwsir中有两个i，但在s1中则只有一个i，即集合中的元素不能重复，如果原来的数据中存在重复的元素，则转换为集合时就只保留一个，再看一个案例：

1
2
3
>>> s2 = set([123,"google","face","book","facebook","book"])
>>> print(s2)
{'google', 123, 'book', 'face', 'facebook'}

从结果可以看出，创建集合的时候与显示集合的时候，元素的顺序不同，这说明集合中的元素没有顺序。再看一案例： 

1
2
3
4
5
6
7
8
9
>>> s1 = set("qiwsir")
>>> print(s1)
{'s', 'i', 'r', 'q', 'w'}
>>> s1[1] = ["I"]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'set' object does not support item assignment
>>> print(s1)
{'s', 'i', 'r', 'q', 'w'}

这说明，集合不是序列类型，不能用索引方式对其进行修改。

直接使用大括号创建集合

1
2
3
4
5
>>> a = {3, 5}
>>> a
{3, 5}
>>> type(a)
<class 'set'>

集合中只能包含数字、字符串、元组等不可变类型（或者说可哈希）的数据，而不能包括列表、字典、集合等可变类型的数据。python提供了一个内置函数hash()来计算对象的哈希值，凡是无法计算哈希值（调用hash()函数时抛出异常）的对象都不能作为集合的元素，也不能作为字典对象的“键”。

集合的转换set()

类型名称函数能够实现类型的转换，例如str()可以将对象转化为字符串，用list()和set()能够将集合和列表进行转换，如下所示： 

1
2
3
4
5
6
7
8
9
>>> s1 = set("qiwsir")
>>> print(s1)
{'s', 'i', 'r', 'q', 'w'}
>>> lst = list(s1)
>>> print(lst)
['s', 'i', 'r', 'q', 'w']
>>> lst[1] = "I"
>>> print(lst)
['s', 'I', 'r', 'q', 'w']

集合元素的添加add()

集合元素的添加使用add()方法，如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
>>> a_set = {'a',"i","1",1} #创建集合
>>> print(a_set)
{'i', '1', 'a', 1}
>>> print(type(a_set)) #查看对象的类型
<class 'set'>
>>> a_set.add("qiwsir") # 添加一个元素
>>> print(a_set)
{1, 'a', 'i', '1', 'qiwsir'}
>>>
>>> b_set = set("python")
>>> print(type(b_set))
<class 'set'>
>>> print(b_set)
{'h', 'o', 'y', 't', 'n', 'p'}
>>> b_set.add("test")
>>> print(b_set)
{'h', 'o', 'y', 'test', 't', 'n', 'p'}

合并集合update()

update()方法用于合并另外一个集合的元素到当前集合中，如下所示：

1
2
3
4
5
6
7
8
9
>>> s1 = {'a','b'}
>>> print(s1)
{'a', 'b'}
>>> s2 = {'github','qiwsir'}
>>> print(s2)
{'qiwsir', 'github'}
>>> s1.update(s2)
>>> print(s1)
{'github', 'qiwsir', 'a', 'b'}

集合的运行in()

字典和集合的in操作比列表快很多。因为python字典和集合使用hash表来存储元素，因此元素查找操作非常快，这就直接决定了关键字in作用于字典和集合时比作用于列表要快得多，看一个案例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import random
import time
x = list(range(10000))
# 生成列表
y = set(range(10000))
# 生成集合
z = dict(zip(range(1000),range(10000)))
# 生成字典
r = random.randint(0,9999)
# 生成随机数
start = time.time()
for i in range(9999999):
    r in x
print('list, time used: ',time.time() - start)
start = time.time()
for i in range(9999999):
    r in y 
print('set, time used: ',time.time() - start)
start = time.time()
for i in range(999999999):
     r in z
print('dict, time used: ',time.time() - start)

运行结果如下所示：

1
2
3
4
C:\Users\20161111>python a.py
list, time used:  1369.371190071106
set, time used:  1.289543867111206
dict, time used:  95.13067197799683

删除set中的元素

pop()函数

pop()随机删除并返回集全中的一个元素，如果集合为空，则抛出异常，如下所示：

1
2
3
4
5
6
7
>>> s3= {'a','b',123,'test'}
>>> print(s3)
{'b', 123, 'a', 'test'}
>>> s3.pop()
'b'
>>> print(s3)
{123, 'a', 'test'}

remove()方法

remove()方法用于删除集合中的元素，如果指定元素不存在，就抛出异常，如下所示：

1
2
3
4
5
6
>>> s3= {'a','b',123,'test'}
>>> print(s3)
{'b', 123, 'a', 'test'}
>>> s3.remove("test")
>>> print(s3)
{'b', 123, 'a'}

discard()方法

discard()方法用于从集合中删除一个特定的元素，如果元素不在集合中，则忽略该操作，如下所示：

1
2
3
4
5
6
>>> s3= {'a','b',123,'test'}
>>> print(s3)
{'b', 123, 'a', 'test'}
>>> s3.discard("test")
>>> print(s3)
{'b', 123, 'a'}

remove()与discard()的区别

1
2
3
4
5
6
7
8
9
10
11
12
>>> s3= {'a','b',123,'test'}
>>> print(s3)
{'b', 123, 'a', 'test'}
>>> s3.discard("test")
>>> print(s3)
{'b', 123, 'a'}
>>> s3= {'a','b',123,'test'}
>>> print(s3)
{'b', 123, 'a', 'test'}
>>> s3.discard("test")
>>> print(s3)
{'b', 123, 'a'}

所实现的目的与remove一样，区别在于如下所示：

1
2
3
4
5
>>> s3= {'a','b',123,'test'}
>>> print(s3)
{'b', 123, 'a', 'test'}
>>> s3.discard("5")
>>>

运行结果：无

而remove()的结果如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
>>> s3= {'a','b',123,'test'}
>>> print(s3)
{'b', 123, 'a', 'test'}
>>> s3.remove("5")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: '5'>>> s3= {'a','b',123,'test'}
>>> print(s3)
{'b', 123, 'a', 'test'}
>>> s3.remove("5")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: '5'

remove与discard的区别在于，remove在删除指定的元素时，如果此元素不在set中，则就会出错，如果是discard删除，不存在此元素时，则不返回任何值。

clear()清除所有元素

clear()方法清空集合中的所有元素，如下所示：

1
2
3
4
5
6
7
8
9
10
>>> s3= {'a','b',123,'test'}
>>> print(s3)
{'b', 123, 'a', 'test'}
>>> print(bool(s3)) #有元素，则返回True
True
>>> s3.clear()
>>> print(s3)
set()
>>> print(bool(s3)) # 无元素返回False
False

集合冻结frozenset()

frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

1
2
3
4
5
6
7
>>> s4 = frozenset("test000")
>>> print(s4)
frozenset({'0', 's', 'e', 't'})
>>> s4.add("python")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'frozenset' object has no attribute 'add'

集合的运算

判断两个集合的从属关系in()

in()：元素与集合的关系可以用in来进行判断，如下所示：

1
2
3
4
5
6
7
>>> s5 = {"123","678",432,'123',"test"}
>>> print(s5)
{432, '678', '123', 'test'}
>>> print("123" in s5) # "123"是否在集合s5中
True
>>> print("123--" in s5) # "123---"是否在集合s5中
False

集合与集合的关系

集合与集合的关系可以用==,!=,>,<,issuperset,issubset来表示，如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
>>> s5 = {"123","678",432,'123',"test"}
>>> print(s5)
{432, '678', '123', 'test'}
>>> s6 = {"543",123,993,"test001"}
>>> print(s6)
{'test001', 993, 123, '543'}
>>> s7 = {"123","test"}
>>> print(s7)
{'123', 'test'}
>>> print(s5 == s6) # s5是否与s6等同
False
>>> print(s5 != s6) # s5是否与s6等同
True
>>> print(s7 < s5) # s7是否是s5的子集
True
>>> print(s7.issubset(s5)) # s7是否是s5的子集
True
>>> print(s5.issuperset(s7)) # s5是否是s7的超集
True

集合求并集(|)

1
2
3
4
5
6
7
8
9
10
11
12
13
>>> s5 = {"123","678",432,'123',"test"}
>>> print(s5)
{432, '678', '123', 'test'}
>>> s6 = {"543",123,993,"test001"}
>>> print(s6)
{'test001', 993, 123, '543'}
>>> s7 = {"123","test"}
>>> print(s7)
{'123', 'test'}
>>> print(s5|s6) # 求s5和s6的并集
{993, 'test001', '543', '123', 432, '678', 'test', 123}
>>> print(s5.union(s7)) # 求s5和s7的并集
{432, '678', 'test', '123'}

集合求交集(&)

1
2
3
4
5
6
7
8
9
10
11
12
13
>>> s5 = {"123","678",432,'123',"test"}
>>> print(s5)
{432, '678', '123', 'test'}
>>> s6 = {"543",123,993,"test001"}
>>> print(s6)
{'test001', 993, 123, '543'}
>>> s7 = {"123","test"}
>>> print(s7)
{'123', 'test'}
>>> print(s5 & s6) # 求s5和s6的交集
set()
>>> print(s5.intersection(s7)) # 求s5和s7的交集
{'123', 'test'}

集合求差集（-）

差集如下所示：

代码为：

1
2
3
4
5
6
7
8
9
10
11
12
13
>>> s5 = {"123","678",432,'123',"test"}
>>> print(s5)
{432, '678', 'test', '123'}
>>> s6 = {"543",123,993,"test001"}
>>> print(s6)
{993, 'test001', 123, '543'}
>>> s7 = {"123","test"}
>>> print(s7)
{'test', '123'}
>>> print(s5 - s6) # 求s5和s6的差集
{432, '678', 'test', '123'}
>>> print(s5.difference(s7)) # 求s5和s7的差集
{432, '678'}

集合的对称差集（）

对称差集示意图如下所示：

mark

代码为：

1
2
3
4
>>> s5 = {"123","678",432,'123',"test"}
>>> s8 = {"123","test",9999}
>>> print(s5.symmetric_difference(s8)) # 求s5和s7的对称差集
{9999, 432, '678'}

集合推导式

Python支持集合推导式，集合推导式使用的是大括号，如下所示：

1
2
3
>>> squared = {x**2 for x in [1, 1, 2]}
>>> print(squared)
{1, 4}

再看另外一个案例：

1
2
3
4
5
6
7
8
9
10
>>> {x.strip() for x in (' he ', 'she ', ' I')}
{'I', 'he', 'she'}
>>>
>>> import random
>>> x = {random.randint(1,500) for i in range(100)}
>>> # 生成随机数，自动去除重复元素
... len(x)
94
>>> {str(x) for x in range(10)}
{'2', '5', '6', '0', '4', '7', '9', '8', '3', '1'}

在比较两套以上的数据集合

如果有两个以上的数据集，希望找到所有集合中的共同元素，可以按如下方法进行：

1
2
3
4
5
6
7
8
9
from functools import reduce
# 注：在Python3中，reduce函数位于functools包中，这一点与python2不同
a = set((1, 2, 3, 4, 5))
b = set((2, 4, 6, 7, 1))
c = set((1, 4, 5, 9))
triple_set = [a, b, c]
common = reduce(set.intersection, triple_set)
print(common)

运行结果为：

1
{1, 4}

reduce()函数有两个参数：

第一个参数是有两个变量的函数f(x,y)；

第二个参数是迭代对象i（元组或列表），reduce(f,i)的意思是将前两个迭代元素(i[0]和i[1])传递至函数f，计算f返回的值，然后将该值作为f的第一个参数，迭代器的第三个元素(i[2])作为第二个参数，以此类推，看下面的这个案例：

1
2
3
4
from functools import reduce
def multiply(x,y):
    return x*y
print(reduce(multiply, (1, 2, 3, 4)))

运行结果为：

1
24

这上面这个案例的运行过程为：reduce()先计算1*2=2，然后以结果2为参数，再计算2*3=6，再以6参数，计算6*4=24。历此在第一个步取中，multiply(x)新参数x是该函数的累积结果，第二个参数是元组(1, 2, 3, 4)的后续元素。

参考资料

  1. 《Python生物信息学数据管理》（[意] Allegra，Via，[阿莱格拉，维亚] 等 著，卢宏超 等 译）