9.Python【非序列】- 集合

认识集合

集合（set）是由具有唯一性的哈希（hashabole）对象所组成的无序多项集。集合的主要用途有如下3方面：

• 成员检测。
• 去除重复项。
• 数学中的集合类计算，如交集、并集、差集和对称差集等。

与其他多项集一样，集合支持的操作包括如下3方面：

• x in set：成员检测。
• len(set)：获取成员个数。
• for x in set：遍历成员。

作为一种无序的多项集，集合并不记录元素的位置，以及插入的顺序，因此也不支持索引、切片
或其他序列类的操作。

目前有两种内置集合类型，具体如下：

• set 类型是可变的，其内容可以使用 add() 和 remove() 方法来改变。由于是可变类型，它没有哈希值，不能被用作字典的键，或其他集合的元素。
• frozenset 类型是不可变的，并且有哈希值，其内容在被创建之后不能再改变，因此，集合可以被用作字典的键或其他集合的元素。

在Python 中，集合具有如下特点。

• 集合是无序的数据结构。集合内的数据随机排列。
• 集合是可变的数据类型。可以任意添加、删除或更新集合包含的数据。
• 内部数据统称为元素，每个元素必须是唯一的、不可变的。因此，集合是一组无序排列的可哈希的值。元素可以是数字、字符串或者元组，但不能使用列表、字典、集合等可变类型数据。
• 不能通过映射或索引访问内部元素，但可以迭代或检查元素。
• 集合的字面值：使用大括号包含所有元素，元素之间使用逗号分隔。

构造集合

使用大括号作为起始和终止标识符，其中包含一个或多个不可变类型的元素，元素之间通过逗号分隔。集合字面值的语法格式如下：

{元素1,元素2,元素3,...,元素n}

使用set()构造集合，参数 iterable 为可达代对象，返回一个新的 set 对象，其元素来自iterable。集合的元素必须为 hashable（可哈希）的值。如果省略参数 iterable，则返回一个新的空集合。

set([iterable])

(1) 在创建空集合时，只能使用set()函数，不能使用字面值表示，因为大括号语法{}表示创建一个空字典对象。
(2) 在创建集合时，如果出现重复的元素，那么将只保留一个元素。
(3) 当把可迭代对象转换为集合时，会去掉重复的元素。
(4) 如果是字典对象，将使用字典对象的键作为集合的值。

set1 = set((1,2,3)) # 元组转集合
set2 = set([1,2,3]) # 列表转集合
set3 = set({1,2,3}) # 集合转集合
set4 = set(range(1,4)) # 数字范围转集合
set5 = set('python') # 字符串转集合
set6 = set({'a':1,'b':2,'c':3}) # 字典转集合

集合推导式

集合推导式使用大括号标识，推导的结果集中没有重复元素，语法如下：

{表达式 for 变量 in 可迭代对象}
{表达式 for 变量 in 可迭代对象 if 条件表达式}

import random # 导入random 随机数模块
s = set() # 定义空集合
while len(s) != 10: # 如果集合长度不为10，则重复生成
		s = {random.randint(1,100) for i in range(10)} # 使用集合推导式随机生成10个数
print(s) # 输出 {99,37,38,41,73,75,12,13,16,89}

操作集合

访问元素

集合元素是无序排列的，不可以为集合创建索引，或执行切片操作，也没有键可用来映射元素，因此无法直接访问集合元素。如果需要访问集合元素，可以把集合转换为列表或元组进行访问。

set1 = {'a','b','c'} # 定义字符串集合
set1 = list(set1) # 转换为列表
print(set1[0]) # 每次输出的值是不确定的
for i in set1: # 遍历集合元素
		print(i) # 输出集合元素

添加元素

使用add()方法可以为集合添加元素，参数 elem 表示要添加的元素值，如果添加的元素在集合中已经存在，则不执行任何操作，语法和示例如下：

add(elem)

import random  # 导入随机数函数
s= set() # 定义空集合
num_range = int(input('请输入随机数的范围：')) # 数值范围
count =int(input(请输入随机数的个数：)) # 随机数个数
while len(s) < count: # 循环生成陏机数
		num = random.randint(1,num_range) # 生成范围内的随机数
		s.add(num) # 将不重复的随机数添加到集合中
print(s) # 打印集合

删除元素

使用remove()方法可以移除集合中指定的元素，参数elem表示要删除的元素，该方法没有返回值，在原对象上操作，如果elem不存在于集合中，则引发KeyError异常。

