Python基础---Set（集合）&Frozenset（不可变集合）

最新推荐文章于 2024-07-05 16:27:38 发布

原创最新推荐文章于 2024-07-05 16:27:38 发布 · 1.2k 阅读

2 ·

CC 4.0 BY-SA版权

Python 专栏收录该内容

49 篇文章

订阅专栏

本文介绍了Python中的两种集合类型：Set和Frozenset。Set是可变集合，不可作为字典键，而Frozenset是不可变且可哈希的，可用于字典键。它们共有的方法包括len(), in, not in, isdisjoint(), issubset(), issuperset(), union(), intersection(), difference()和symmetric_difference()。Frozenset独有的方法有copy()。Set特有的方法包括update(), intersection_update(), difference_update(), symmetric_difference_update(), add(), remove(), discard(), pop()和clear()。" 107460771,9898807,Java实现：找到随机数组的最大值和最小值,"['Java', '数组操作', '算法']

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

SET对象是由具有唯一性的 hashable 对象所组成的无序多项集，否则会报“unhashable type”的错误。目前有两种内置集合类型，set 和 frozenset。 set 类型是可变的 --- 其内容可以使用 add() 和 remove() 这样的方法来改变。由于是可变类型，它没有哈希值，且不能被用作字典的键或其他集合的元素。 frozenset 类型是不可变并且为 hashable --- 其内容在被创建后不能再改变；因此它可以被用作字典的键或其他集合的元素。

s1={"aa","bb","aa","cc","dd","aa"}
print(s1)  # {'aa', 'bb', 'cc', 'dd'}


# s2=set('apple', 'orange', 'apple', 'pear', 'orange', 'banana')
# print(s2)  # 报错：TypeError: set expected at most 1 arguments, got 6

list2=('apple', 'orange', 'apple', 'pear', 'orange', 'banana')
s2=set(list2)
print(s2)  # {'banana', 'apple', 'pear', 'orange'} 里面的值随机排序

str3="ksjfskfwefwkefwk"
s3=set(str3)
print(s3)  # {'e', 'k', 'j', 'w', 's', 'f'}
s3.add("a")
print(s3)  # {'f', 's', 'e', 'j', 'w', 'a', 'k'}

tup4=(1,2,3,2,1,"a",'a','b',"c")
s4=set(tup4)
print(s4)  # {1, 2, 3, 'a', 'c', 'b'}

temp={"a","aa","a"}
print(type(temp))  # <class 'set'>
s5=set(temp)
print(s5)  # {'a', 'aa'}
print(type(s5))  # <class 'set'>

# temp={"a","aa","a",["b","b","bbb"]}
# print(type(temp))  #报错：TypeError: unhashable type: 'list
# s5=set(temp)
# print(s5)  # {'a', 'aa'}
# print(type(s5))  # <class 'set'>

set和 frozenset共有的方法：

1.len(s)：返回集合中的元素个数

s1={"aa","bb","aa","cc","dd","aa"}
s2=frozenset({"aa","bb","aa","cc","dd","aa"})
print(s1)  # {'aa', 'cc', 'bb', 'dd'}
print(s2)  # frozenset({'aa', 'cc', 'bb', 'dd'})
print(len(s1))  # 4
print(len(s2))  # 4

2.x in s：检测元素x是否在集合s中

s1={"aa","bb","aa","cc","dd","aa"}
s2=frozenset({"aa","bb","aa","cc","dd","aa","e"})

print("aa" in s1)  # True
print("aa" in s2)  # True
print("e" in s1)  # False
print("e" in s2)  # True

3.x not in s：检测元素x是否不在集合s中

s1={"aa","bb","aa","cc","dd","aa"}
s2=frozenset({"aa","bb","aa","cc","dd","aa","e"})

print("aa" not in s1)  # False
print("aa" not in s2)  # False
print("e" not in s1)  # True
print("e" not in s2)  # False

4.s1 isdisjoint(s2)：判断两个集合s1和s2是否包含相同的元素，如果没有返回 True，否则返回 False

s1={"aa","bb","aa","cc","dd","aa"}
s2=set({"aa","bb","aa","cc","dd","aa","e"})
print(s1.isdisjoint(s2))  # False

s1={"aa","bb","aa","cc","dd","aa"}
s2=set({"a3a","bab","a1a","c3c","d3d","a2a","e"})
print(s1.isdisjoint(s2))  # True


s1={"aa","bb","aa","cc","dd","aa"}
s2=frozenset({"aa","bb","aa","cc","dd","aa","e"})
print(s1.isdisjoint(s2))  # False


s1={"aa","bb","aa","cc","dd","aa"}
s2=frozenset({"a3a","bab","a1a","c3c","d3d","a2a","e"})
print(s1.isdisjoint(s2))  # True

#---------------------------------------------------------------------#

# 非集合类型：

s1 = {"apple", "banana", "cherry"}
s2 = ("google", "runoob", "apple")
print(s1)  # {'banana', 'cherry', 'apple'}
s = s1.isdisjoint(s2)
print(s)  # False

s1 = {"apple", "banana", "cherry"}
s2 = (("google", "runoob", "apple"))
print(s1)  # {'banana', 'cherry', 'apple'}
s = s1.isdisjoint(s2)
print(s)  # False

s1 = {"apple", "banana", "cherry"}
s2 = "apple"
print(s1)  # {'banana', 'cherry', 'apple'}
s = s1.isdisjoint(s2)
print(s)  # True

s1 = {"apple", "banana", "cherry"}
s2 = {"banana", "apple", "cherry"}
print(s1)  # {'banana', 'cherry', 'apple'}
s = s1.isdisjoint(s2)
print(s)  # False

s1 = {"apple", "banana", "cherry", "abc"}
s2 = {"banana", "apple", "cherry"}
print(s1)  # {'banana', 'cherry', 'apple'}
s = s1.isdisjoint(s2)
print(s)  # False

如上，set和frozenset也能互相比较

5.s1 issubset(s2)：判断s1的元素是否都在s2中，即s1<=s2，有就返回True，否则返回False

