python基本数据类型--集合（set）

目录

集合的定义

python内置函数

内置函数len

内置函数min

内置函数max

 内置函数del

列表类内置函数

增加元素

内置函数add

内置函数update 

清空集合

内置函数clear

删除元素

内置函数remove

 内置函数discard

内置函数pop

复制集合

内置函数copy

求并集

内置函数union

求交集

内置函数isdisjoint

内置函数intersection

内置函数intersection_update

求差集

内置函数difference

内置函数difference_update

求对称差集

内置函数symmetric_difference

内置函数symmetric_difference_update

子集判断

内置函数issubset

内置函数issuperset

集合 计算运算符

运算符（|）

运算符（&）

运算符（-）

运算符（^）

集合 成员运算符

成员运算符（in）

成员运算符（not in）

集合 身份运算符

身份运算符（is）

身份运算符（is not）

要注意内存地址相同的可变对象

冻结集合（frozenset）

---

集合的定义

        用{}作为边界逗号作为分隔符，只能容纳不可变的数据类型，如：{}，{1, 2, 'abc', (1, 2, 3)}等等，是可迭代的数据类型，可以被修改，集合中的元素排列方式是无序的。我们可以使用下面两种方式来定义集合。

第一种：直接使用{}

set1 = {1, 2, 3, 'hello', 'world', 'name'}
print(set1)  # {1, 2, 3, 'name', 'world', 'hello'}

从打印的结果，我们可以发现集合是无序的。因为打印出来的集合跟我们定义集合有区别，它们的元素排列顺序不完全相同。它不像列表、元组、字典一样，定义时是什么顺序打印出来就是什么顺序，集合中的元素没有固定的顺序，随时都可能发生改变。

        我们不能用{}表示空集合，因为{}表示空字典。请看如下代码：

set1 = {}
print(type(set1))  # <class 'dict'>

我们可以使用python内置函数type来查看对象的类型，通过type函数我们可以发现set1的类型是字典。       

        第二种：使用set函数

set1 = set('abcde')
print(set1)  # {'c', 'a', 'e', 'd', 'b'}
list1 = [1, 2, 'abc']
set2 = set(list1)
print(set2)  # {1, 2, 'abc'}
set3 = set()
print(set3)  # set()

set函数可以把一个可迭代对象中的每一个元素都取出来，变成一个集合。字符串是可迭代的对象，所以set把字符串'abcde'中的每一个元素都取出来，组成了集合set1。列表是可迭代的对象，set把列表list1中的每一个元素都取出来，组成了集合set2。set()表示空集合。

         集合中的元素具有唯一性，类似于字典中的键，因此集合中的元素必须是不可变的数据类型。在定义集合时，如果里面有多个相同的元素，只会保留其中一个元素。

