Python中set的功能介绍

                                               Set的功能介绍

1.集合的两种函数（方法）

1. 集合的内置函数

1. 交集

   格式：x.__and__(y)等同于x&y
   例如：s1 = {'a',1,}
        s2 = {'b',1,}
        s3 = {'b','d'}
        print(s1.__and__(s2))
    >>> {1}
        print(s1.__and__(s3))
    >>> set()
   返回值：set
   #y只能是集合，当两个集合没有交集时，返回值为空集合。
   

2. 判断是否是包含关系

   格式：x.__contains__(y)等同于y in x
   例如：s1 = {'a',1,}
        print(s1.__contains__(3))
    >>> False
   返回值：bool
   #y可以是任意对象
   

3. 判断两个集合是否相等

   格式：x.__eq__(y)等同于x==y
   例如：s1 = {'a',1,}
        print(s1.__eq__({3,}))
    >>> False
   返回值：bool
   

4. 判断集合1是否大于等于集合2

   格式：x.__ge__(y)等同于x>=y
   例如：s1 = {3,4,5}
        print(s1.__ge__({3,4}))
    >>> True
        print(s1.__ge__({2}))
    >>> False
   返回值：bool
   #y只能是集合，判断大小主要依据集合相同元素的个数。
   

5. 访问属性

   格式：x.__getattribute__(self,name)
   返回值：tuple
   

6. 判断集合1是否大于集合2

   格式：x.__gt__(y)等同于x>y
   例如：s1 = {3,4,5}
        print(s1.__gt__({3,4}))
    >>> True
        print(s1.__gt__({2}))
    >>> False
   返回值：bool
   #y只能是集合，判断大小主要依据集合相同元素的个数。
   

7. 赋值交集

   格式：x.__iand__(y)等同于x&=y
   例如：s1 = {'a',3,}
        s1.__iand__({3})
        print(s1)
    >>> {3}
   返回值：None
   

8. 构造方法

   格式：x.__init__(set())
   例如：s1 = {3,5,}
        s1.__init__(set())
        print(s1)
   返回值：None
   

9. 赋值或并集

   格式：x.__ior__(y)等同于x|=y
   例如：s1 = {'a','b',}
        s1.__ior__({3})
        print(s1)
    >>> {'a','b',3}
   返回值：None
   

10. 赋值差集

    格式：x.__isub__(y)等同于x-=y
    例如：s1 = {'a','b',}
         s1.__isub__({3,4})
         print(s1)
     >>> {'a','b'}
    返回值：None
    

11. 迭代器

    格式：x.__iter__()等同于iter(x)
    返回值：迭代器
    

12. 赋值异或

    格式：x.__ixor__(y)等同于x^=y
    例如：s1 = {'a','b',2,}
         s1.__ixor__({'a',2,3})
         print(s1)
     >>> {'b',3}
    返回值：None
    #去除两个集合的交集后再并集
    

13. 判断集合1是否小于等于集合2

    格式：x.__le__(y)等同于x<=y
    例如：s1 = {3,4,5}
         print(s1.__le__({3,4}))
     >>> False
         print(s1.__le__({2}))
     >>> True
    返回值：bool
    #y只能是集合，判断大小主要依据集合相同元素的个数。
    

14. 长度

    格式：x.__len__()等同于len(x)
    例如：s1 = {2,3,4,}
         print(s1.__len__())
     >>> 3
    返回值：int
    

15. 判断集合1是否小于集合2

    格式：x.__lt__(y)等同于x<y
    例如：s1 = {3,4,5}
         print(s1.__lt__({3,4}))
     >>> False
         print(s1.__lt__({2}))
     >>> True
    返回值：bool
    #y只能是集合，判断大小主要依据集合相同元素的个数。
    

16. 判断两个集合是否不相等

    格式：x.__ne__(y)等同于x!=y
    例如：s1 = {2,3,4}
         print(s1.__ne__({3,4,}))
     >>> True
    返回值：bool
    

17. 创建一个空集合

    格式：x.__new__(set)
    例如：s1 = {2,3,}
         print(s1.__new__(set))
     >>> set()
    返回值：set
    