s1={"aa","bb","aa","cc","dd","aa"}
s2=set({"aa","bb","aa","cc","dd","aa","e"})
print(s1.issubset(s2))  # True
print(s2.issubset(s1))  # False
print(s1<=s2)  # True
print(s2<=s1)  # False

s1={"aa","bb","aa","cc","dd","aa"}
s2=set({"a3a","bab","a1a","c3c","d3d","a2a","e"})
print(s1.issubset(s2))  # False
print(s2.issubset(s1))  #
print(s1<=s2)  # False
print(s2<=s1)  # False


s1={"aa","bb","aa","cc","dd","aa"}
s2=frozenset({"aa","bb","aa","cc","dd","aa","e"})
print(s1.issubset(s2))  #
print(s2.issubset(s1))  # False
print(s1<=s2)  # True
print(s2<=s1)  # False

s1={"aa","bb","aa","cc","dd","aa"}
s2=frozenset({"a3a","bab","a1a","c3c","d3d","a2a","e"})
print(s1.issubset(s2))  # False
print(s2.issubset(s1))  # False
print(s1<=s2)  # False
print(s2<=s1)  # False


#---------------------------------------------------------------------# 

# 非集合类型：

s1 = {"apple", "banana", "cherry"}
s2 = ("google", "runoob", "apple")
print(s1)  # {'banana', 'cherry', 'apple'}
s = s1.issubset(s2)
print(s)  # False

s1 = {"apple", "banana", "cherry"}
s2 = (("google", "runoob", "apple"))
print(s1)  # {'banana', 'cherry', 'apple'}
s = s1.issubset(s2)
print(s)  # False

s1 = {"apple", "banana", "cherry"}
s2 = "apple"
print(s1)  # {'banana', 'cherry', 'apple'}
s = s1.issubset(s2)
print(s)  # False

s1 = {"apple", "banana", "cherry"}
s2 = {"banana", "apple", "cherry"}
print(s1)  # {'banana', 'cherry', 'apple'}
s = s1.issubset(s2)
print(s)  # True

s1 = {"apple", "banana", "cherry"}
s2 = {"banana", "apple", "cherry","aaa"}
print(s1)  # {'banana', 'cherry', 'apple'}
s = s1.issubset(s2)
print(s)  # True

5.s1 issuperset(s2)：判断s2的元素是否都在s1中，即s2<=s1，有就返回True，否则返回False

s1={"aa","bb","aa","cc","dd","aa"}
s2=set({"aa","bb","aa","cc","dd","aa","e"})
print(s1.issuperset(s2))  # False
print(s2.issuperset(s1))  # True
print(s1>=s2)  # False
print(s2>=s1)  # True

s1={"aa","bb","aa","cc","dd","aa"}
s2=set({"a3a","bab","a1a","c3c","d3d","a2a","e"})
print(s1.issuperset(s2))  # False
print(s2.issuperset(s1))  # False
print(s1>=s2)  # False
print(s2>=s1)  # False


s1={"aa","bb","aa","cc","dd","aa"}
s2=frozenset({"aa","bb","aa","cc","dd","aa","e"})
print(s1.issuperset(s2))  # False
print(s2.issuperset(s1))  # True
print(s1>=s2)  # False
print(s2>=s1)  # True

s1={"aa","bb","aa","cc","dd","aa"}
s2=frozenset({"a3a","bab","a1a","c3c","d3d","a2a","e"})
print(s1.issuperset(s2))  # False
print(s2.issuperset(s1))  # False
print(s1>=s2)  # False
print(s2>=s1)  # False

#---------------------------------------------------------------------#

# 非集合类型：

s1 = {"apple", "banana", "cherry"}
s2 = ("google", "runoob", "apple")
print(s1)  # {'banana', 'cherry', 'apple'}
s = s1.issuperset(s2)
print(s)  # False

s1 = {"apple", "banana", "cherry"}
s2 = (("google", "runoob", "apple"))
print(s1)  # {'banana', 'cherry', 'apple'}
s = s1.issuperset(s2)
print(s)  # False

s1 = {"apple", "banana", "cherry"}
s2 = "apple"
print(s1)  # {'banana', 'cherry', 'apple'}
s = s1.issuperset(s2)
print(s)  # False

s1 = {"apple", "banana", "cherry"}
s2 = {"banana", "apple", "cherry"}
print(s1)  # {'banana', 'cherry', 'apple'}
s = s1.issuperset(s2)
print(s)  # True

s1 = {"apple", "banana", "cherry","abc"}
s2 = {"banana", "apple", "cherry"}
print(s1)  # {'banana', 'cherry', 'apple'}
s = s1.issuperset(s2)
print(s)  # True

6.s1.union(s2,s3,...)：返回一个新集合，为s1、s2、s3等集合的并集，等同于s1∪s2∪s3∪...

s1={"aa","bb","aa","cc","dd","aa"}
s2=set({"aa","bb","aa","cc","dd","aa","e"})
print(s1.union(s2))  # {'cc', 'e', 'aa', 'dd', 'bb'}
print(s2.union(s1))  # {'cc', 'e', 'aa', 'dd', 'bb'}
print(s1|s2)  # {'cc', 'e', 'aa', 'dd', 'bb'}
print(s2|s1)  # {'cc', 'e', 'aa', 'dd', 'bb'}
s=s1.union(s2)
print(type(s))  # <class 'set'>
print(s1)  # {'bb', 'dd', 'cc', 'aa'}
print(s2)  # {'bb', 'e', 'dd', 'aa', 'cc'}

