什么是集合？
集合并不是一种数据处理类型，而是一种中间类型。
- 集合(set)是一个无序、不重复的元素序列
- 经常被用来处理两个列表进行交并差的处理性
- 集合与列表一样，支持所有的不可变数据类型
集合中所有的元素放在 {} 中间，并用逗号分开，例如：
{1, 2, 3}，一个包含 3 个整数的列表
{‘a’, ‘b’, ‘c’}，一个包含 3 个字符串的列表
集合与列表的区别
| 功能 |
列表 |
集合 |
| 顺序 |
有序 |
无序 |
| 内容 |
可重复 |
不可重复 |
| 功能 |
用于数据的使用 |
用于数据的交集、并集、差集的获取 |
| 索引 |
有索引 |
无索引 |
| 符号 |
[ ] —> [1, 2, 3] |
{ } —> {1, 2, 3} |
集合的创建方法
通过 set 函数创建集合，也可以使用有值的大括号来创建。 如 {1, 2} ，但不能使用空的大括号来创建。(空的大括号是一个空的字典)
示例如下：
|
1
2
3
4
5
6
7
8
9
|
test_set_01 = set() # ---> 一个空的集合
test_set_02 = set([1, 2, 3]) # ---> 传入列表或元组
test_set_03 = {1, 2, 3} # ---> 传入元素
test_set_04 = {} # ---> 这样的方式是错误的，这是一个空的字典
print(type(test_set_04))
# 执行结果如下：
# ---> <class 'dict'>
|
|
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
31
32
33
34
35
36
37
38
39
40
41
42
43
|
test_list_01 = ['name', 'age', 'birthday']
test_set_01 = set(test_list_01)
print(test_set_01)
# 执行结果如下：
# >>> {'name', 'age', 'birthday'} 可以看到，传入的并不是列表，而是列表的元素
test_list_02 = ['name', 'age', 'birthday', 'age']
test_set_02 = set(test_list_02)
print(test_set_02)
# 执行结果如下：
# >>> {'name', 'age', 'birthday'} 可以看到，列表里重复的元素，做了去重的处理
test_list_03 = (1, 2, 3, 1, 5)
test_set_03 = set(test_list_03)
print(test_set_03)
# 执行结果如下：
# >>> {1, 2, 3, 5} 可以看到，元组里重复的元素，做了去重的处理
test_set_04 = {['name', 'age', 'birthday']}
print(test_set_04)
# 执行结果如下：
# >>> TypeError: unhashable type: 'list' 集合内不可传入列表，否则会报错
test_set_05 = {{'name', 'age', 'birthday'}}
print(test_set_05)
# 执行结果如下：
# >>> TypeError: unhashable type: 'set' 集合内同样也不可传入字典
test_set_06 = {'name', 1, 3.14, (666, 888)}
print(test_set_06)
# 执行结果如下：
# >>> {'name', 3.14, 1, (666, 888)} 集合内可以传入不同的数据类型(列表不可以直接传入)
|
集合的增删改
add 函数
add 函数的功能：用于集合中添加一个元素，如果集合中已经存在该被添加的元素，则该函数不执行。
add 函数的用法：set.add(item) ；item 为要被添加到集合的元素；无返回值。
示例如下：
|
1
2
3
4
5
6
7
|
test_set = {'name', 'age', 'birthday'}
test_set.add('sex')
test_set.add('name')
print(test_set)
# 执行结果如下：
# >>> {'sex', 'birthday', 'age', 'name'} 已存在的 'name' 元素，未再次执行添加
|
update 函数
update 函数的功能：在集合中加入一个新的集合(或者列表、元组、字符串)，如果新集合内的元素在原集合中存在则无视。
update 函数的用法：set.update(iterable) ；iterable为集合、列表、元组、字符串；无返回值，直接作用于原集合。
示例如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
test_set = set()
test_list = ['name', 'age', 'birthday']
test_set.update(test_list)
print(test_set)
# 执行结果如下：
# >>> {'birthday', 'age', 'name'} 列表的成员(元素)被添加进集合
test_tuple = (666, 888)
test_set.update(test_tuple)
print(test_set)
# 执行结果如下：
# >>> {'name', 'birthday', 'age', 888, 666} 元组的成员(元素)被添加进集合
name = 'Neo'
test_set.update(name)
print(test_set)
# 执行结果如下：
# >>> {'name', 'N', 'birthday', 'e', 'age', 'o', 888, 666} 字符串是每个字符都作为元素被添加进集合的
|
remove 函数
remove函数的功能：将集合中某个元素删除，如果该元素不存在则会报错。
remove函数的用法：set.remove(item) ；item 为当前集合中的一个元素；无返回值，直接作用于原集合。
需要注意的是，item 为集合中的某一个元素，而不是索引。
示例如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
test_set = set()
test_list = ['name', 'age', 'birthday']
test_set.update(test_list)
print(test_set)
# 执行结果如下：
# >>> {'name', 'birthday', 'age'}
test_set.remove('age')
print(test_set)
# 执行结果如下：
# >>> {'birthday', 'name'}
test_set_01 = set()
test_set.remove('test')
print(test_set_01)
# 执行结果如下：
# >>> KeyError: 'test' 'test'元素不存在则报错。
|
clear 函数
clear 函数的功能：清空当前集合中所有的元素
clear 函数的用法：set.clear() ；无返回值，直接作用于原集合。
示例如下：
|
1
2
3
4
5
6
7
8
|
test_set = set()
test_list = ['name', 'age', 'birthday']
test_set.clear()
print(test_set)
# 执行结果如下：
# >>> set()
|
del 方法删除集合
del 的功能：直接删除 （作用于集合，无法通过索引删除）
示例如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
test_set = set()
test_list = ['name', 'age', 'birthday']
test_set.update(test_list)
print(test_set)
# 执行结果如下：
# >>> {'birthday', 'age', 'name'}
del test_set
print(test_set)
# 执行结果如下：
# >>> NameError: name 'test_set' is not defined.
|
关于集合的重要说明
- 集合无法通过索引获取元素
- 集合无获取元素的任何方法
- 集合只是用来处理列表或元组的一种临时类型，它不适合存储、传输数据
获取两个集合交、并、差集的函数
difference() 函数
什么是差集：
a 和 b 两个集合，由所属于 a 且不属于 b 的元素组成的集合叫做 a 集合 与 b 集合 的差集。
difference() 函数的功能：返回集合的差集，即返回的集合元素包含在第一个集合中，但不包含在第二个集合中。
difference() 函数的用法：a_set.difference(b_set) ；b_set 为当前集合需要比对的集合；返回值为原集合作用于对比集合的差集。(即 a_set 与 b_set 的差集)
示例如下：
|
1
2
3
4
5
6
7
8
|
names_set_01 = {'Neo', 'Lily', 'Jack'}
names_set_02 = {'Jack', 'Adem', 'Albina'}
names_diff = names_set_01.difference(names_set_02)
print(names_diff)
# 执行结果如下：
# >>> {'Lily', 'Neo'}
|
intersection() 函数
什么是交集？
a 和 b 两个集合，分别拥有相同的元素集，称之为 a 集合 与 b 集合 的交集。
intersection() 函数的功能：返回两个或者更多个集合中都包含有的元素。（即交集）
intersection() 函数的用法：a_set.inersection(b_set...) ；b_set… 为当前集合需要比对的一个或者多个集合；返回值为原集合作用于对比集合的交集。
示例如下：
|
1
2
3
4
5
6
7
8
9
|
names_set_01 = {'Neo', 'Lily', 'Jack', 'Adem'}
names_set_02 = {'Jack', 'Adem', 'Albina'}
names_set_03 = {'Apollo', 'Ben', 'Adem'}
names_inter = names_set_01.intersection(names_set_02, names_set_03)
print(names_inter)
# 执行结果如下：
# >>> {'Adem'}
|
union() 函数
什么是并集？
a 和 b 两个集合中所有的元素(去掉重复的)，即为 a 集合 与 b 集合 的并集。
union() 函数的功能：返回多个集合的并集，即包含了所有集合的元素(重复的元素，只出现一次)
union() 函数的用法：a_set.union(b_set...) ；b_set… 为当前集合需要比对的一个或者多个集合；返回值为原集合作用于对比集合的并集。
示例如下：
|
1
2
3
4
5
6
7
8
9
|
names_set_01 = {'Neo', 'Lily', 'Jack', 'Adem'}
names_set_02 = {'Jack', 'Adem', 'Albina'}
names_set_03 = {'Apollo', 'Ben', 'Adem'}
names_union = names_set_01.union(names_set_02, names_set_03)
print(names_union)
# 执行结果如下：
# >>> {'Lily', 'Neo', 'Albina', 'Apollo', 'Jack', 'Ben', 'Adem'}
|
判断两个集合中是否存在相同的元素
isdisjoint() 函数
isdisjoint()函数的功能：判断两个集合是否包含相同的元素，如果没有返回 True ， 否则就返回 False
isdisjoint()函数的用法：a_set.isdisjoint(b_set) ；b_set 为与当前集合用来判断的集合；返回值为布尔值
示例如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
names_set_01 = {'Neo', 'Lily', 'Jack', 'Adem'}
names_set_02 = {'Jack', 'Adem', 'Albina'}
names_isdisjoint = names_set_01.isdisjoint(names_set_02)
print(names_isdisjoint)
# 执行结果如下：
# >>> False
names_set_01 = {'Neo', 'Lily', 'Jack'}
names_set_02 = {'Ben', 'Adem', 'Albina'}
names_isdisjoint = names_set_01.isdisjoint(names_set_02)
print(names_isdisjoint)
# 执行结果如下：
# >>> True
|
拓展 - 集合的 ‘&、|、- 运算符’
& 符可以计算两个集合的交集，与集合的intersection()函数实现的功能一样
| 符可以计算两个集合的并集，与集合的union()函数实现的功能一样
- 运算符可以计算两个集合的差集，与集合的difference()函数实现的功能一样
代码示例如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
# 交集
names_set_01 = {'Neo', 'Lily', 'Jack', 'Adem'}
names_set_02 = {'Jack', 'Adem', 'Albina'}
names_set_03 = {'Apollo', 'Ben', 'Adem'}
names_inter = names_set_01.intersection(names_set_02, names_set_03)
names_inter_01 = names_set_01 & names_set_02 & names_set_03
print(names_inter)
print(names_inter_01)
# 执行结果如下：
# >>> {'Adem'}
# >>> {'Adem'}
|
|
1
2
3
4
5
6
7
8
9
10
11
12
|
# 差集
names_set_01 = {'Neo', 'Lily', 'Jack'}
names_set_02 = {'Jack', 'Adem', 'Albina'}
names_diff = names_set_01.difference(names_set_02)
names_diff_01 = names_set_01 - names_set_02
print(names_diff)
print(names_diff_01)
# 执行结果如下：
# >>> {'Lily', 'Neo'}
# >>> {'Lily', 'Neo'}
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
# 并集
names_set_01 = {'Neo', 'Lily', 'Jack', 'Adem'}
names_set_02 = {'Jack', 'Adem', 'Albina'}
names_set_03 = {'Apollo', 'Ben', 'Adem'}
names_union = names_set_01.union(names_set_02, names_set_03)
names_union_1 = names_set_01 | names_set_02 | names_set_03
print(names_union)
print(names_union_1)
# 执行结果如下：
# >>> {'Adem', 'Albina', 'Neo', 'Jack', 'Lily', 'Ben', 'Apollo'}
# >>> {'Adem', 'Albina', 'Neo', 'Jack', 'Lily', 'Ben', 'Apollo'}
|
&、|、- 与 intersection()、union()、difference()函数的不同之处
集合运算时：
intersection()、union()、difference()函数的参数可以是集合，也可以是列表或字典、字符串。
&、|、-运算符左右两边必须是集合。
|