remove(elem)

set1 = {'a','b','c'}
set1.remove('a') # 删除 a 元素
set1.remove('d') # 删除 d 元素，抛出异常

使用discard()方法也可以移除指定的集合元素，与remove()方法不同，在移除一个不存在的元素时，discard()方法不执行删除操作，也不会抛出异常。

set1 = {'a','b','c'}
set1.discard('a') # 删除 a 元素
set1.discard('d') # 删除 d 元素，没有抛出异常

使用clear()方法可以清空集合中所有元素，没有参数，也没有返回值。

set1 = {'a','b','c'}
set1.clear() # 清空元素
print(set1) # 输出为set()

使用pop()方法可以随机移除一个元素，该方法没有参数，返回值为删除的元素，如果集合为空引发KeyError异常。

set1 = {'a', 'b','c'}
list1 = [] # 定义空列表
for i in range(len(set1)): # 循环遍历集合
		val = set1.pop() # 随机刪除元素
		list1.append(val) # 把刪除元素附加到列表中
print(set1) # 输出为 set()
print(list1) # 输出为 [a，b,c]

检测元素

使用in 或者 not in运算检测指定的键是否存在于字典中。

set1 = {'a', 'b','c'}
if 'a' in set1: # 检测 a 是否存在
		set1.remove('a') # 存在则移除
if 'd' in set1: # 检测 d 是否存在
		set1.remove('d') # 村在则移除
print(set1) # 输出 {'c','d'}

合并集合

使用update()方法可以把一个或多个元素添加到集合中，或者合并两个集合，参数others 可以是一个值、元组、列表、字典，或者一个集合。语法和示例如下：

update(*others)

set1 = {'a','b','c',3}
set2 = {1,2,3,'c'}
set1.update(set2)
print(set1)

set3 = {'a', 'b', 'c'}
set3.update("d") # 添加1个新元素
set3.update({1: 1, 2: 2}) # 以字典形式添加2个元素
set3.update("d", "e", "f") # 以元组形式添加3个元素
set3.update(["h", "¡", "j"]) # 以列表形式添加了个元素
print(set3) # 输出为 (1,2,'a;d;h;c:g,9,1,1,03

a = set()
b = set()
a.update({"Python"}) # 添加集合，集合元素为字符串
b.update("Python") # 添加字符串
print(a) # 输出为 {Python}
print(b) # 输出为 {'t','P','n','y','o','h'}

要把字符串作为一个元素添加到集合中，需要把字符串作为一个对象的元素来添加。

复制集合

使用copy()方法复制集合，该方法没有参数，返回一个集合的浅复制的副本，语法和示例如下：

set.copy()

set1 = {'a', 'b','c'}
set2 = set1.copy()
print(set2) # {'a', 'b','c'}

import copy
set3 = copy.copy(set1)
print(set3) # {'a', 'b','c'}

删除集合

使用del命令手动删除集合。

set1 = {'a', 'b','c'}
del set1 # 删除集合
print(set1) # 再次访问集合，将抛出错误

集合运算

并集

并集也称合集，就是把两个集合的所有元素加在一起，组成一个新的集合。

使用|运算符。

set1 |= set2

a = {1,2,3,4}
b = {3,4,5,6}
c = a|b # 并集为 {1,2,3,4,5,6}

使用union()方法合并两个集合，语法和示例如下：

set1.union(set2)
set.union(set1,set2,...,setn)

a = {1,2,3,4}
b = {3,4,5,6}
c = set.union(a,b) # 使用union()函数，并集为 {1,2,3,4,5,6}
d = a.union(b) # 使用union()方法，并集为 {1,2,3,4,5,6}

交集

交集也称重叠集合，就是计算两个集合共有的元素。

使用&运算符。

set1&set2

a = {1,2,3,4}
b = {3,4,5,6}
c = a&b  # 交集为{3,4}

使用intersection()方法求两个集合的交集，语法和示例如下：

set1 &= set2 
set1.intersection(set2)
set.intersection(set1,set2,...,setn)

a = {1,2,3,4}
b = {3,4,5,6}
c = set.intersection(a,b) # {3,4}
d = a.intersection(b) # {3,4}

使用intersection_update()方法获取两个或更多集合的交集，语法和示例如下：

set.intersection_update(set1,set2,...,setn)