s1={"aa","bb","aa","cc","dd","aa"}
s2=set({"a3a","bab","a1a","c3c","d3d","a2a","e"})
print(s1.union(s2))  # {'c3c', 'cc', 'a2a', 'd3d', 'e', 'aa', 'a3a', 'bab', 'dd', 'bb', 'a1a'}
print(s2.union(s1))  # {'c3c', 'cc', 'a2a', 'd3d', 'e', 'aa', 'a3a', 'bab', 'dd', 'bb', 'a1a'}
print(s1|s2)  # {'c3c', 'cc', 'a2a', 'd3d', 'e', 'aa', 'a3a', 'bab', 'dd', 'bb', 'a1a'}
print(s2|s1)  # {'c3c', 'cc', 'a2a', 'd3d', 'e', 'aa', 'a3a', 'bab', 'dd', 'bb', 'a1a'}
print(s1)  # {'bb', 'dd', 'cc', 'aa'}
print(s2)  # {'bab', 'e', 'c3c', 'a3a', 'd3d', 'a2a', 'a1a'}

s1={"aa","bb","aa","cc","dd","aa","111"}
s2=frozenset({"aa","bb","aa","cc","dd","aa","e"})
print(s1.union(s2))  # {'bb', 'e', 'cc', '111', 'aa', 'dd'}
print(s2.union(s1))  # frozenset({'bb', 'e', 'cc', '111', 'aa', 'dd'})
print(s1|s2)  # {'bb', 'e', 'cc', '111', 'aa', 'dd'}
print(s2|s1)  # frozenset({'bb', 'e', 'cc', '111', 'aa', 'dd'})
s=s1.union(s2)
print(type(s))  # <class 'set'>
s=s2.union(s1)
print(type(s))  # <class 'frozenset'>

s1={"aa","bb","aa","cc","dd","aa","221"}
s2=frozenset({"a3a","bab","a1a","c3c","d3d","a2a","e"})
print(s1.union(s2))  # {'bb', 'd3d', 'a3a', 'a2a', 'e', 'a1a', 'c3c', '221', 'cc', 'bab', 'aa', 'dd'}
print(s2.union(s1))  # frozenset({'bb', 'd3d', 'a3a', 'a2a', 'e', 'a1a', 'c3c', '221', 'bab', 'cc', 'aa', 'dd'})
print(s1|s2)  # {'bb', 'd3d', 'a3a', 'a2a', 'e', 'a1a', 'c3c', '221', 'cc', 'bab', 'aa', 'dd'}
print(s2|s1)  # frozenset({'bb', 'd3d', 'a3a', 'a2a', 'e', 'a1a', 'c3c', '221', 'bab', 'cc', 'aa', 'dd'})

s1={"aa","bb","aa","cc","dd","aa"}
s2=set({"a3a","bab","a1a","c3c","d3d","a2a","e"})
s3={1,2,3}
print(s1.union(s2,s3))  # {1, 2, 'bab', 'a3a', 3, 'd3d', 'aa', 'a1a', 'cc', 'bb', 'c3c', 'a2a', 'e', 'dd'}
print(s2.union(s1,s3))  # {1, 2, 'bab', 'a3a', 3, 'd3d', 'aa', 'a1a', 'cc', 'bb', 'c3c', 'a2a', 'e', 'dd'}
print(s1|s2|s3)  # {1, 2, 'bab', 'a3a', 3, 'd3d', 'aa', 'a1a', 'cc', 'bb', 'c3c', 'a2a', 'e', 'dd'}
print(s3|s2|s1)  # {1, 2, 'bab', 'a3a', 3, 'd3d', 'aa', 'a1a', 'cc', 'bb', 'c3c', 'a2a', 'e', 'dd'}

s1={"aa","bb","aa","cc","dd","aa","111"}
s2=frozenset({"aa","bb","aa","cc","dd","aa","e"})
s3=frozenset((1,2,3))
print(s1.union(s2,s3))  # {1, 2, 3, '111', 'aa', 'cc', 'bb', 'e', 'dd'}
print(s2.union(s1,s3))  # frozenset({1, 2, 3, '111', 'aa', 'cc', 'bb', 'e', 'dd'})
print(s1|s2|s3)  # {1, 2, 3, '111', 'aa', 'cc', 'bb', 'e', 'dd'}
print(s3|s2|s1)  # frozenset({1, 2, 3, '111', 'aa', 'cc', 'bb', 'e', 'dd'})

#---------------------------------------------------------------------#

#非集合类型：

s1 = {"apple", "banana", "cherry"}
s2 = ("google", "runoob", "apple")
print(s1)  # {'banana', 'cherry', 'apple'}
s = s1.union(s2)
print(s)  # {'runoob', 'banana', 'apple', 'google', 'cherry'}

s1 = {"apple", "banana", "cherry"}
s2 = (("google", "runoob", "apple"))
print(s1)  # {'banana', 'cherry', 'apple'}
s = s1.union(s2)
print(s)  # {'runoob', 'banana', 'apple', 'google', 'cherry'}

s1 = {"apple", "banana", "cherry"}
s2 = "apple"
print(s1)  # {'banana', 'cherry', 'apple'}
s = s1.union(s2)
print(s)  # {'a', 'banana', 'l', 'apple', 'p', 'cherry', 'e'}

上述可见，可变和不可变集合也能互并

7.s1.intersection(s2,s3,...)：返回一个新集合，为s1、s2、s3等集合的交集，等同于s1∩s2∩s3∩...

s1={"aa","bb","aa","cc","dd","aa"}
s2=set({"aa","bb","aa","cc","dd","aa","e"})
print(s1.intersection(s2))  # {'aa', 'bb', 'dd', 'cc'}
print(s2.intersection(s1))  # {'aa', 'bb', 'dd', 'cc'}
print(s1 & s2)  # {'aa', 'bb', 'dd', 'cc'}
print(s2 & s1)  # {'aa', 'bb', 'dd', 'cc'}
s=s1.intersection(s2)
print(type(s))  # <class 'set'>
print(s1)  # {'aa', 'bb', 'dd', 'cc'}
print(s2)  # {'aa', 'bb', 'dd', 'cc', 'e'}

s1={"aa","bb","aa","cc","dd","aa"}
s2=set({"a3a","bab","a1a","c3c","d3d","a2a","e"})
print(s1.intersection(s2))  # set()
print(s2.intersection(s1))  # set()
print(s1 & s2)  # set()
print(s2 & s1)  # set()
print(s1)  # {'aa', 'bb', 'dd', 'cc'}
print(s2)  # {'a1a', 'a3a', 'bab', 'a2a', 'c3c', 'd3d', 'e'}

