目录
内置函数symmetric_difference_update
集合的定义
用{}作为边界逗号作为分隔符,只能容纳不可变的数据类型,如:{},{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'}
冻结集合也可以使用成员运算符,用法跟集合一模一样。
冻结集合也可以使用成员运算符,用法跟集合一模一样。虽然冻结集合是不可变的,但它并非真正的不可变数据类型。它的本质还是集合,只不过是不能修改元素的集合而已。