set1 = {'hello', 'world', 'haha', 'hello', 'xixi', 'hello}
print(set1)  # {'hello', 'xixi', 'world', 'haha'} 每次打印都会有不同的结果，因为集合是无序的

定义的时候有3个字符串都是'hello'，但集合只会保留一个。我们常常利用集合的这个特性，来帮列表去除重复元素。

list1 = [1, 2, 3, 'a', 'b', 'c', 1, 'a', 2]
print(list1)  # [1, 2, 3, 'a', 'b', 'c', 1, 'a', 2]
set1 = set(list1)
list1 = list(set1)
print(list1)  # [1, 2, 3, 'c', 'a', 'b']

set函数可以把可迭代对象变成集合，因为集合中的元素具有唯一性，就会把重复的元素去掉。list函数可以把可迭代对象变成列表，所以我们就能得到一个去除重复元素的列表了。

        因为集合是无序的，每个元素的位置都不固定，所以集合不能被索引和切片。

python内置函数

len()	返回集合的长度（元素个数）
min()	返回集合中值最小的元素（所有元素必须有可比性）
max()	返回集合中值最大的元素（所有元素必须有可比性）
del	删除集合

内置函数len

        我们向len函数传入一个集合，它会返回这个列表的长度（整型）。

set1 = {1, 2, 3, 'a', 'b', 'c'}
print(len(set1))  # 6

内置函数min

        我们向min函数传入一个集合，它会返回这个集合中值最小的元素，前提是这个集合中的所有元素必须具有可比性。比如所有的元素全都是数字，全都是字符串。

set1 = {4, 2, 6, 1, 5, 3}
print(min(set1))  # 1
set2 = {'c', 'a', 'd', 'e', 'b'}
print(min(set2))  # a

如果这个集合中的元素不具有可比性就会报错，例如整型和字符串是不能比较大小的。

set1 = {1, 2, 3, 'a', 'b', 'c'}
print(min(set1))

执行结果如下：

报错显示类型错误，字符串和整型不能比较大小。

内置函数max

        我们向max函数传入一个集合，它会返回这个集合中值最大的元素，前提是这个集合中的所有元素必须具有可比性。比如所有的元素全都是数字，全都是字符串。

set1 = {4, 2, 6, 1, 5, 3}
print(max(set1))  # 6
set2 = {'c', 'a', 'd', 'e', 'b'}
print(max(set2))  # e

 内置函数del

        函数del可以删除整个集合，当我们删除整个集合之后，就不能再使用这个集合了，因为这个集合已经不存在了。当我们是用del删除集合后再去打印这个集合就会报错。

set1 = {4, 2, 6, 1, 5, 3}
del set1
print(set1)

执行结果如下：

报错显示变量名错误，变量set1未定义。因为set1已经被整个删除掉了，所以在内存中找不到set1。 

列表类内置函数

        集合类内置函数是在集合这个类型中定义的函数，所以想要使用这些函数，前提是使用的对象必须是一个集合。

增加元素

内置函数add

        我们给add函数传入一个不可变的对象，它可以把这个对象添加到集合中，前提是集合中没有跟这个对象值相同的元素。

set1 = {3, 2, 'abc'}
set1.add('hello')
print(set1)  # {2, 3, 'hello', 'abc'}

如果集合中已经存在了跟这个对象值相同的元素，则不会添加，因为集合中的元素具有唯一性。

set1 = {3, 2, 'abc'}
set1.add(3)
print(set1)  # {2, 3, 'abc'}

如果传入一个可变对象，就会报错。

set1 = {3, 2, 'abc'}
set1.add([3])
print(set1)

执行结果如下：

报错显示类型错误，列表不是可以哈希的类型。

内置函数update 

        我们给函数update传入一个集合set_，它会把set_中的元素添加到当前集合中。

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

如果set_中存在跟当前集合相同的元素，相同的元素将不会被添加，因为集合中的元素具有唯一性。

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

        当我们要把多个集合中的元素添加到当前集合中时，就给update函数传入多个集合。

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

清空集合

内置函数clear

        clear函数可以清空集合中的所有元素，把当前集合变成一个空集合。

set1 = {1, 2, 3, 'abc'}
set1.clear()
print(set1)  # set()

set()表示的就是空集合，{}表示空字典，不要搞错了。

删除元素

内置函数remove

        remove函数可以删除集合中指定的元素，我们想删除集合中的那个元素，就给remove函数传入相同的值来指定元素。

set1 = {1, 2, 3, 'abc'}
set1.remove('abc')
print(set1)  # {1, 2, 3}

当集合中不存在指定的元素时，会报错。

set1 = {1, 2, 3, 'abc'}
set1.remove('hello')
print(set1)

执行结果如下：

报错显示值错误，字符串'hello'不在集合set1中。

 内置函数discard

        discard函数跟remove函数类似，也可以删除集合中指定的元素，我们想删除集合中的那个元素，就给discard函数传入相同的值来指定元素。

set1 = {1, 2, 3, 'abc'}
set1.discard('abc')
print(set1)  # {1, 2, 3}

discard函数跟remove函数不同的地方在于，当集合中不存在指定的元素时，会忽略要删除的元素，不会报错。

set1 = {1, 2, 3, 'abc'}
set1.discard('hello')
print(set1)  # {1, 2, 3, 'abc'}

内置函数pop

        函数pop可以随机删除集合中的一个元素，本来pop是删除集合中的最后一个元素，但是集合中的元素是无序的，任何一个元素都有可能是最后一个元素，所以pop变成了随机删除一个元素。

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

复制集合

内置函数copy

        函数copy可以复制当前集合，并返回一个复制集合，我们需要用一个变量来接收返回回来的复制集合。

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

求并集

内置函数union

        我们给union函数传入一个集合set_，它会把当前集合与set_的合并起来，变成一个新的集合，再返回这个新集合。我们需要使用一个变量来接收这个新集合，如果不接收就得不到当前集合与set_的并集。

set1 = {1, 2, 3, 'a', 'b', 'c'}
set2 = {1, 2, 'hello', 'world'}
set3 = set1.union(set2)
print(set3)  # {1, 2, 3, 'a', 'world', 'b', 'hello', 'c'}

set3就是set1和set2 的并集。

        当我们需要求多个集合与当前集合的并集时，就把多个集合都传入union函数。

set1 = {1, 2, 3, 'a', 'b', 'c'}
set2 = {1, 2, 'hello', 'world'}
set3 = {1, 'abc'}
set4 = set1.union(set2, set3)
print(set4)  # {1, 2, 3, 'a', 'c', 'world', 'hello', 'abc', 'b'}

        内置函数update也相当于求并集，只不过它求出的并集会更新到当前集合。好处是我们不需要额外的变量来接收并集；坏处是当前集合中的元素被改变，后面要使用当前集合时，要注意当前集合已不是更新前的集合了。

求交集

内置函数isdisjoint

        我们给isdisjoint函数传入一个集合set_，它会判断出当前集合与set_是否存在相同的元素，如果存在相同的元素就返回False，如果不存在相同的元素就返回True。

set1 = {1, 2, 3, 'a', 'b', 'c'}
set2 = {1, 2, 'hello', 'world'}
print(set1.isdisjoint(set2))  # False

set1和set2中存在相同的元素1、2，所以set1.isdisjoint(set2)返回False。

set1 = {1, 2, 3, 'a', 'b', 'c'}
set2 = {5, 'abc'}
print(set1.isdisjoint(set2))  # True

set1和set2中不存在相同的元素，所以set1.isdisjoint(set2)返回True。

内置函数intersection

        我们给intersection函数传入一个集合set_，它会找出当前集合与set_共有的元素，再返回这些共有元素组成的新集合。我们需要使用一个变量来接收这个新集合，如果不接收就得不到当前集合与set_的交集。

set1 = {1, 2, 3, 'a', 'b', 'c'}
set2 = {1, 2, 'hello', 'world'}
set3 = set1.intersection(set2)
print(set3)  # {1, 2}

set3就是set1和set2 的交集，1、2是集合set1和set2中都存在的元素。

        当我们需要求多个集合与当前集合的交集时，就把多个集合都传入intersection函数。

set1 = {1, 2, 3, 'a', 'b', 'c'}
set2 = {1, 2, 'hello', 'world'}
set3 = {1, 'abc'}
set4 = set1.intersection(set2, set3)
print(set4)  # {1}

如果当前集合跟要求交集的集合没有交集时，返回空集合。

set1 = {1, 2, 3, 'a', 'b', 'c'}
set2 = {1, 2, 'hello', 'world'}
set3 = {5, 'abc'}
set4 = set1.intersection(set2, set3)
print(set4)  # set()

set1与set2存在交集{1, 2}，set1与set3不存在交集，所以set1与set2和set3不同时存在交集。即set1与set2和set3的交集为空集合。

内置函数intersection_update

        我们给intersection_update函数传入一个集合set_，它会找出当前集合与set_共有的元素，再把这些共有元素更新到当前集合中，把当前集合变为前集合与set_的交集。

set1 = {1, 2, 3, 'a', 'b', 'c'}
set2 = {1, 2, 'hello', 'world'}
set1.intersection_update(set2)
print(set1)  # {1, 2}

set1就是set1和set2 的交集，1、2是集合set1和set2中都存在的元素。

        当我们需要求多个集合与当前集合的交集时，就把多个集合都传入intersection函数。

set1 = {1, 2, 3, 'a', 'b', 'c'}
set2 = {1, 2, 'hello', 'world'}
set3 = {1, 'abc'}
set1.intersection_update(set2, set3)
print(set1)  # {1}

求差集

内置函数difference

        我们给difference函数传入一个集合set_，它会找出当前集合中存在但set_中不存在的元素，再返回这些元素组成的新集合。我们需要使用一个变量来接收这个新集合，如果不接收就得不到当前集合与set_的差集。

set1 = {1, 2, 3, 'a', 'b', 'c'}
set2 = {1, 2, 'hello', 'world'}
set3 = set1.difference(set2)
print(set3)  # {'c', 'a', 3, 'b'}

set3就是set1和set2 的差集，'c'、'a'、3、'b'都是集合set1中存在但set2中不存在的元素。

        当我们需要求多个集合与当前集合的差集时，就把多个集合都传入difference函数。

set1 = {1, 2, 3, 'a', 'b', 'c'}
set2 = {1, 2, 'hello', 'world'}
set3 = {'a', 5, 6}
set4 = set1.difference(set2, set3)
print(set4)  # {'c', 3, 'b'}

set4就是set1与set2和set3的差集，'c'、3、'b'都是集合set1中存在但set2和set3中不存在的元素。

内置函数difference_update

        我们给difference_update函数传入一个集合set_，它会找出当前集合中存在但set_中不存在的元素，再把这些元素更新到当前集合中，把当前集合变为当前集合与set_的差集。

set1 = {1, 2, 3, 'a', 'b', 'c'}
set2 = {1, 2, 'hello', 'world'}
set1.difference_update(set2)
print(set1)  # {3, 'a', 'b', 'c'}

set1就是set1和set2 的差集，3、'a'、'b'、'c'都是集合set1中存在但set2中不存在的元素。

        当我们需要求多个集合与当前集合的差集时，就把多个集合都传入difference_update函数。

set1 = {1, 2, 3, 'a', 'b', 'c'}
set2 = {1, 2, 'hello', 'world'}
set3 = {'a', 5, 6}
set1.difference_update(set2, set3)
print(set1)  # {3, 'c', 'b'}

求对称差集

        对称差集的定义：现有两个集合A和B，把集合A与B的差集C跟集合B与A的差集D组合成一个集合E，集合E即集合A和B的对称差集。

内置函数symmetric_difference

        我们给symmetric_difference函数传入一个集合set_，它会去掉当前集合与set_相同的元素，把当前集合和set_中剩余的元素组成一个新集合，再返回新集合。我们需要一个变量来接收新集合，如果不接收就得不到当前集合与set_的对称差集。

set1 = {1, 2, 3, 'a', 'b', 'c'}
set2 = {1, 2, 3, 'hello'}
set3 = set1.symmetric_difference(set2)
print(set3)  # {'b', 'a', 'c', 'hello'}

set1与set2中相同的元素是1、2、3，set1去除元素1、2、3后剩余元素'a'、'b'、'c'，set2去除元素1、2、3后剩余元素'hello'。把set1和set2中剩余元素组合成新集合{'a'、'b'、'c'，'hello'}，这个集合就是set1和set2的对称差集。

内置函数symmetric_difference_update

        我们给difference_update函数传入一个集合set_，它会去掉当前集合与set_相同的元素，再把当前集合和set_中剩余的元素更新到当前集合中，把当前集合变为当前集合与set_的对称差集。

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

set1与set2中相同的元素是1、2、3，set1去除元素1、2、3后剩余元素'a'、'b'、'c'，set2去除元素1、2、3后剩余元素'hello'。把set1和set2中剩余元素更新到set1中，set1就变成了{'a'、'b'、'c'，'hello'}。

子集判断

内置函数issubset

        我们给issubset函数传入一个集合set_，它会判断出当前集合是不是set_的子集。如果当前集合中所有元素在set_中都能找到，那么当前集合是set_的子集，返回True；如果当前集合中所有元素在set_中只能找到一部分或完全找不到，那么当前集合不是set_的子集，返回False。

set1 = {1, 2, 3}
set2 = {1, 2, 3, 'hello', 'abc'}
print(set1.issubset(set2))  # True

set1中的所有元素1、2、3在set2中都能找到，所以set1是set2的子集，返回True。

set1 = {1, 2, 3, 4}
set2 = {1, 2, 3, 'hello', 'abc'}
print(set1.issubset(set2))  # False

set1中的元素1、2、3在set2中能找到，但set1中的元素4在set2中找不到，所以set1不是set2的子集，返回False。

set1 = {'a', 'b', 'c'}
set2 = {1, 2, 3, 'hello', 'abc'}
print(set1.issubset(set2))  # False

set1中的所有元素'a'、'b'、'c'在set2中完全找不到，所以set1不是set2的子集，返回False。

内置函数issuperset

        我们给issuperset函数传入一个集合set_，它会判断出set_是不是当前集合的子集。如果set_中所有元素在当前集合中都能找到，那么set_是当前集合的子集，返回True；如果set_中所有元素在当前集合中只能找到一部分或完全找不到，那么set_不是当前集合的子集，返回False。

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

set2中的所有元素1、2、3在set1中都能找到，所以set2是set1的子集，返回True。

set1 = {1, 2, 3, 'a', 'b', 'c'}
set2 = {1, 2, 3, 4}
print(set1.issuperset(set2))  # False

set2中的元素1、2、3在set1中能找到，但set2中的元素4在set1中找不到，所以set2不是set1的子集，返回False。

set1 = {1, 2, 3, 'a', 'b', 'c'}
set2 = {5, 6, 7}
print(set1.issuperset(set2))  # False

set2中的所有元素5、6、7在set1中完全找不到，所以set2不是set1的子集，返回False。

集合 计算运算符

|	求并集
&	求交集
-	求差集
^	求对称差集

运算符（|）

        |用于求左右两个集合的并集。

set1 = {1, 2, 3, 'a', 'b', 'c'}
set2 = {1, 2, 3, 'hello'}
set3 = set1 | set2
print(set3)  # {'a', 1, 2, 3, 'hello', 'c', 'b'}

运算符（&）

        &用于求左右两个集合的交集。

set1 = {1, 2, 3, 'a', 'b', 'c'}
set2 = {1, 2, 3, 'hello'}
set3 = set1 & set2
print(set3)  # {1, 2, 3}

运算符（-）

        -用于求左右两个集合的差集。

set1 = {1, 2, 3, 'a', 'b', 'c'}
set2 = {1, 2, 3, 'hello'}
set3 = set1 - set2
print(set3)  # {'c', 'a', 'b'}
set4 = set2 - set1
print(set4)  # {'hello'}

运算符（^）

        ^用于求左右两个集合的对称差集。

set1 = {1, 2, 3, 'a', 'b', 'c'}
set2 = {1, 2, 3, 'hello'}
set3 = set1 ^ set2
print(set3)  # {'a', 'hello', 'b', 'c'}

集合 成员运算符

        成员运算符是用来判断某个python对象是否跟某个序列（可迭代对象）中的某个元素的值相同。也可以理解成是否在这个集合中，但其实看的还是元素的值是否有和这个python对象的值一样的情况。

in	判断某个对象是否在集合中，在则返回True，不在则返回False
not in	判断某个对象是否不在集合中，不在则返回True，在则返回False

成员运算符（in）

        当某个python对象跟某个序列（可迭代对象）中的某个元素的值相同时，返回True；找不到相同值的元素时，返回False。

set1 = {1, 2, 3, 'a', 'b', 'c'}
print(1 in set1)  # True
set2 = {'hello', 'abc'}
print(1 in set2)  # False

集合set1中有一个元素的值为1，所以1 in set1返回True。集合set2中没有一个元素的值为1，所以1 in set2返回False。

成员运算符（not in）

        当某个python对象在某个序列（可迭代对象）中找不到值相同的元素时，返回True；找到相同值的元素时，返回False。

set1 = {1, 2, 3, 'a', 'b', 'c'}
print(1 not in set1)  # False
set2 = {'hello', 'abc'}
print(1 not in set2)  # True

集合set1中有一个元素的值为1，所以1 not in set1返回False。集合set2中没有一个元素的值为1，所以1 not in set2返回True。

集合 身份运算符

        身份运算符可以判断两个集合的内存地址是否一致。因为集合是可变的数据类型，所以即使两个集合的值是相等的，它们的内存地址也可能不同。

is	判断左右两边的内存地址是否相同，相同返回True，否则返回False
is not	判断左右两边的内存地址是否不同，不同返回True，否则返回False

身份运算符（is）

        is用于判断左右两个对象的内存地址是否相同，如果相同返回True，不同返回False。举个例子，请看下面的代码：

set1 = {1, 2, 3, 'a', 'b', 'c'}
set2 = {1, 2, 3, 'a', 'b', 'c'}
print(id(set1))  # 2795614387104
print(id(set2))  # 2795614384640
print(set1 is set2)  # False

set1和set2是相等的，但它们的内存地址不同。它们存储在内存中不同的地方，这就是可变数据类型的特性。

        我们使用集合类内置函数copy来复制集合，复制出来的集合和原集合内存地址也不相同。

set1 = {1, 2, 3, 'a', 'b', 'c'}
set2 = set1.copy()
print(id(set1))  # 1973089745824
print(id(set2))  # 1973089743360
print(set1 is set2)  # False

        通过赋值运算符（=）赋值出来的集合内存地址是相同的。

set1 = {1, 2, 3, 'a', 'b', 'c'}
set2 = set1
print(id(set1))  # 2456719342496
print(id(set2))  # 2456719342496
print(set1 is set2)  # True

身份运算符（is not）

        is not用于判断左右两个对象的内存地址是否不同，如果不同返回True，相同返回False。举个例子，请看下面的代码：

set1 = {1, 2, 3, 'a', 'b', 'c'}
set2 = {1, 2, 3, 'a', 'b', 'c'}
print(id(set1))  # 1841428773792
print(id(set2))  # 1841428774464
print(set1 is not set2)  # True
set3 = {1, 2, 3, 'a', 'b', 'c'}
set4 = set3.copy()
print(id(set3))  # 1841428773344
print(id(set4))  # 1841428774688
print(set3 is not set4)  # True
set5 = {1, 2, 3, 'a', 'b', 'c'}
set6 = set5
print(id(set5))  # 1841428774016
print(id(set6))  # 1841428774016
print(set5 is not set6)  # False

要注意内存地址相同的可变对象

         当两个集合的内存地址相同时，我们修改其中任意一个集合，另一个集合也会跟着改变。

set1 = {1, 2, 3, 'a', 'b', 'c'}
set2 = set1
set2.add('hello')
print(set1)  # {1, 2, 3, 'hello', 'c', 'b', 'a'}
print(set2)  # {1, 2, 3, 'hello', 'c', 'b', 'a'}
set1.remove(1)
print(set1)  # {2, 3, 'hello', 'c', 'b', 'a'}
print(set2)  # {2, 3, 'hello', 'c', 'b', 'a'}

冻结集合（frozenset）

        冻结集合是不可变的，冻结集合在被定义后我们就不能再修改里面的元素了。冻结集合除了不能修改元素以外，其他的性质和集合一样。冻结集合也可以跟集合之间求并集、交集、差集、对称差集、判断是否相交、判断是否是子集。

        冻结集合的定义：使用frozenset函数

set1 = frozenset('abcdef')
print(set1)  # frozenset({'b', 'c', 'd', 'a', 'e', 'f'})
set2 = frozenset()
print(set2)  # frozenset() 空冻结集合

frozenset函数可以把一个可迭代对象中的每一个元素都取出来，变成一个冻结集合。字符串是可迭代的对象，所以set把字符串'abcdef'中的每一个元素都取出来，组成了冻结集合set1。frozenset()表示空冻结集合。

        冻结集合类的内置函数

copy	复制当前冻结集合
union	求当前冻结集合与其他集合的并集
isdisjoint	判断当前冻结集合与其他集合是否相交
intersection	求当前冻结集合与其他集合的交集
difference	求当前冻结集合与其他集合的差集
symmetric_difference	求当前冻结集合与其他集合的对称差集
issubset	判断当前冻结集合是不是set_的子集
issuperset	判断set_是不是当前冻结集合的子集

这些函数跟上面集合中的函数用法一模一样，具体用法参考上面集合中的介绍。但需要注意一点，集合中的内置函数返回的都是集合，冻结集合中的内置函数返回的都是冻结集合。

set1 = frozenset('abcdef')
set2 = {'a', 1, 2}
set3 = set1.difference(set2)
print(set3)  # frozenset({'f', 'd', 'c', 'e', 'b'})
set4 = set2.difference(set1)
print(set4)  # {1, 2}

        冻结集合也可以使用用于计算的运算符（|、&、-、^），用法跟集合一模一样。但需要注意集合与冻结集合的计算，当集合在运算符左边时得到的是集合，冻结集合在运算符左边时得到的是冻结集合。

set1 = frozenset('abcdef')
set2 = {'a', 1, 2}
set3 = set1 | set2
print(set3)  # frozenset({1, 'd', 2, 'c', 'b', 'f', 'e', 'a'})
set4 = set2 | set1
print(set4)  # {1, 2, 'd', 'c', 'b', 'f', 'e', 'a'}

        冻结集合也可以使用成员运算符，用法跟集合一模一样。

        冻结集合也可以使用成员运算符，用法跟集合一模一样。虽然冻结集合是不可变的，但它并非真正的不可变数据类型。它的本质还是集合，只不过是不能修改元素的集合而已。