s1={"aa","bb","aa","cc","dd","aa","111"}
s2=frozenset({"aa","bb","aa","cc","dd","aa","e"})
print(s1.intersection(s2))  # {'aa', 'bb', 'dd', 'cc'}
print(s2.intersection(s1))  # frozenset({'aa', 'bb', 'dd', 'cc'})
print(s1 & s2)  # {'aa', 'bb', 'dd', 'cc'}
print(s2 & s1)  # frozenset({'aa', 'bb', 'dd', 'cc'})
s=s1.intersection(s2)
print(type(s))  # <class 'set'>
s=s2.intersection(s1)
print(type(s))  # <class 'frozenset'>

s1={"aa","bb","aa","cc","dd","aa","221"}
s2=frozenset({"a3a","bab","a1a","c3c","d3d","a2a","e"})
print(s1.intersection(s2))  # set()
print(s2.intersection(s1))  # frozenset()
print(s1 & s2)  # set()
print(s2 & s1)  # frozenset()

s1={"aa","bb","aa","cc","dd","aa",1,2}
s2=set({"a3a","bab","a1a","c3c","d3d","a2a","e",2})
s3={1,2,3}
print(s1.intersection(s2,s3))  # {2}
print(s2.intersection(s1,s3))  # {2}
print(s1 & s2 & s3)  # {2}
print(s3 & s2 & s1)  # {2}

s1={"aa","bb","aa","cc","dd","aa","111"}
s2=frozenset({"aa","bb","aa","cc","dd","aa","e"})
s3=frozenset((1,2,3))
print(s1.intersection(s2,s3))  # set()
print(s2.intersection(s1,s3))  # frozenset()
print(s1 & s2 & s3)  # set()
print(s3 & s2 & s1)  # frozenset()

#---------------------------------------------------------------------#

#非集合类型：

s1 = {"apple", "banana", "cherry"}
s2 = ("google", "runoob", "apple")
print(s1)  # {'banana', 'cherry', 'apple'}
s = s1.intersection(s2)
print(s)  # {'apple'}

s1 = {"apple", "banana", "cherry"}
s2 = (("google", "runoob", "apple"))
print(s1)  # {'banana', 'cherry', 'apple'}
s = s1.intersection(s2)
print(s)  # {'apple'}

s1 = {"apple", "banana", "cherry"}
s2 = "apple"
print(s1)  # {'banana', 'cherry', 'apple'}
s = s1.intersection(s2)
print(s)  # set()

8.s1.difference(s2,s3,...)：返回一个新集合，为只在s1中，但不在s2、s3等集合中，即s1与s2、s3等集合的差集，等同于s1-s1∩s2-s1∩s3...

s1={"aa","bb","aa","cc","dd","aa"}
s2=set({"aa","bb","aa","cc","dd","aa","e"})
print(s1.difference(s2))  # set()
print(s2.difference(s1))  # {'e'}
print(s1-(s1&s2))
print(s2-(s2&s1))
s=s1.difference(s2)
print(type(s))  # <class 'set'>
print(s1)  # {'aa', 'bb', 'dd', 'cc'}
print(s2)  # {'aa', 'bb', 'dd', 'cc', 'e'}

s1={"aa","bb","aa","cc","dd","aa"}
s2=set({"a3a","bab","a1a","c3c","d3d","a2a","e"})
print(s1.difference(s2))  # {'aa', 'cc', 'bb', 'dd'}
print(s2.difference(s1))  # {'a3a', 'c3c', 'a1a', 'a2a', 'd3d', 'e', 'bab'}
print(s1-(s1&s2))  # {'aa', 'cc', 'bb', 'dd'}
print(s2-(s2&s1))  # {'a3a', 'c3c', 'a1a', 'a2a', 'd3d', 'e', 'bab'}
print(s1)  # {'aa', 'cc', 'bb', 'dd'}
print(s2)  # {'a2a', 'd3d', 'a3a', 'e', 'c3c', 'bab', 'a1a'}

s1={"aa","bb","aa","cc","dd","aa","111"}
s2=frozenset({"aa","bb","aa","cc","dd","aa","e"})
print(s1.difference(s2))  # {'111'}
print(s2.difference(s1))  # frozenset({'e'})
print(s1-(s1&s2))  # {'111'}
print(s2-(s2&s1))  # frozenset({'e'})
s=s1.difference(s2)
print(type(s))  # <class 'set'>
s=s2.difference(s1)
print(type(s))  # <class 'frozenset'>

s1={"aa","bb","aa","cc","dd","aa","221"}
s2=frozenset({"a3a","bab","a1a","c3c","d3d","a2a","e"})
print(s1.difference(s2))  # {'aa', 'dd', 'bb', '221', 'cc'}
print(s2.difference(s1))  # frozenset({'a3a', 'c3c', 'a1a', 'a2a', 'd3d', 'e', 'bab'})
print(s1-(s1&s2))  # {'aa', 'dd', 'bb', '221', 'cc'}
print(s2-(s2&s1))  # frozenset({'a3a', 'c3c', 'a1a', 'a2a', 'd3d', 'e', 'bab'})

s1={"aa","bb","aa","cc","dd","aa",1,2}
s2=set({"a3a","bab","a1a","c3c","d3d","a2a","e",2})
s3={1,2,3}
print(s1.difference(s2,s3))  # {'aa', 'dd', 'bb', 'cc'}
print(s2.difference(s1,s3))  # {'a3a', 'c3c', 'a1a', 'a2a', 'd3d', 'e', 'bab'}
print(s1-(s1&s2)-(s1&s3))  # {'aa', 'dd', 'bb', 'cc'}
print(s2-(s2&s1)-(s2&s3))  # {'a3a', 'c3c', 'a1a', 'a2a', 'd3d', 'e', 'bab'}

