Python可变集合 python不可变集合

集合

概念：集合是一个无序的（无法通过索引来进行访问），不可随机访问的（无法通过索引来进行访问），不可重复的元素集合 s = {1，2，3}

类似于数学中的集合的概念，并且集合分为可变集合和非可变集合，可变集合可以进行增删改等操作，不可变集合创建好之后无法继续进行增删改

定义

• 可变集合 方式一：直接定义；方式二：用set来转换 方式三;集合推导式

#方式一
s = {1,2,3,4,5}
print(s,type(s))

#方式二
s1 = set('abc')  #set集合本身就是无序的
s2 = set([1,2,3])
s3 = set((1,2,3))
s4 = set({'a':1,'b':2})
print(s1)
print(s2)
print(s3)
print(s4)

#方式三
s5 = set(x for x in range(1,10))
print(s5,type(s5))

• 不可变集合frozenset

相比于可变集合，没有了方法一

s = frozenset('abc')
print(s,type(s))

s1 = frozenset(i**2 for i in range(1,10) if i%2 ==0)
print(s1,type(s1))

集合注意事项

s = {}
print(s,type(s))

s1 = set()
print(s1,type(s1))

集合的常用操作

• 单一集合的操作：操作是某一个集合

• 集合的增操作 set.add（元素） 集合内部的元素必须是可哈希的，或者说是不可变的
• 集合的删除操作：

s = {1,2,3}
print(s)
s.add(4)
print(s,type(s))

• 集合的删除操作：1. set.remove（元素）从集合中删除一个指定的元素，如果元素不存在，则返回一个错误，返回值是个None；2. set.discard(元素) 指定删除集合中的一个元素，若没有这个元素，则啥也不做；3. set.pop（元素）随机删除并且返回一个集合中的元素，若集合为空，则返回一个错误。4. set.clear，清空一个集合中所有的元素

#方法一
s = {1,2,3}
s.remove(3)
print(s)
#方法二
s1 = {1,2,3}
s1.discard(4)
print(s1)

#方法三
s2 = {1,2,3}
s2.pop()
print(s2)
#方法四
s3 = {1,2,3,4}
s3.clear()
print(s3)

• 集合的修改和查询操作：
  首先集合没法修改，元素都是为不可变的类型；并且无法通过索引或者key来进行查询
  但是可以进行遍历操作；
  一个是用for in来遍历，另一个方法是用迭代器来进行遍历；

s = {1,2,3}
for v in s:
    print(v)


print('方法二--------------------------------------------------')
#用迭代器来进行遍历
s1 = {1,2,3,4,5}
#1. 先生成一个迭代器 （）
it = iter(s)
#2. 对迭代器进行遍历，用next()函数或者for in均可
print(next(it))
print('--------------迭代器迭代完成后就不会输出任何值了-----------------')
for a in it:
    print(a)

• 集合之间的操作：给多个集合，求集合之间的交集并集等等。

• 交集操作 方法一：set.intersection（集合）；方法二：&； 方法三：set1.intersection_update(set2)交集计算完成后，会再次赋值给原来对象，会改变原来对象，所以只适用于可变集合。

#方法一
s = {1,2,3,4,5}
s1 = {4,5,6}
result = s.intersection(s1)
print(result,type(result))

#方法二
result1 = s&s1
print(result1,type(result1))
#方法三
s.intersection_update(s1)
print(s)

括号里面必须是可迭代的，并且是可哈希的

• 并集操作 ：union()：返回并集胡总和用逻辑或|，再者用update（集合）用来更新并集

s = {1,2,3,4,5}
s1 = {5,6,7,8,9}
result = s.union(s1)
print(result)

result1 =  s | s1
print(result1)

s.update(s1)
print(s)

下面代码我们可以看到，因为求并集的时候s1在前，并且s1是个不可变集合，所以最后并集之后也是不可变的；如果前面是个可变的集合那么最后形成的也是可变的集合。

s1 = frozenset([1,2,3])
print(s1,type(s1))
s2 = {3,4,5}
result = s1.union(s2)
print(result)

• 集合的差集 difference（）或者算数运算符减号’-‘来进行操作，difference_update()也可以

s1 = {1,2,3}
s2 = {3,4,5}
result = s1.difference(s2)
print(result)

result1 = s1-s2
print(result1)

print(s1)
s1.difference_update(s2)
print(s1)

• 集合的判定操作

s1.isdisjoint（s2）判定两个集合不相交
issuperset（）一个集合包含(完全包含而不是部分包含)另外一个集合
issubset（）一个集合包含于另外一个集合

s1 = {1,2,3}
s2 = {3,4,5}
result = s1.isdisjoint(s2)
print(result)

s3 = {1,2,3,4,5}
s4 = {3,4,5}
print(s3.issuperset(s4))

s5 = {1,2,3,4,5}
s6 = {3,4,5,6}
print(s5.issubset(s6))