a = {1,2,3,4}
b = {3,4,5,6}
a.intersection_update(b) # 求a和b的交集，a为{3,4}

差集

差集就是由所有属于集合A，但是不属于集合B的元素组成的集合，也称为A与B的差集，即”我有而你没有”的元素。

使用-运算符。

set1 - set2

a = {1,2,3,4}
b = {3,4,5,6}
c = a - b # 求a与b的差集{1,2}

使用difference()方法求差集，语法和示例如下：

set1 -= set2

a = {1,2,3,4}
b = {3,4,5,6}
c = a.difference(b) # 求a与b的差集{1,2}

使用difference_update()方法直接在原集合中进行计算。

a = {1,2,3,4}
b = {3,4,5,6}
a.difference_update(b) # 求a与b的差集{1,2}

对称差集

对称差集就是两个集合的差集的并集，即求A与B的差集和B与A的差集的并集，简单来说就是两个集合中不重叠元素组成的集合。

使用^运算符。

a = {1,2,3,4}
b = {3,4,5,6}
c = a^b # 求a与b的对称并集，{1,2,5,6}
# c 等价于 e
e = a-b
f = b-a
d = e|f # 求a与b的对称并集，{1,2,5,6}

使用symmetric_difference()方法求对称差集，语法和示例如下：

set1 ^= set2
set1.symmetric_difference(set2)

a = {1,2,3,4}
b = {3,4,5,6}
c = a.symmetric_difference(b) # 求a与b的对称并集，{1,2,5,6}

使用symmetric_difference_update()方法求对称差集，直接在原集合中进行计算，没有返回值，语法和示例如下：

a = {1,2,3,4}
b = {3,4,5,6}
c = a.symmetric_difference_update(b) # 求a与b的对称并集，{1,2,5,6}

集合运算

两个集合之间的关系包括：相等、子集、父集和不相交。

相等

两个集合当且仅当每个集合中的每个元素均包含与另一个集合之内时，即各为对方的子集时，两个集合相等，语法和示例如下：

a = {1,2}
b = {1,2}
c = a == b # True

子集和真子集

如果集合 A 的任意一个元素都是集合 B的元素，那么集合 A 就是集合 B的子集，集合A 和集合 B元素个数可以相等。使用<=运算符可以检测A是否为B的子集。语法格式如下：

A<=B
set1.issubset(set2)

如果集合 A 的任意一个元素都是集合 B 的元素，并且集合 B中含有集合 A 中没有的元素，那么集合 A 就是集合 B 的真子集。可以使用<运算符检测A是否为B的真子集。语法格式如下：

A<B

a = {1,2}
b = {1,2}
c = a<=b # 检测a是否为b的子集：True
c = a<b # 检测a是否为6的真子集：False
c = a.issubset(b) # 检测a是否为b的子集：True

父集和真父集

如果集合 B 的任意一个元素都是集合 A 的元素，那么集合 A 就是集合 B 的父集。集合 A 和集合 B元素个数可以相等。使用＞=运算符检测 A 是否为B 的父集。语法格式如下：

A>=B
set1.isssuperset(set2)

如果集合 B 的任意一个元素都是集合 A 的元素，并且集合 A 中含有集合 B中没有的元素，那么集合A就是集合 B 的真父集。可以使用>运算符检测 A 是否为 B的真父集。语法格式如下：

A>B

a = {1,2}
b = {1,2}
c=b>=a #  检测b 是否为a 的父集 True
c=b>a # 检测b 是否为a的真父集：False
c=b.issuperset(a)#  检测b 是否为a 的父集 True

不相交

如果集合A和集合B没有共有元素，那么他们不相交。

A!=B
set1.isdisjoint(set2)

a = (1, 2}
b = {3, 4}
c = a.isdisjoint(b) # 检测a和b 是否存在交集：True
d= a != b # 检测a和b是否存在交集：True

不可变集合

frozenset（不可变集合）的结构和特点与 set（可变集合）完全相同，功能和用法也基本相同。与
可变集合 set 不同点：不可变集合在创建之后，就不能再添加、修改和删除元素。

不可变集合的应用场景：使用集合参与哈希值运算，如在集合中嵌套集合，或者使用集合作为字典的键，这时就必须使用不可变集合。

使用frozenset()函数可以创建不可变集合，该函数包含一个参数，指定一个可迭代的对象，它可以将列表、元组、字典等对象转换为不可变集合。语法格式如下：

frozenset([iterable])