18. 并集

    格式：x.__or__(y)等同于x|y
    例如：s1 = {2,3,4}
         print(s1.__or__({3,4,5}))
     >>> {2,3,4,5}
    返回值：set
    

19. 右→左 交集

    格式：x.__rand__(y)等同于y&x
    例如：s1 = {2,3,4}
         print(s1.__rand__({3,4,5}))
     >>> {3,4}
    返回值：set
    

20. 集合的状态信息

    格式：x.__reduce__()
    例如：s1 = {3,4,5,}
         print(s1.__reduce__())
     >>> (<class 'set'>, ([3, 4, 5],), None)
    返回值：tuple
    

21. 内置转换

    格式：x.__repr__(self)
    返回值：set
    

22. 右→左 并集

    格式：x.__ror__(y)等同于y|x
    例如：s1 = {2,3,4}
         print(s1.__ror__({3,4,5}))
     >>> {2,3,4,5}
    返回值：set
    

23. 右→左 差集

    格式：x.__rsub__(y)等同于y-x
    例如：s1 = {2,3,4,}
         print(s1.__rsub__({3,4,5}))
     >>> {5}
    返回值：set
    

24. 右→左 并集减去交集

    格式：x.__rxor__(y)等同于y^x
    例如：s1 = {2,3,4,}
         print(s1.__rxor__({3,4,5}))
     >>> {2,5}
    返回值：set
    

25. 集合在内存中的大小，转换为字节进行计算

    格式：x.__sizeof__()
    例如：s1 = {3,4,}
         s2 = {2,3,}
         print(s1.__sizeof__())
     >>> 200
         print(s2.__sizeof__())
     >>> 200
    返回值：int
    #集合长度和内容的不同，不影响集合在内存中的大小。
    

26. 差集

    格式：x.__sub__(y)等同于x-y
    例如：s1 = {2,3,4,}
         print(s1.__sub__({3,4,5}))
     >>> {2}
    返回值：set
    

27. 并集减去交集

    格式：x.__xor__(y)等同于x^y
    例如：s1 = {2,3,4,}
         print(s1.__xor__({3,4,5}))
     >>> {2,5}
    返回值：set
    

2. 集合的常用函数

1. 集合添加元素

   格式：x.add(y)
   例如：s1 = {2,4,}
        s1.add(3)
        print(s1)
    >>> {2,3,4}
   返回值：None
   #y是任意可以哈希的对象
   

2. 清空集合

   格式：x.clear()
   例如：s1 = {2,3,}
        s1.clear()
        print(s1)
    >>> set()
   返回值：None
   

3. 复制集合

   格式：x.copy()
   例如：s1 = {2,3,}
        print(s1.copy())
    >>> {2,3}
   返回值：set
   

4. 差集（生成新集合）

   格式：x.difference(y)等同于x-y
   例如：s1 = {1,2,3,}
        print(s1.difference({2,3,4,}))
    >>> {1}
   返回值：set
   

5. 差集（修改原集合）

   格式：x.difference_update(y)
   例如：s1 = {1,2,3,}
        s1.difference_update({2,3,4,})
        print(s1)
    >>> {1}
   返回值：None
   

6. 删除元素（不报错）

   格式：x.discard(y)
   例如：s1 = {1,2,3,}
        s1.discard(3)
        print(s1)
    >>> {1,2}
   返回值：None
   #y是任意可哈希化的对象，集合若无该元素时，也不会报错
   

7. 交集（生成新集合）

   格式：x.intersection(y)等同于x&y
   例如：s1 = {1,2,3,}
        print(s1.intersection({2,3,4}))
    >>> {2,3}
   返回值：set
   

8. 交集（修改原集合）

   格式：x.intersection_update(y)
   例如：s1 = {1,2,3,}
        s1.intersection_update({2,3,4,})
        print(s1)
    >>> {2,3}
   返回值：None
   

9. 判断两个集合是否没有相同元素

   格式：x.isdisjoint(y)
   例如：s1 = {1,2,3,}
        print(s1.isdisjoint({4,5,}))
    >>> True
   返回值：bool
   