s1={"aa","bb","aa","cc","dd","aa","111"}
s2=frozenset({"aa","bb","aa","cc","dd","aa","e"})
s3=frozenset((1,2,3))
print(s1.difference(s2,s3))  # {'111'}
print(s2.difference(s1,s3))  # frozenset({'e'})
print(s1-(s1&s2)-(s1&s3))  # {'111'}
print(s2-(s2&s1)-(s2&s3))  # frozenset({'e'})

#---------------------------------------------------------------------#

#非集合类型:

s1 = {"apple", "banana", "cherry"}
s2 = ("google", "runoob", "apple")
print(s1)  # {'banana', 'cherry', 'apple'}
s = s1.difference(s2)
print(s)  # {'banana', 'cherry'}

s1 = {"apple", "banana", "cherry"}
s2 = (("google", "runoob", "apple"))
print(s1)  # {'banana', 'cherry', 'apple'}
s = s1.difference(s2)
print(s)  # {'banana', 'cherry'}

s1 = {"apple", "banana", "cherry"}
s2 = "apple"
print(s1)  # {'banana', 'cherry', 'apple'}
s = s1.difference(s2)
print(s)  # {'apple', 'cherry', 'banana'}

9.s1.symmetric_difference(s2)：返回一个新集合，为在s1和s2中，不同时存在的元素集合，等同于s1^s2

s1={"aa","bb","aa","cc","dd","aa"}
s2=set({"aa","bb","aa","cc","dd","aa","e"})
print(s1.symmetric_difference(s2))  # {'e'}
print(s2.symmetric_difference(s1))  # {'e'}
print(s1^s2)  # {'e'}
print(s2^s1)  # {'e'}
s=s1.symmetric_difference(s2)
print(type(s))  # <class 'set'>
print(s1)  # {'aa', 'bb', 'dd', 'cc'}
print(s2)  # {'aa', 'bb', 'dd', 'cc', 'e'}

s1={"aa","bb","aa","cc","dd","aa"}
s2=set({"a3a","bab","a1a","c3c","d3d","a2a","e"})
print(s1.symmetric_difference(s2))  # {'a3a', 'dd', 'c3c', 'a2a', 'd3d', 'aa', 'bab', 'bb', 'a1a', 'e', 'cc'}
print(s2.symmetric_difference(s1))  # {'a3a', 'dd', 'c3c', 'a2a', 'd3d', 'aa', 'bab', 'bb', 'a1a', 'e', 'cc'}
print(s1^s2)  # {'a3a', 'dd', 'c3c', 'a2a', 'd3d', 'aa', 'bab', 'bb', 'a1a', 'e', 'cc'}
print(s2^s1)  # {'a3a', 'dd', 'c3c', 'a2a', 'd3d', 'aa', 'bab', 'bb', 'a1a', 'e', 'cc'}
print(s1)  # {'aa', 'cc', 'bb', 'dd'}
print(s2)  # {'a2a', 'd3d', 'a3a', 'e', 'c3c', 'bab', 'a1a'}

s1={"aa","bb","aa","cc","dd","aa","111"}
s2=frozenset({"aa","bb","aa","cc","dd","aa","e"})
print(s1.symmetric_difference(s2))  # {'e', '111'}
print(s2.symmetric_difference(s1))  # frozenset({'e', '111'})
print(s1^s2)  # {'e', '111'}
print(s2^s1)  # frozenset({'e', '111'})
s=s1.symmetric_difference(s2)
print(type(s))  # <class 'set'>
s=s2.symmetric_difference(s1)
print(type(s))  # <class 'frozenset'>

s1={"aa","bb","aa","cc","dd","aa","221"}
s2=frozenset({"a3a","bab","a1a","c3c","d3d","a2a","e"})
print(s1.symmetric_difference(s2))  # {'a1a', 'c3c', 'e', 'a2a', 'd3d', 'aa', '221', 'cc', 'a3a', 'bb', 'dd', 'bab'}
print(s2.symmetric_difference(s1))  # frozenset({'a1a', 'c3c', 'e', 'a2a', 'd3d', 'aa', '221', 'cc', 'a3a', 'bb', 'dd', 'bab'})
print(s1^s2)  # {'a1a', 'c3c', 'e', 'a2a', 'd3d', 'aa', '221', 'cc', 'a3a', 'bb', 'dd', 'bab'}
print(s2^s1)  # frozenset({'a1a', 'c3c', 'e', 'a2a', 'd3d', 'aa', '221', 'cc', 'a3a', 'bb', 'dd', 'bab'})

#---------------------------------------------------------------------#

#s2非集合类型：

s1 = {"apple", "banana", "cherry"}
s2 = ("google", "runoob", "apple")
print(s1)  # {'banana', 'cherry', 'apple'}
s = s1.symmetric_difference(s2)
print(s)  # {'google', 'cherry', 'banana', 'runoob'}

s1 = {"apple", "banana", "cherry"}
s2 = (("google", "runoob", "apple"))
print(s1)  # {'banana', 'cherry', 'apple'}
s = s1.symmetric_difference(s2)
print(s)  # {'google', 'cherry', 'banana', 'runoob'}

s1 = {"apple", "banana", "cherry"}
s2 = "apple"
print(s1)  # {'banana', 'cherry', 'apple'}
s = s1.symmetric_difference(s2)
print(s)  # {'apple', 'cherry', 'banana', 'e', 'p', 'a', 'l'}

10.s1.copy()：返回一个新集合，为s1的浅拷贝

s1={"aa","bb","aa","cc","dd","aa"}
s2=s1.copy()
print(s1)  # {'aa', 'cc', 'bb', 'dd'}
print(s2)  # {'aa', 'cc', 'bb', 'dd'}

s1.add("param1")
print(s1)  # {'param1', 'dd', 'aa', 'cc', 'bb'}
print(s2)  # {'aa', 'cc', 'bb', 'dd'}

s1.add(1)
print(s1)  # {1, 'dd', 'cc', 'param1', 'aa', 'bb'}
print(s2)  # {'aa', 'cc', 'bb', 'dd'}

