25 集合：在我的世界里，你就是我的唯一 - 景命

景命

(高能注意！)
知识点：
       


集合中的元素是不可以重复的，集合会自动去除重复的元素（这也是集合唯一的作用）。集合是无序的，不支持索引。
        集合与字典的存储方式是一样的，都是利用哈希函数计算。相同的元素会得到相同的哈希值（存放内存的地址）。所有集合中相同的元素都会覆盖掉，因此有了集合的唯一性。通过哈希计算得到的地址是不可能按照顺序排放的，所以才强调集合是无序的。
       
创建一个集合（创建空集合只能使用set()函数的方式，不可以直接用大括号的方式，直接使用大括号的方式会生成一个空字典）：
        1.直接把一堆元素用花括号括起来。

>>> s = {1,2,3,4,5}
>>> type(s)
<class 'set'>

        2.使用set()工厂函数。

>>> s = set([1,2,3,4,4])        #括号中放列表、元组或字符串都可以。
>>> s
{1, 2, 3, 4}

集合是无序的所以去除重复后是顺序会改变的：

>>> n = [1,2,3,4,0,5,4,3,2,0]
>>> n = list(set(n))                #将n取出重复后变为list型。
>>> print(n)
[0, 1, 2, 3, 4, 5]                        #结果虽然去除了重复，但是顺序改变。

如何访问集合中的值
        1.使用for把集合中的数据一个个的读取出来。

>>> n = {1,2,3,4,5}
>>> for i in n:
        print(i)
1
2
3
4
5

                2.可以通过in和not in判断一个元素是否在集合中已经存在。

>>> n = {1,2,3,4,5}
>>> 1 in n
True
>>> "1" in n
False

不可变集合：frozenset()
        参数：可迭代对象，比如列表、元组、字典等。
        返回值：返回新的frozenset对象，如果不提供参数，默认会生成空集合。

>>> n = frozenset([1,2,3,4,5,6])
>>> n                #定义的不可变集合n不可以添加或者删除元素。
frozenset({1, 2, 3, 4, 5, 6})
>>> n.add(5)        #如果添加元素会报错
Traceback (most recent call last):
  File "<pyshell#70>", line 1, in <module>
    n.add(5)
AttributeError: 'frozenset' object has no attribute 'add'#意思是，属性错误：frozenset集合没有添加属性。

添加元素的方法：

        s.add(obj):
                #添加操作：将obj添加到集合中
                参数：要添加的元素。
                返回值：None。
        例：

>>> s = {1,2,3,4,5}
>>> s.add(6)
>>> s
{1, 2, 3, 4, 5, 6}

删除元素的方法:

        s.remove(obj):
                #删除操作：将元素从s中删除，如果s中不存在obj，那么会报错。
                参数：要删除的元素。
                返回值：None。
        例：

>>> s = {1,2,3,4,5}
>>> s.remove(5)
>>> s
{1, 2, 3, 4}

        s.discard(obj)
                #丢弃操作：将obj从集合s中删除，如果obj不在集合s中，也没事^_^
                参数：要删除的元素。
                返回值：None。
        例：

>>> s = {4,5,6}
>>> s.discard(3)

        s.pop()
                #弹出操作：移除并返回集合s中随机的一个元素。
                参数：无
                返回值：移除的元素。
        例：

>>> s = {1,2,3,4}
>>> s.pop()
1

        s.clear()
                #清空操作：清空集合s中所有的元素。
                参数：无
                返回值：None。
        例：

>>> s = {1,2,3,4}
>>> print(s.clear())
None
>>> s
set()

集合类型内建方法总结
        1）s.issubset(t)        等价于        s <= t
                #子集测试（允许不严格意义上的子集）：判断集合s中的元素是否都是集合t的元素
                子集测试（严格意义上）：s != t ,且s中所有的元素都是t的成员
                参数：另一个集合，或者序列。
                返回值：返回真或者假。
        例：

>>> s = {1,2,3,4,5}
>>> s.issubset({1,2,3,4,6})        
False

        2）s.issuperset(t)        等价于        s >= t
                #超集测试（允许不严格意义上的超集）：判断集合t中的元素是否都是集合s的元素
                超集测试（严格意义上 s > t）：s != t，且t中的元素都是s的成员。
                参数：另一个集合，或者序列。
                返回值：返回真或者假。
        例：

>>> s = {1,2,3,4,5}
>>> s.issuperset({1,2,3})
True

        3）s.union(t)        等价于        s | t
                #合并操作：由于集合中不允许出现重复的元素，所以是s “或” t 中的元素。
                参数：用来合并的集合，或者序列。
                返回值：合并后的集合
        例：

>>> t = {6}
>>> s = {1,2,3,4,5}
>>> t.union(s)
{1, 2, 3, 4, 5, 6}                #运算后的结果不会出现重复的元素。

        4）s.intersection(t)        等价于        s & t
                #交集操作：s “与” t 中的元素，集合s和集合t都有的元素。
                参数：用来合并的集合，或者序列。
                返回值：合并后的集合
        例：

>>> s = {4,5,6,8}
>>> t = {3,5,7,8}
>>> s.intersection(t)
{8, 5}

        5）s.difference(t)        等价于        s - t
                #差分操作：在s中存在，在t中不存在的元素。
                参数：要判断的集合，或者序列。
                返回值：返回一个集合。
        例：

>>> s = {1,2,3}
>>> t = {4,5,6}
>>> s.difference(t)
{1, 2, 3}

        6）s.symmetric_difference        等价于        s ^ t
                #对称差分操作：s “或” t 中的元素，但不是s和t共有的元素。类似于s.union(t)，但
                不同的是不会返回两个集合中相同的元素。
                参数：另一个集合，或者序列。
                返回值：判断后的集合。
        例：

>>> s = {1,2,3}
>>> t = {1,4,5,6}
>>> s.symmetric_difference(t)
{2, 3, 4, 5, 6}

        7）s.copy()
                #浅复制。
                参数：无
                返回值：返回复制后集合。
        例：

>>> s = {1,2,3}
>>> t = s.copy()
>>> t
{1, 2, 3}

以下方法之适用于可变集合

        8）s.update(t)        等价于        s |= t
                #将t中的元素添加到s中。
                参数：要添加的集合，或者序列。
                返回值：None。
        例：

>>> s = {1, 2, 3, 4, 5, 6}
>>> t = {6,7}
>>> s.update(t)
>>> s
{1, 2, 3, 4, 5, 6, 7}                #相同的元素会被自动剔除。

        9）s.intersection_update(t)        等价于        s &= t
                #交集修改操作：s中仅包含s和t中共有的成员。就是取s和t的交集然后在赋给s
                参数：一个集合，或者序列。
                返回值：None
        例：

>>> s = {2,3,6,5}
>>> t = {3,1,5,6,2}
>>> s.intersection_update(t)
>>> s
{2, 3, 5, 6}

        10）s.difference_update(t)        等价于        s -= t
                #差修改操作：s中包含仅属于s但不属于t的成员，会改变原集合。
                参数：一个集合，或者序列。
                返回值：None。
        例：

>>> t = {4,1,6,8,3,2}
>>> s = {2,4,1,5}
>>> s.difference_update(t)
>>> s
{5}

        11）s.symmetric_difference_update(t)        等价于        s ^= t
                #对称差分修改操作：s中包括仅属于s或仅属于t的成员。（就是把s和t中不共有的元素赋给s）
                参数：一个集合，或者序列。
                返回值：None。
        例：

>>> s = {1,2,3,4}
>>> t = {1,2,6,5}
>>> s.symmetric_difference_update(t)
>>> s
{3, 4, 5, 6}