10. 判断集合1是否包含集合2

    格式：x.issuperset(y)
    例如：s1 = {1,2,3,}
         print(s1.issuperset({1,2,}))
     >>> True
    返回值：bool
    

11. 随机删除一个元素

    格式：x.pop()
    例如：s1 = {1,2,3,}
         print(s1.pop())
     >>> 1 or 2 or 3
    返回值：object（可哈希化的对象）
    

12. 删除指定元素

    格式：x.remove(y)
    例如：s1 = {1,2,3,}
         s1.remove(2)
         print(s1)
     >>> {1,3}
    返回值：None
    

13. 并集减去交集（生成新集合）

    格式：x.symmetric_difference(y)等同于x^y
    例如：s1 = {1,2,3,}
         print(s1.symmetric_difference({2,3,4,}))
     >>> {1,4}
    返回值：set
    

14. 并集减去交集（修改原集合）

    格式：x.symmetric_difference_update(y)
    例如：s1 = {1,2,3,}
         s1.symmetric_difference_update({2,3,4,})
         print(s1)
     >>> {1,4}
    返回值：None
    

15. 并集（生成新集合）

    格式：x.union(y)等同于x|y
    例如：s1 = {1,2,3,}
         print(s1.union([4,5,]))
     >>> {1,2,3,4,5}
    返回值：set
    #y是可迭代的对象，主要为列表，元祖，字典和集合。
    

16. 并集（修改原集合）

    格式：x.update(y)
    例如：s1 = {1,2,3,}
         s1.update((4,5,))
         print(s1)
     >>> {1,2,3,4,5}
    返回值：None
    #y是可迭代的对象，主要为列表，元祖，字典和集合。
    

2.集合的操作

1. 集合的基础操作

1. 长度

   格式：len(set)
   返回值：int
   

2. 转换为集合

   格式：set(object)
   返回值：set
   #object只能是可哈希的对象
   

2. 集合遍历操作

1. 使用for...in 遍历集合

   格式：for variable in set:
            使用variable
   例如：se1 = {1,'a','b',}
        for i in se1:
            print(i)
    >>> 1
    >>> 'a'
    >>> 'b'
   

2. 集合内等长元祖的遍历

   格式：for variable1,variable2 in set:
            使用variable1,variable2
   例如：se1 = {(1,3,),(4,6,),(7,9,),}
        for i,j in se1:
            print(i,j)
    >>> 1 3
    >>> 4 6
    >>> 7 9
   

   注：方法2只能遍历同等长度的二级集合，由于集合内的元素不能是列表、字典和集合，因此只能是元祖。

3. 集合的推导式

1. 简单的集合推导式

   格式：{variable for variable in set}
   例如：se1 = {1,'a','b',}
        print({i for in se1})
    >>> {1,'a','b',}
   返回值：set
   #遍历集合生成一个新集合
   

2. 稍作修改的集合推导式

   格式：{variable*3 for variable in set}
   例如：se1 = {1,'a','b',}
        print({i*3 for i in se1})
    >>> {3,'aaa','bbb'}
   返回值：set
   

3. 带判断的集合推导式

   格式：{variable+'x' for variable in set if 条件表达式}
   例如：se1 = {1,'a','b',}
        print({i+'x' for i in se1 if i != 1})
    >>> {'ax','bx'}
   返回值：set
   

4. 多个集合推导式

   格式：{variable1+variable2 for variable1 in se1 for variable2 in se2}
   例如：se1 = {'a','b',}
        se2 = {'c','d',}
        print({i+j for i in se1 for j in se2})
    >>> {'bc', 'ad', 'ac', 'bd'}
   返回值：set
   

5. 带判断的多个集合推导式

   格式：{variable1+variable2 for variable1 in se1 for variable2 in se2 if 条件表达式}
   例如：se1 = {'a','b','c'}
        se2 = {'a','d','e'}
        print({i+j for i in se1 for j in se2 if i == j})
    >>> {'aa'}
   返回值：set