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

景命

(高能注意！)
知识点：
       


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

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

复制代码

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

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

复制代码

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

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

复制代码

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

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

复制代码

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

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

复制代码

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

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

复制代码

添加元素的方法：

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

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

复制代码

删除元素的方法:

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

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

复制代码

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

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

复制代码

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

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

复制代码

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

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

复制代码

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

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

复制代码

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

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

复制代码

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

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

复制代码

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

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

复制代码

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

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

复制代码

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

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

复制代码

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

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

复制代码

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

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

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

复制代码

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

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

复制代码

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

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

复制代码

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

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

复制代码