以上几点发现，混合了 set 实例与 frozenset 的二进制位运算将返回与第一个操作数相同的类型

以下，是set中有，但frozenset中没的方法：

11.s1.update(*others)：更新集合s1，添加来自 others 中的所有元素，包括新的元素或集合到当前集合中，等同于s1 |= other |=...

s1 = {"apple", "banana", "cherry"}
s2 = {"google", "runoob", "apple"}
print(s1)  # {'banana', 'cherry', 'apple'}
s1 |= s2
print(s1)  # {'apple', 'google', 'banana', 'cherry', 'runoob'}


s1 = {"apple", "banana", "cherry"}
s2 = {"google", "runoob", "apple"}
print(s1)  # {'banana', 'cherry', 'apple'}
s1.update(s2)
print(s1)  # {'apple', 'google', 'banana', 'cherry', 'runoob'}

#---------------------------------------------------------------------#
s1 = {"apple", "banana", "cherry"}
s2 = {"google", "runoob", "apple"}
s3 = {"A", "a", "b"}
print(s1)  # {'banana', 'cherry', 'apple'}
# s1 |= s2 |= s3  # 报错：SyntaxError: invalid syntax，因此必须分开写
s1 |= s2
s1 |= s3
print(s1)  # {'a', 'A', 'runoob', 'b', 'cherry', 'apple', 'google', 'banana'}

s1 = {"apple", "banana", "cherry"}
s2 = {"google", "runoob", "apple"}
s3 = {"A", "a", "b"}
print(s1)  # {'banana', 'cherry', 'apple'}
s1.update(s2, s3)
print(s1)  # {'a', 'A', 'runoob', 'b', 'cherry', 'apple', 'google', 'banana'}
#---------------------------------------------------------------------#
s1 = {"apple", "banana", "cherry"}
s2 = {"google", "runoob", "apple"}
s3 = {"A", "a", "b"}
print(s1)  # {'banana', 'cherry', 'apple'}
s1 |= s2
s1 |= s3
s1 |= {"11"}
# {'banana', '1', 'b', 'cherry', 'a', 'google', 'apple', 'A', 'runoob'}
print(s1)


s1 = {"apple", "banana", "cherry"}
s2 = {"google", "runoob", "apple"}
s3 = {"A", "a", "b"}
print(s1)  # {'banana', 'cherry', 'apple'}
s1.update(s2, s3, "11")
# {'banana', '1', 'b', 'cherry', 'a', 'google', 'apple', 'A', 'runoob'}
print(s1)

#---------------------------------------------------------------------#

#s2为非集合类型：

s1 = {"apple", "banana", "cherry"}
s2 = ("google", "runoob", "apple")
print(s1)  # {'banana', 'cherry', 'apple'}
s1.update(s2)
print(s1)  # {'apple', 'cherry', 'runoob', 'google', 'banana'}

s1 = {"apple", "banana", "cherry"}
s2 = (("google", "runoob", "apple"))
print(s1)  # {'banana', 'cherry', 'apple'}
s1.update(s2)
print(s1)  # {'apple', 'cherry', 'runoob', 'google', 'banana'}

s1 = {"apple", "banana", "cherry"}
s2 = "apple"
print(s1)  # {'banana', 'cherry', 'apple'}
s1.update(s2)
print(s1)  # {'apple', 'cherry', 'p', 'e', 'a', 'l', 'banana'}

12.s1.intersection_update(*others)：更新集合s1，添加来自 others 同时存在的元素，等同于s1 &= other &=...

s1 = {"apple", "banana", "cherry"}
s2 = {"google", "runoob", "apple"}
print(s1)  # {'banana', 'cherry', 'apple'}
s1 &= s2
print(s1)  # {'apple'}


s1 = {"apple", "banana", "cherry"}
s2 = {"google", "runoob", "apple"}
print(s1)  # {'banana', 'cherry', 'apple'}
s1.intersection_update(s2)
print(s1)  # {'apple'}

#---------------------------------------------------------------------#
s1 = {"apple", "banana", "cherry"}
s2 = {"google", "runoob", "apple"}
s3 = {"A", "a", "b"}
print(s1)  # {'banana', 'cherry', 'apple'}
# s1 &= s2 &= s3  # 报错：SyntaxError: invalid syntax
s1 &= s2
s1 &= s3
print(s1)  # set()

s1 = {"apple", "banana", "cherry"}
s2 = {"google", "runoob", "apple"}
s3 = {"A", "a", "b"}
print(s1)  # {'banana', 'cherry', 'apple'}
s1.intersection_update(s2, s3)
print(s1)  # set()
#---------------------------------------------------------------------#
s1 = {"apple", "banana", "cherry"}
s2 = {"google", "runoob", "apple"}
s3 = {"A", "a", "b", "apple"}
print(s1)  # {'banana', 'cherry', 'apple'}
s1 &= s2
s1 &= s3
s1 &= {"apple"}
print(s1)  # {'apple'}


s1 = {"apple", "banana", "cherry"}
s2 = {"google", "runoob", "apple"}
s3 = {"A", "a", "b", "apple"}
print(s1)  # {'banana', 'cherry', 'apple'}
s1.intersection_update(s2, s3, {"apple"})
print(s1)  # {'apple'}
#---------------------------------------------------------------------#

#s2为非集合类型：

s1 = {"apple", "banana", "cherry"}
s2 = ("google", "runoob", "apple")
print(s1)  # {'banana', 'cherry', 'apple'}
s1.intersection_update(s2)
print(s1)  # {'apple'}

s1 = {"apple", "banana", "cherry"}
s2 = (("google", "runoob", "apple"))
print(s1)  # {'banana', 'cherry', 'apple'}
s1.intersection_update(s2)
print(s1)  # {'apple'}

s1 = {"apple", "banana", "cherry"}
s2 = "apple"
print(s1)  # {'banana', 'cherry', 'apple'}
s1.intersection_update(s2)
print(s1)  # set()

