Python数据容器总结(集合部分)

一、集合的存储特点

集合是一个容器，最大的特点在于：

1、集合是去重的！其中不能包含重复的元素。

2、集合是无序的！元素添加的顺序和存储的顺序不一致。（即：无法使用下标来访问元素）

集合的创建

# 1. 通过字面量，创建一个set
set1 = {1, 2, 3, 4, 5}
print(type(set1), set1)

#    set集合中，不允许包含重复的元素
set2 = {1, 2, 2, 3, 3, 4, 4, 5}
print(type(set2), set2)

#    set集合中存储的数据是无序的（元素添加的顺序和存储的顺序是不一致的）
#    但是注意：这里的无序，不代表随机！
set3 = {"李云龙", "二营长", "意大利炮", "云飞兄"}
print(type(set3), set3)


# 2. 通过set()函数，可以将其他的容器，转成set
set4 = set("hello world")
print(type(set4), set4)


# 3. 注意事项：无法通过 {} 创建一个空集合，如果要创建空集合，只能使用 set()
set5 = {}
print(type(set5), set5)

二、集合的运算符

运算符	描述	示例
&	求交集，两个集合中都包含的元素。将结果保存在一个新的集合中返回。	{1, 2, 3} & {2, 3, 4}
|	求并集，两个集合中包含的所有元素。将结果保存在一个新的集合中返回。	{1, 2, 3} | {2, 3, 4}
-	求差集，左边集合包含，但是右边集合不包含的元素（左边的集合-交集）。将结果保存在一个新的集合中返回。	{1, 2, 3} - {2, 3, 4}
^	求对称集，并集 - 交集。将结果保存在一个新的集合中返回。	{1, 2, 3} ^ {2, 3, 4}
&=	计算交集，修改左边的集合。	s1 = {1, 2, 3} s1 &= {2, 3, 4}
|=	计算并集，修改左边的集合。	s1 = {1, 2, 3} s1 |= {2, 3, 4}
-=	计算差集，修改左边的集合。	s1 = {1, 2, 3} s1 -= {2, 3, 4}
^=	计算对称集，修改左边的集合。	s1 = {1, 2, 3} s1 ^= {2, 3, 4}
>	判断右边的集合，是否是左边集合的真子集。	{1, 2, 3, 4} > {1, 2, 3}
>=	判断右边的集合，是否是左边集合的子集。	{1, 2, 3, 4} >= {1, 2, 3}
<	判断左边的集合，是否是右边集合的真子集。	{1, 2, 3, 4} < {1, 2, 3}
<=	判断左边的集合，是否是右边集合的子集。	{1, 2, 3, 4} <= {1, 2, 3}
==	判断两个集合的元素是否相同。	{1, 2, 3, 4} == {1, 2, 3}
!=	判断两个集合的元素是否不同。	{1, 2, 3, 4} != {1, 2, 3}
in	判断元素是否在指定的集合中包含。	1 in {1, 2, 3}
not in	判断元素是否在指定的集合中不包含。	1 not in {1, 2, 3}

子集: 如果B集合中的所有元素都在A集合中包含，那么B就是A的子集

真子集: 如果A除了包含B集合中所有的元素之外，还有其他的元素，那么B就是A的真子集

 

"""
&   交集 把数据存储在一个新的集合中
|   并集 把数据存储在一个新的集合中
^   对称差 把数据存储在一个新的集合中
-   差集 把数据存储在一个新的集合中

&= 交集  修改前者
|= 并集  修改前者
^= 对称差  修改前者
-= 差集  修改前者

子集: 如果B集合中的所有元素都在A集合中包含，那么B就是A的子集
真子集: 如果A除了包含B集合中所有的元素之外，还有其他的元素，那么B就是A的真子集

>   判断后者是否为前者的真子集
>=  判断后者是否为前者的子集
<   判断前者是否为后者的真子集
<=  判断前者是否为后者的子集
==  判断两个集合数据是否一样
!=  判断两个集合数据是否不一样

in  判断元素是否包含在集合中
not in  判断元素是否不包含在集合中
id 获取地址
is 判断地址是否一致
not is 判断地址是否不止一致
"""

s1 = {1, 2, 3, 4, 5}
s2 = {3, 4, 5, 6, 7}

print(s1 & s2)      # 3, 4, 5
print(s1 | s2)      # 1, 2, 3, 4, 5, 6, 7
print(s1 - s2)      # 1, 2
print(s1 ^ s2)      # 1, 2, 6, 7

s3 = {1, 2, 3, 4, 5}
s4 = {2, 3, 4, 5}

print(s3 > s4)      # 判断是否是真子集
print(s3 >= s4)     # 判断是否是子集

print(s3 == s4)     # 判断两个集合中的元素是否相同

print(3 in s3)      # 判断是否包含

集合的操作

函数	描述	示例
add	添加元素	s1 = {} s1.add(1)
remobe	删除元素 如果要删除的元素不存在，报错	s1 = {1, 2, 3} s1.remove(2)
discard	删除元素 如果要删除的元素不存在，不报错	s1 = {1, 2, 3} s1.discard(2)
clear	清空集合	s1 = {1, 2, 3} s1.clear()
isdisjoint	判断两个集合是否不存在交集	s1 = {1, 2, 3} s2 = {4, 5, 6} s1.isdisjoint(s2)
copy	拷贝一个集合	s1 = {1, 2, 3} s1.copy()

# 创建一个集合
set1 = {1, 2, 3, 4, 5}

# 添加元素
set1.add(6)

# 删除元素
# remove函数，在删除的时候，如果集合中不包含这个元素，删除会报错
set1.remove(5)
# discard函数，在删除的时候，如果集合中不包含这个元素，没有任何反应
set1.discard(5)

# 清空集合
# set1.clear()

# 判断两个集合，是否没有交集
print(set1.isdisjoint({7, 8, 9, 0}))

# 深拷贝
set1.copy()

print(set1)

三、集合的遍历

因为集合中没有下标的概念，因此对于集合的遍历，只有一种方式:

 

s1 = {1, 2, 3, 4, 5}

for n in s1:
    print(n)

四、不可变集合

frozenset: 表示不可变集合，类似于tuple，不可以修改集合中的元素，不可以增加、删除元素

# 不可变集合，与集合的关系，类似于tuple和list
s1 = frozenset({1, 2, 3, 4, 5})
print(type(s1), s1)

s2 = frozenset([3, 4, 5, 6, 7])
print(type(s2), s2)

print(s1 & s2)
print(s1 | s2)