python 集合根据值给出索引 python集合可以索引吗

2.2.4 集合

集合是一个由唯一元素组成的非排序集合体，也就是说，集合中的元素没有特定顺序且不重复。Python使用{ }或者set( )函数创建集合，但是，在创建一个空集合时，必须使用set( )函数，因为使用{ }创建的是字典。
即：
○ 集合中的元素不能重复。
○ 集合中的元素是不可变的(不能修改)，但整个集合是可变的。
○ 没有索引附加到python集中的任何元素。因此，它们不支持任何索引或切片操作。
集合支持的功能：包括成员检测、从序列中去除重复项以及数学中的集合类计算，例如交集、并集、差集与对称差集等等。
集合不支持的功能：作为一种无序的多项集，集合并不记录元素位置或插入顺序。 相应地，集合不支持索引、切片或其他序列类的操作。

集合的系列操作如下表所示：
集合 aggregate --> agr

方法	描述
set( )	创建一个集合
agr.add( )	直接向集合中添加元素
agr.update([ ])	以列表格式向集合中添加元素
agr.remove(x)	删除元素x，不存在会报错
agr.discard(x)	删除元素x，不存在不会报错
n = agr.pop()	随机删除一个元素，并返回删除的元素值
agr.clear()	清空集合的所有元素
del agr	删除整个集合，注意集合是不能索引下标的
list(agr)	集合去重（顺序会被打乱）
len(agr)	统计集合的长度
( agr1.union(agr2) )	求集合的并集 （所有元素）
( agr1.intersection(agr2) )	求集合的交集（公共元素）
( agr1 & agr2 )	求集合的交集
( agr1.intersection_update(agr2)	取集合agr1、agr2的交集并更新到集合agr1中
( agr1.symmetric_difference(agr2) )	求集合agr1、agr2的反差集(对称差集)，即俩集合各自独有元素之和

一、创建集合

集合的创建有三种方法：1.{ }、2.set( )、3.集合推导式

1.{ }

sdc = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(sdc)
#Output
# {'banana', 'orange', 'apple', 'pear'}

2.set( )

agr1 = set([1,2,3,4,5,6])
agr2 = set()
print("agr1:",agr1)
print("agr2:",agr2)
#Output
#agr1: {1, 2, 3, 4, 5, 6}
#agr2: set()

3.集合推导式，类似列表推导式

sets = {c for c in 'abracadabra'}
print(sets)
#Output
# {'d', 'a', 'r', 'c', 'b'}

二、添加元素

添加元素有两种方法：1.add()、2.update()

1.add()方法

num_set = {1,2,3,4,5,6}
num_set.add(7)
print(num_set) 
#Output
#{1, 2, 3, 4, 5, 6, 7}

2.update()方法

num_set = {1,2,3,4,5,6}
num_set.update([7,8,9])
print(num_set)
#Output
#{1, 2, 3, 4, 5, 6, 7, 8, 9}

三、删除元素

删除元素有四种方式：1.agr.remove(x)、2.agr.discard(x)、3.n = agr.pop() 、4.agr.clear()、5.del agr

1.agr.remove(x)

删除元素，不存在会报错

agr = {1,2,3,4,5,6}
print(agr)
agr.remove(6)
agr.remove(8)
print(agr)
#Output
#{1, 2, 3, 4, 5, 6}
#{1, 2, 3, 4, 5}
#Traceback (most recent call last):
#  File "D:\python-Project\pythonProject3\py gather.py", #line 23, in <module>
#    agr.remove(8)
#KeyError: 8  元素不存在，报错。

2.agr.discard(x)

删除元素，不存在不会报错

agr = {1,2,3,4,5,6}
print(agr)
agr.discard(6)
agr.discard(8)
#Output
#{1, 2, 3, 4, 5, 6}
#{1, 2, 3, 4, 5}
#元素8不在集合中，执行操作时未报错。

3.n = agr.pop()

随机删除一个元素，并返回删除的元素值

agr = {1,2,3,4,5,6}
print(agr)
for i in range(len(agr)):
    n = agr.pop()
    print("当前被删除的是：",n)
print(agr)
#Output
#{1, 2, 3, 4, 5, 6}
#当前被删除的是： 1
#当前被删除的是： 2
#当前被删除的是： 3
#当前被删除的是： 4
#当前被删除的是： 5
#当前被删除的是： 6
#set()

4.agr.clear()

清空集合的所有元素

agr = {1,2,3,4,5,6}
print(agr)
agr.clear()
print(agr)
#Output
#{1, 2, 3, 4, 5, 6}
#set()

5.del agr

删除整个集合

agr = {1,2,3,4,5,6}
print(agr)
del agr
print(agr)
#Output
#{1, 2, 3, 4, 5, 6}
# NameError: name 'agr' is not defined 这里表示在执行完del 操作后，agr集合已被整个删除。

四、计算集合长度

n = len(agr)

agr = {1,2,3,4,5,6}
print(agr)
n = len(agr)
print(n)
#Output
#{1, 2, 3, 4, 5, 6}
#6

五、浅拷贝/复制

agr1 = agr.copy()
该方法，如果删除原集合，不会导致副本集合的改变

agr = {1,2,3,4,5,6}
agr1 = agr.copy()
del agr
print(agr1)
#Output
#{1, 2, 3, 4, 5, 6}

六、集合的嵌套

集合的元素，其基本数据类型是不可变数据类型（比如list、dict、set就不可作为集合的元素），所谓集合的嵌套，是指符合要求的数据类型元素可以共同构成一个集合。

agr = {1,2,3,'chenkk','zijun',(2,3,8)}
print(agr)
#Output
# {1, 2, 3, (2, 3, 8), 'zijun', 'chenkk'}

七、集合的基本运算

1.并集：所有元素（｜、union）

agr1 = {-2,-1,0,1,2,3}
agr2 = {-2,1,2,3,4,5}

# 并集:所有元素（｜、union）
print(agr1.union(agr2)) # {0, 1, 2, 3, 4, 5, -1, -2}
# print(agr2.union(agr1)) # {0, 1, 2, 3, 4, 5, -1, -2}
print(agr1 | agr2) # {0, 1, 2, 3, 4, 5, -1, -2}
# print(agr2 | agr1) # {0, 1, 2, 3, 4, 5, -1, -2}

2.交集：公共元素（&、intersection）

agr1 = {-2,-1,0,1,2,3}
agr2 = {-2,1,2,3,4,5}

# 交集:公共元素（&、intersection）
print(agr1.intersection(agr2)) # {1, 2, 3, -2}
# print(agr1.intersection(agr3)) # {1, 2, 3, -2}
print(agr2 & agr1) # {1, 2, 3, -2}
# print(agr1 & agr2) # {1, 2, 3, -2}

2.1 交集并更新到集合中：公共元素==>更新到集合

agr1 = {1,2,3,4}
agr2 = {3,4,5,6}

# 交集并更新到agr2
# agr2.intersection_update(agr1)
# print(agr2) # {3, 4}

# 交集并更新到agr1
# agr1.intersection_update(agr2)
# print(agr1) # {3, 4}

3.差集：自身独有元素（-、difference）

agr1 = {-2,-1,0,1,2,3}
agr2 = {-2,1,2,3,4,5}

# 差集：独有元素（-、difference）
# 差集：set2独有的成员
print(agr2.difference(agr1)) # {4, 5}
print(agr2 - agr1) # {4, 5}
# 差集：set1独有的成员
print(agr1.difference(agr2)) # {0, -1}
print(agr1 - agr2) # {0, -1}

3.1 差集并更新到集合中：独有成员==>更新到集合

agr1 = {1,2,3,4}
agr2 = {3,4,5,6}

# 差集并更新到agr1
# agr1.difference_update(agr2)
# print(agr1) # {1, 2}

# 差集并更新到agr2
# agr2.difference_update(agr1)
# print(agr2) # {5, 6}

4.反差集（对称差集:^、symmetric_difference()

俩集合各自独有元素之和，即不包含共有的其它元素之和。
也可以理解，先差集，再取反。即：各自独有的成员集合((s1-s2)+(s2-s1))。

agr1 = {1, 2, 3, 4}
agr2 = {3, 4, 5, 6}

# 反差集（对称差集）：^、symmetric_difference()
print(agr1.symmetric_difference(agr2)) # {1, 2, 5, 6}
# print(agr2.symmetric_difference(agr1)) # {1, 2, 5, 6}
print(agr1 ^ agr2) # {1, 2, 5, 6}
# print(agr2 ^ agr1) # {1, 2, 5, 6}

4.1 反差集(对称差集)并更新到集合中

先差集，再取反，最后将结果更新到集合中

agr1 = {1, 2, 3, 4}
agr2 = {3, 4, 5, 6}

# 反差集（对称差集）并更新到集合中
# agr1.symmetric_difference_update(agr2)
# print(agr1) #　{1, 2, 5, 6}
# agr2.symmetric_difference_update(agr1)
# print(agr2) # {1, 2, 5, 6}

八、集合的判断

1.判断成员运算符（单个）：in 、not in

agr = {1,2,3,'chenkk','zijun',(2,3,8)}
print(agr)
print(1 in agr)
print(2 in agr)
print(3 in agr)
print(4 in agr)
print(4 not in agr)
print('chenkk' not in agr)
print('chenkk'  in agr)
#Output
#{1, 2, 3, 'zijun', 'chenkk', (2, 3, 8)}
#True
#True
#True
#False
#True
#False
#True

2.判断子集、超集：issubset()、issuperset()

• 判断集合A所有元素都在集合B中 / 判断子集：issubset()

agr1 = {1,2,3,4,5,6,7}
agr2 = {2,3}
print(agr1.issubset(agr2)) # False
print(agr2.issubset(agr1)) # True

• 判断超集：issuperset()

agr1 = {1,2,3,4,5,6,7}
agr2 = {2,3}
print(agr1.issuperset(agr2)) # True，表示agr1是set2的超集
print(agr2.issuperset(agr1)) # False，表示agr2不是agr1的超集

3.判断两个集合之间关系：>、>=、<、<=

s1 = {1, 2, 3, 4, 5}
s2 = {1, 2, 3}
print(s1 < s2)  # False，检测集合s1是否为s2的真子集,s1 <= s2 and s1 != s2
print(s1 <= s2)  # False，检测是否集合s1中的每个元素都在s2中
print(s1 > s2)  # True s1是s2的超集
print(s1 >= s2) # True