13.s1.difference_update(*others)：更新集合s1，添加来自 others 同时存在的元素，等同于s1 -= other -=...

s1 = {"apple", "banana", "cherry"}
s2 = {"google", "runoob", "apple"}
print(s1)  # {'banana', 'cherry', 'apple'}
s1 -= s2
print(s1)  # {'banana', 'cherry'}


s1 = {"apple", "banana", "cherry"}
s2 = {"google", "runoob", "apple"}
print(s1)  # {'banana', 'cherry', 'apple'}
print(s1.difference_update(s2))  # None
print(s1)  # {'banana', 'cherry'}

# ---------------------------------------------------------------------#
s1 = {"apple", "banana", "cherry"}
s2 = {"google", "runoob", "apple"}
s3 = {"A", "a", "b"}
print(s1)  # {'banana', 'cherry', 'apple'}
# s1 -= s2 -= s3  # 报错：SyntaxError: invalid syntax
s1 -= s2
s1 -= s3
print(s1)  # {'banana', 'cherry'}

s1 = {"apple", "banana", "cherry"}
s2 = {"google", "runoob", "apple"}
s3 = {"A", "a", "b"}
print(s1)  # {'banana', 'cherry', 'apple'}
s1.difference_update(s2, s3)
print(s1)  # {'banana', 'cherry'}
# ---------------------------------------------------------------------#
s1 = {"apple", "banana", "cherry"}
s2 = {"google", "runoob", "apple"}
s3 = {"A", "a", "b", "apple","cherry"}
print(s1)  # {'banana', 'cherry', 'apple'}
s1 -= s2
s1 -= s3
s1 -= {"apple"}
print(s1)  # {'banana'}


s1 = {"apple", "banana", "cherry"}
s2 = {"google", "runoob", "apple"}
s3 = {"A", "a", "b", "apple"}
print(s1)  # {'banana', 'cherry', 'apple'}
s1.difference_update(s2, s3, {"apple","cherry"})
print(s1)  # {'banana'}
# ---------------------------------------------------------------------#

# 非集合类型：

s1 = {"apple", "banana", "cherry"}
s2 = ("google", "runoob", "apple")
print(s1)  # {'banana', 'cherry', 'apple'}
s1.difference_update(s2)
print(s1)  # {'banana', 'cherry'}

s1 = {"apple", "banana", "cherry"}
s2 = (("google", "runoob", "apple"))
print(s1)  # {'banana', 'cherry', 'apple'}
s1.difference_update(s2)
print(s1)  # {'banana', 'cherry'}

s1 = {"apple", "banana", "cherry"}
s2 = "apple"
print(s1)  # {'banana', 'cherry', 'apple'}
s1.difference_update(s2)
print(s1)  # {'banana', 'cherry', 'apple'}

# s1 = {"apple", "banana", "cherry"}
# s2 = 123
# print(s1)  # {'banana', 'cherry', 'apple'}
# s1.difference_update(s2)  # 报错：TypeError: 'int' object is not iterable

14.s1.symmetric_difference_update(*others)：更新集合s1，添加来自 others 不同时存在的元素，等同于s1 ^= other ^=...

s1 = {"apple", "banana", "cherry"}
s2 = {"google", "runoob", "apple"}
print(s1)  # {'banana', 'cherry', 'apple'}
s1 ^= s2
print(s1)  # {'google', 'banana', 'runoob', 'cherry'}


s1 = {"apple", "banana", "cherry"}
s2 = {"google", "runoob", "apple"}
print(s1)  # {'banana', 'cherry', 'apple'}
print(s1.symmetric_difference_update(s2))  # None
print(s1)  # {'google', 'banana', 'runoob', 'cherry'}

# ---------------------------------------------------------------------#
s1 = {"apple", "banana", "cherry"}
s2 = {"google", "runoob", "apple"}
s3 = {"A", "a", "b"}
print(s1)  # {'banana', 'cherry', 'apple'}
# s1 -= s2 -= s3  # 报错：SyntaxError: invalid syntax
s1 ^= s2
s1 ^= s3
print(s1)  # {'b', 'a', 'cherry', 'banana', 'A', 'runoob', 'google'}

s1 = {"apple", "banana", "cherry"}
s2 = {"google", "runoob", "apple"}
s3 = {"A", "a", "b"}
print(s1)  # {'banana', 'cherry', 'apple'}
# s1.symmetric_difference_update(s2, s3)  # 报错：TypeError: symmetric_difference_update() takes exactly one argument (2 given)
s1.symmetric_difference_update(s2)
s1.symmetric_difference_update(s3)
print(s1)  # {'cherry', 'A', 'banana', 'google', 'runoob', 'a', 'b'}

# ---------------------------------------------------------------------
s1 = {"apple", "banana", "cherry"}
s2 = {"google", "runoob", "apple"}
s3 = {"A", "a", "b", "apple", "cherry"}
print(s1)  # {'banana', 'cherry', 'apple'}
s1 ^= s2
s1 ^= s3
s1 ^= {"apple"}
print(s1)  # {'b', 'A', 'banana', 'runoob', 'google', 'a'}


s1 = {"apple", "banana", "cherry"}
s2 = {"google", "runoob", "apple"}
s3 = {"A", "a", "b", "apple"}
print(s1)  # {'banana', 'cherry', 'apple'}
# s1.symmetric_difference_update(s2, s3, {"apple", "cherry"})
s1.symmetric_difference_update(s2)
s1.symmetric_difference_update(s3)
s1.symmetric_difference_update({"apple", "cherry"})
print(s1)  # {'a', 'banana', 'b', 'A', 'google', 'runoob'}
# ---------------------------------------------------------------------#

# 非集合类型：

s1 = {"apple", "banana", "cherry"}
s2 = ("google", "runoob", "apple")
print(s1)  # {'banana', 'cherry', 'apple'}
s1.symmetric_difference_update(s2)
print(s1)  # {'google', 'runoob', 'banana', 'cherry'}

