[Python] Python数据类型(三）集合类型之set集合和frozenset集合
1.集合基本概念
集合是0-n个对象引用的无序组合，集合中存储的元素不可重复，因此这些对象引用的引用的对象必须是可哈希运算的 。
1.python中提供了两种内置的集合类型：可变的set类型和固定的frozenset类型。
2.只有可哈希运算的对象可以添加到集合中，因为集合是无序的，不能存储重复数据项；
3.可哈希运算的对象包含一个__hash__()方法，该方法返回值在整个对象的生命周期都是相同的，可以使用__eq__()方法进行比较。
4.所有内置的固定数据类型都是可哈希运算的，比如：int,float,str,tuple,所有内置的可变的数据类型都是不可进行哈希运算的，比如：dict,list,set.
5.集合中不存储重复元组，每一项都是唯一的。
2.set集合
set类型是可变的无序序列，因此可以进行添加、移除数据，同时由于是无序的组合类型，因此没有索引位置 ，故不能使用分片操作符进行操作。
2.1.set的创建
1.创建set类型时，使用{}进行创建，如：
>>> s1 = {"java","12",12}
>>> s1
{'12', 12, 'java'}str、int都是内置不可变的数据类型，因此可以存储在set集合中，如果存储list类型的数据项呢？
>>> l1 = [1,2,3]
>>> s1 = {"java",12,l1}
Traceback (most recent call last):
File "" , line 1, in
s1 = {"java",12,l1}
TypeError: unhashable type: 'list' 这里报TypeError异常，原因是list是可变类型，没有hash()方法，不能进行哈希运算，因此 不能存储在set中。
2.使用set()创建集合，set()将返回一个空集合：
>>> s = set()
>>> s
set()
>>> set()中传入一个set参数时，将返回该set的浅拷贝：
>>> s = set(s1)
>>> s
{'12', 12, 'java'}
>>> set()中如果传入其他任意对象，则尝试将给定的对象转换为集合：
>>> s = set("set list")
>>> s
{' ', 's', 'l', 't', 'e', 'i'}
>>> 注意：创建空集合时，只能必须用set().不能使用s = {“ss”,1}这种形式，原因是这种形式用于创建另一种数据类型dict.
3.使用集合内涵创建(单独总结)
2.2.常用操作符和方法：
<,>,<=,>=,==,!=:比较运算符,逐项进行比较，如果有嵌套，则递归比较；
如：
>>> s1 = set("1234")
>>> s2 = set("2134")
>>> s1
{'2', '3', '1', '4'}
>>> s2
{'2', '3', '1', '4'}
>>>
>>> s1 == s2
True
>>> in、not in：成员关系符：
>>> "2" in s2
True
>>> 内置len()方法：
>>> len(s1)
4
>>> 集合操作符：|，&，-，^,
|:并集
>>> s1 = set("man")
>>> s2 = set("woman")
>>> s1 | s2
{'o', 'n', 'a', 'w', 'm'}
>>> &：交集
>>> s1 & s2
{'m', 'n', 'a'}
>>> -：如A-B,表示包含A中但不包含B中元素组成的集合，不支持交换性，如
>>> s1 - s2
set()
>>> s2 -s1
{'o', 'w'}
>>> ^:对称差集，A&B以外的元素组成的集合
>>> s2 ^ s1
{'o', 'w'}
>>> 常用方法：
s.add(x):将数据项x添加到集合s中
s.clear():清空s集合
s.copy()返回s的浅拷贝
s.difference(t):返回一个新集合，包含s中数据项但不包含t中的数据项，等同s-t,如：
>>> s1 = set("chinese")
>>> s2 = set("china")
>>> s1.difference(s2)
{'s', 'e'}
>>> s2.difference(s1)
{'a'}
>>> s.difference-update(t):移除s中和t中都存在的数据项，等同于s-=t
>>> s1
{'h', 'n', 's', 'c', 'e', 'i'}
>>> s2
{'h', 'n', 'a', 'c', 'i'}
>>>
>>> s1.difference_update(s2)
>>> s1
{'s', 'e'}
>>> s.discard(x):从集合s中移除数据项x，如果不存在，则不进行操作：
>>> s = set("discard")
>>> s
{'d', 'a', 's', 'r', 'c', 'i'}
>>> s.discard("s")
>>> s
{'d', 'a', 'r', 'c', 'i'}
>>> s.discard("y")
>>> s
{'d', 'a', 'r', 'c', 'i'}
>>> s.remove(x):从集合s中移除数据项x,如果不存在，则报KeyError异常：
>>> s
{'d', 'a', 'r', 'c', 'i'}
>>> s.remove("s")
Traceback (most recent call last):
File "" , line 1, in
s.remove("s")
KeyError: 's'
>>> s.intersection(t):返回s和t的交集集合，等同于s&t：
>>> s = set("basketball")
>>> t = set("football")
>>> s2 = s.intersection(t)
>>> s2
{'b', 'l', 'a', 't'}
>>> s.intersection_update(t):不返回新的集合，使s变为s和t的交集，等同于s&=t:
>>> s = set("basketball")
>>> t = set("football")
>>> s&=t
>>> s
{'b', 'l', 'a', 't'}
>>> s.isdisjoint(t):如果集合s和t中没有相同的项，就返回true：
>>> s.isdisjoint(t)
False
>>> s.issubset(t):如果s等于t或者s是t的子集，则返回True，等同于s<=t:
>>> s = set("number")
>>> t = set("bignumber")
>>>
>>> s.issubset(t)
True
>>> s.issuperset(t):如果s等于t或者s是t的超集，则返回True，等同于s>=t:
>>> s = set("number")
>>> t = set("bignumber")
>>> s.issuperset(t)
False
>>> t.issuperset(s)
True
>>>s.pop():返回并移除s中的一个随机项，如果s为空集，则报KeyError异常：
>>> s
{'n', 'r', 'b', 'u', 'm', 'e'}
>>> s.pop()
'n'
>>> s.symmetric_difference(t):返回一个新集合，包含s和t的对称差集，即s和t的交集以外的元素，等同于s ^ t:
>>> s = set("number")
>>> t = set("big number")
>>> s.symmetric_difference(t)
{' ', 'g', 'i'}
>>> s.symmetric_difference_update(t):不返回一个新集合，使集合s包含s和t的对称差集，即s和t的交集以外的元素，等同于s ^= t:
>>> s.symmetric_difference_update(t)
>>> s
{' ', 'g', 'i'}
>>> s.union(t):返回一个新集合，为s和t的并集，等同于s | t:
>>> s.union(t)
{' ', 'n', 'r', 'g', 'b', 'u', 'm', 'e', 'i'}
>>> s.update(t):将s变为s和t的并集，等同于s |= t:
>>> s.update(t)
>>> s
{' ', 'n', 'r', 'g', 'b', 'u', 'm', 'e', 'i'}
>>> 2.3.set的常用场景
1.可以用来删除重复的项，如：
>>> l = list("10101001")
>>> l
['1', '0', '1', '0', '1', '0', '0', '1']
>>> l= list(set("10101001"))
>>> l
['1', '0']
>>> 2.通过将数据存放到set中可以确保没有重复的数据：
>>> s = set()
>>> s.add("basketball")
>>> s.add("football")
>>> s.add("football")
>>> s
{'football', 'basketball'}
>>> 这种形式常用于for循环中进行遍历时：
for item in set(items)
3.用于删除不需要的数据：
>>> filenames = {"test.txt","001.log","show.bak"}
>>> for fn in filenames:
if fn.endswith(".txt"):
filenames.discard(fn)
# 出现异常
Traceback (most recent call last):
File "" , line 1, in
for fn in filenames:
RuntimeError: Set changed size during iteration 这里出现RuntimeError异常，说明不能使用原来的filenames集合，因此通过set(fileenames)得到一个浅拷贝进行操作:
>>> for fn in set(filenames):
if fn.endswith(".txt"):
filenames.discard(fn)
>>> filenames
{'001.log', 'show.bak'}
>>> 也可用通过集合操作符进行操作如：
>>> filenames = {"test.txt","001.log","show.bak"}
>>> filenames = set(filenames)-{"test.txt"}
>>> filenames
{'show.bak', '001.log'}
>>> 2.4.集合内涵
和列表内涵类似，当集合数据项太长时，可以使用集合内涵类创建集合，集合内涵是一个循环表达式，格式如下
S = {expression for item in iterable if condition}
比如要创建一个0-100的偶数集合：
>>> s = {num for num in range(0,100) if num%2 == 0}
>>> s
{0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98}
>>> 集合内涵中的iterable也可以是一个集合内涵。
3.固定集合frozenset类型
frozenset类型集合是指创建之后就不能改变的集合。
3.1.frozenset集合的创建
1.使用frozenset()进行创建，不给定参数时将返回一个空的固定集合：
>>> fs = frozenset()
>>> fs
frozenset()
>>> 2.带一个frozenset参数时，将返回该参数的浅拷贝：
>>> frozenset(fs)
frozenset()
>>> 3.传入其他参数时，将规定的对象转换为frozenset：
>>> fs = frozenset("frozenset")
>>> fs
frozenset({'o', 'n', 's', 'r', 't', 'f', 'z', 'e'})
>>> 3.2.常用操作符和方法：
固定集合是不变的，因此其支持的方法和操作符不能影响固定集合本身,故对于set集合中不改变本身的方法和操作符都是支持的。
fs.copy():返回fs的浅拷贝
>>> fs2 = frozenset("frozenset")
>>> fs = fs2.copy()
>>> fs
frozenset({'o', 'n', 's', 'r', 't', 'f', 'z', 'e'})
>>> fs.difference(t):返回一个新的固定集合，包含在fs中且不在t中的数据项，等同于fs - t：
>>> fs1 = frozenset("frozenset")
>>> fs2 = frozenset("set")
>>> fs1.difference(fs2)
frozenset({'o', 'n', 'r', 'f', 'z'})
>>>
>>> fs - fs2
frozenset({'o', 'n', 'r', 'f', 'z'})
>>> fs.intersection(t):返回一个新集合，fs和t的交集，等同于fs1 & t：
>>> fs1 = frozenset("frozenset")
>>> fs2 = frozenset("set")
>>> fs1.intersection(fs2)
frozenset({'s', 'e', 't'})
>>>
>>> fs1 & fs2
frozenset({'s', 'e', 't'})
>>> fs.isdisjoint(t):如果fs和t没有相同数据项，返回True：
>>> fs1.isdisjoint(fs2)
False
>>> fs.issubset(t):如果fs等于t或者fs为t的子集，则返回True，等同于fs <= t:
>>> fs2.issubset(fs1)
True
>>> fs.issupperset(t):如果fs等于t或者fs为t的超集，则返回True，等同于fs >= t:
fs.union(t):返回一个新集合，为fs和t的并集，等同于fs | t：
>>> fs3 = frozenset("fs3")
>>> fs4 = frozenset("fs4")
>>> fs3.union(fs4)
frozenset({'3', '4', 'f', 's'})
>>> fs.symmetric_difference(t):返回一个新集合，为fs和t的对称差集，等同于fs ^ t:
>>> fs5 = frozenset("apple")
>>> fs6 = frozenset("people")
>>> fs5.symmetric_difference(fs6)
frozenset({'o', 'a'})
>>>