s1 = {"apple", "banana", "cherry"}
s2 = (("google", "runoob", "apple"))
print(s1)  # {'banana', 'cherry', 'apple'}
s1.symmetric_difference_update(s2)
print(s1)  # {'google', 'runoob', 'banana', 'cherry'}

s1 = {"apple", "banana", "cherry"}
s2 = "apple"
print(s1)  # {'banana', 'cherry', 'apple'}
s1.symmetric_difference_update(s2)
print(s1)  # {'a', 'banana', 'cherry', 'p', 'l', 'apple', 'e'}

# s1 = {"apple", "banana", "cherry"}
# s2 = 123
# print(s1)  # {'banana', 'cherry', 'apple'}
# s1.symmetric_difference_update(s2)  # # 报错：TypeError: 'int' object is not iterable

15.s1.add(elem)：更新集合s1，添加元素elem，elem必须为hashable并且不可遍历的

s1 = {"apple", "banana", "cherry"}
s2 = {"google", "runoob", "apple"}
print(s1)  # {'banana', 'cherry', 'apple'}
# s1.add(s2)  # 报错：TypeError: unhashable type: 'set'

# 非集合类型：

s1 = {"apple", "banana", "cherry"}
print(s1.add(1))  # None
s1.add(1)
print(s1)  # {1, 'apple', 'banana', 'cherry'}
s1.add("param")
print(s1)  # {1, 'param', 'banana', 'cherry', 'apple'}
s1.add( (2) )
print(s1)  # {1, 2, 'param', 'apple', 'banana', 'cherry'}
s1.add( (3,4,5) )
print(s1)  # {1, 2, (3, 4, 5), 'apple', 'param', 'banana', 'cherry'}

16.s1.remove(elem)：更新集合s1，删除元素elem，如果 elem 不存在则会引发 KeyError

s1 = {"apple", "banana", "cherry"}
s2 = {"google", "runoob", "apple"}
print(s1)  # {'banana', 'cherry', 'apple'}
# s1.remove(s2)  # 报错：TypeError: unhashable type: 'set'

s1 = {"apple", "banana", "cherry"}
s1.add(1)
print(s1.add(1))  # None
s1.add("param")
s1.add( (2) )
s1.add( (3,4,5) )
print(s1)  # {1, 2, (3, 4, 5), 'apple', 'param', 'banana', 'cherry'}
s1.remove(1)
print(s1)  # {2, (3, 4, 5), 'param', 'cherry', 'banana', 'apple'}
# s1.remove( (3,4) )  # 报错：KeyError: (3, 4)
# print(s1)
print(s1.remove( (3,4,5) ))  # None
print(s1)  # {2, 'param', 'cherry', 'apple', 'banana'}

17.s1.discard(elem)：更新集合s1，删除元素elem，如果 elem 不存在不会报错

s1 = {"apple", "banana", "cherry"}
s2 = {"google", "runoob", "apple"}
print(s1)  # {'banana', 'cherry', 'apple'}
s1.discard(s2)
print(s1.discard(s2))  # None
print(s1)  # {'banana', 'cherry', 'apple'}

s1 = {"apple", "banana", "cherry"}
s1.add(1)
s1.add("param")
s1.add( (2) )
s1.add( (3,4,5) )
print(s1)  # {1, 2, (3, 4, 5), 'apple', 'param', 'banana', 'cherry'}
s1.discard(1)
print(s1)  # {2, (3, 4, 5), 'param', 'cherry', 'banana', 'apple'}
s1.discard( (3,4) )  # {2, (3, 4, 5), 'param', 'cherry', 'banana', 'apple'}
print(s1)
print(s1.discard((3,4,5)))  # None
s1.discard( (3,4,5) )
print(s1)  # {2, 'param', 'cherry', 'apple', 'banana'}

18.s1.pop()：更新集合s1，从集合s1中随机移除并返回一个元素，如果集合为空则会引发 KeyError

# s1 = {"apple", "banana", "cherry"}
# s2 = {"google", "runoob", "apple"}
# print(s1)  # {'banana', 'cherry', 'apple'}
# s1.pop(s2)  # 报错：TypeError: pop() takes no arguments (1 given)
# print(s1)  # {'banana', 'cherry', 'apple'}

s1 = {"apple", "banana", "cherry"}
s1.add(1)
s1.add("param")
s1.add( (2) )
s1.add( (3,4,5) )
print(s1)  # {1, 2, (3, 4, 5), 'apple', 'param', 'banana', 'cherry'}
print(s1.pop())  # 1
print(s1)  # {'param', 2, 'banana', 'apple', (3, 4, 5), 'cherry'}
s1.pop()
print(s1)  # {2, 'banana', 'apple', (3, 4, 5), 'cherry'}
s1.pop( )
print(s1)  # {'banana', 'apple', (3, 4, 5), 'cherry'}

# s2=set()
# s2.pop()  # 报错：KeyError: 'pop from an empty set'

19.s1.clear()：更新集合s1，从集合s1中移除所有元素，如果集合为空则会引发 KeyError

# s1 = {"apple", "banana", "cherry"}
# s2 = {"google", "runoob", "apple"}
# print(s1)  # {'banana', 'cherry', 'apple'}
# s1.clear(s2)  # 报错：TypeError: clear() takes no arguments (1 given)
# print(s1)  # {'banana', 'cherry', 'apple'}

s1 = {"apple", "banana", "cherry"}
s2 = {"google", "runoob", "apple"}
print(s1)  # {'banana', 'cherry', 'apple'}
s1.clear()  # 报错：TypeError: clear() takes no arguments (1 given)
print(s1)  # set()


s1 = {"apple", "banana", "cherry"}
s1.add(1)
s1.add("param")
s1.add( (2) )
s1.add( (3,4,5) )
print(s1)  # {1, 2, (3, 4, 5), 'apple', 'param', 'banana', 'cherry'}
print(s1.clear())  # None
print(s1)  # set()
s1.clear()
print(s1)  # set()


# s2=set()
# s2.pop()  # 报错：KeyError: 'pop from an empty set'