集合操作

一、集合基础

1、创建集合

• 使用set类创建集合

　　在使用set类创建集合是=时，需要为set类的构造方法提供一个列表或者元组类型的值，用于建立集合的数据源；这也就是说set类可以将元组或列表转为集合，并且去除重复元素，元素顺序可能也会被打乱，因为集合是无序的。

#利用列表创建集合
s=set([1,2,3])
print(s) #{1, 2, 3}

　#利用元组创建集合

　s=set((1,2,3))
　print(s) #{1, 2, 3}

• 使用{}直接创建

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

2、集合特性

（1）无序性

集合中的值是平等的，元素之间是无序的，无法通过索引和分片进行操作。

（2）互异性

集合中任意两个元素之间是不同的，即每个元素只能出现一次，常常用于去重应用。

（3）确定性

集合内的元素是不可变数据类型，例如，集合、列表、字典都不能作为集合的元素，因为它们都是可变的。

3、元素检测

判断一个元素是否属于该集合，使用in，如果在就返回True，如果不在就返回False。

s=set("hello")
print("h" in s)#True

4、集合遍历

######遍历字符串#####
s=set("hello")
for i in s:
    print(i)
#########输出#####
        o
        e
        l
        h


#######遍历元组####

　s={(1,2),(3,4),(5,6)}
  for item in s:
    print(item)
#########输出##########
　　(5, 6)
　　(3, 4)
　　(1, 2)

二、集合方法

class set(object):
    """
    set() -> new empty set object
    set(iterable) -> new set object
    
    Build an unordered collection of unique elements.
    """
    def add(self, *args, **kwargs): # real signature unknown
        """
        Add an element to a set.
        
        This has no effect if the element is already present.
        """
        pass

    def clear(self, *args, **kwargs): # real signature unknown
        """ Remove all elements from this set. """
        pass

    def copy(self, *args, **kwargs): # real signature unknown
        """ Return a shallow copy of a set. """
        pass

    def difference(self, *args, **kwargs): # real signature unknown
        """
        Return the difference of two or more sets as a new set.
        
        (i.e. all elements that are in this set but not the others.)
        """
        pass

    def difference_update(self, *args, **kwargs): # real signature unknown
        """ Remove all elements of another set from this set. """
        pass

    def discard(self, *args, **kwargs): # real signature unknown
        """
        Remove an element from a set if it is a member.
        
        If the element is not a member, do nothing.
        """
        pass

    def intersection(self, *args, **kwargs): # real signature unknown
        """
        Return the intersection of two sets as a new set.
        
        (i.e. all elements that are in both sets.)
        """
        pass

    def intersection_update(self, *args, **kwargs): # real signature unknown
        """ Update a set with the intersection of itself and another. """
        pass

    def isdisjoint(self, *args, **kwargs): # real signature unknown
        """ Return True if two sets have a null intersection. """
        pass

    def issubset(self, *args, **kwargs): # real signature unknown
        """ Report whether another set contains this set. """
        pass

    def issuperset(self, *args, **kwargs): # real signature unknown
        """ Report whether this set contains another set. """
        pass

    def pop(self, *args, **kwargs): # real signature unknown
        """
        Remove and return an arbitrary set element.
        Raises KeyError if the set is empty.
        """
        pass

    def remove(self, *args, **kwargs): # real signature unknown
        """
        Remove an element from a set; it must be a member.
        
        If the element is not a member, raise a KeyError.
        """
        pass

    def symmetric_difference(self, *args, **kwargs): # real signature unknown
        """
        Return the symmetric difference of two sets as a new set.
        
        (i.e. all elements that are in exactly one of the sets.)
        """
        pass

    def symmetric_difference_update(self, *args, **kwargs): # real signature unknown
        """ Update a set with the symmetric difference of itself and another. """
        pass

    def union(self, *args, **kwargs): # real signature unknown
        """
        Return the union of sets as a new set.
        
        (i.e. all elements that are in either set.)
        """
        pass

    def update(self, *args, **kwargs): # real signature unknown
        """ Update a set with the union of itself and others. """
        pass

    def __and__(self, *args, **kwargs): # real signature unknown
        """ Return self&value. """
        pass

    def __contains__(self, y): # real signature unknown; restored from __doc__
        """ x.__contains__(y) <==> y in x. """
        pass

    def __eq__(self, *args, **kwargs): # real signature unknown
        """ Return self==value. """
        pass

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __ge__(self, *args, **kwargs): # real signature unknown
        """ Return self>=value. """
        pass

    def __gt__(self, *args, **kwargs): # real signature unknown
        """ Return self>value. """
        pass

    def __iand__(self, *args, **kwargs): # real signature unknown
        """ Return self&=value. """
        pass

    def __init__(self, seq=()): # known special case of set.__init__
        """
        set() -> new empty set object
        set(iterable) -> new set object
        
        Build an unordered collection of unique elements.
        # (copied from class doc)
        """
        pass

    def __ior__(self, *args, **kwargs): # real signature unknown
        """ Return self|=value. """
        pass

    def __isub__(self, *args, **kwargs): # real signature unknown
        """ Return self-=value. """
        pass

    def __iter__(self, *args, **kwargs): # real signature unknown
        """ Implement iter(self). """
        pass

    def __ixor__(self, *args, **kwargs): # real signature unknown
        """ Return self^=value. """
        pass

    def __len__(self, *args, **kwargs): # real signature unknown
        """ Return len(self). """
        pass

    def __le__(self, *args, **kwargs): # real signature unknown
        """ Return self<=value. """
        pass

    def __lt__(self, *args, **kwargs): # real signature unknown
        """ Return self<value. """
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __ne__(self, *args, **kwargs): # real signature unknown
        """ Return self!=value. """
        pass

    def __or__(self, *args, **kwargs): # real signature unknown
        """ Return self|value. """
        pass

    def __rand__(self, *args, **kwargs): # real signature unknown
        """ Return value&self. """
        pass

    def __reduce__(self, *args, **kwargs): # real signature unknown
        """ Return state information for pickling. """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    def __ror__(self, *args, **kwargs): # real signature unknown
        """ Return value|self. """
        pass

    def __rsub__(self, *args, **kwargs): # real signature unknown
        """ Return value-self. """
        pass

    def __rxor__(self, *args, **kwargs): # real signature unknown
        """ Return value^self. """
        pass

    def __sizeof__(self): # real signature unknown; restored from __doc__
        """ S.__sizeof__() -> size of S in memory, in bytes """
        pass

    def __sub__(self, *args, **kwargs): # real signature unknown
        """ Return self-value. """
        pass

    def __xor__(self, *args, **kwargs): # real signature unknown
        """ Return self^value. """
        pass

    __hash__ = None

•  add  向集合中添加一个元素
• clear 从集合中移除所有元素
• copy 返回集合的浅拷贝
• difference 将两个或多个集合的差集作为一个新集合返回
• difference_update 从这个集合中删除另一个集合的所有元素
• discard 移除一个已经存在于集合中的元素（如果元素不存在，则不执行任何操作）
• intersection 将两个集合的交集作为一个新集合返回
• intersection_update 自身集合和另一个的交集来更新这个集合
• isdisjoint 如果两个集合有一个空交集，返回 True
• issubset 如果另一个集合包含这个集合，返回 True
• issuperset 如果这个集合包含另一个集合，返回 True
• pop 删除并返回任意的集合元素（如果集合为空，会抛出 KeyError异常）
• remove 删除集合中的一个元素（如果元素不存在，会抛出KeyError异常）
• symmetric_difference 将两个集合的对称差作为一个新集合返回(两个集合合并删除相同部分，其余保留)
• symmetric_difference_update 用自己和另一个的对称差来更新这个集合
• union 将集合的并集作为一个新集合返回
• update 用自己和另一个的并集来更新这个集合 

1、add()

s={1,2,4,}
s.add(5)
print(s)#{1, 2, 4, 5}

2、clear()

s={'hell0','world'}
s.clear()
print(s)#set()

3、copy ()

s1={1,2,3,}
s2=s1.copy()
print(s2)#{1, 2, 3}

4、difference()

s1={'a','b','c'}
s2={'a','d','c','e'}
#求出s1和s2之间的差集，保留s1中不同的元素
print(s1.difference(s2))#{'b'}
print(s1-s2)#{'b'}

#保留s2中相同的元素
print(s2.difference(s1))#{'d', 'e'}
print(s2-s1)#{'d', 'e'}

5、difference_update()

s1={1,2,4,5,}
s2={2,4,6,8}
s3={6}
s1.difference_update(s2)
#从s1中删除存在s2的元素
print(s1)#{1, 5}

#从s2中删除存在s3的元素
s2.difference_update(s3)
print(s2)#{8, 2, 4}

6、discard()

s={"a","b","c"}
s.discard("b")
#从s中移除元素b
print(s)#{'a', 'c'}

7、intersection()

s1={1,2,4,5,}
s2={2,4,6,8}
#将s1和s2求交集并且返回新的集合
print(s1.intersection(s2))#{2, 4}
print(s1&s2)#{2, 4}

8、intersection_update()

s1={'a','b','c'}
s2={'a','d','c','e'}
#相当于s1-s2，这与差集difference差不多
s1.intersection_update(s2)
print(s1)#{'a', 'c'}

9、isdisjoint()

s1={'a','b','c'}
s2={'a','d','c','e'}
#判断s1与s2之间是否有空交集，如果没有返回False
print(s1.isdisjoint(s2))#False

10、issubset()

s1={1,2,3}
s2={2}
#因为s1集合包含s2，所以返回True
print(s2.issubset(s1))#True

11、issuperset()

s1={1,2,3}
s2={2}
#因为s1集合包含s2，所以返回True
print(s1.issuperset(s2))#True

它与issubset的区别在于，包含的集合作为方法的调用者，被包含集合作为方法的参数。

12、pop()

s={1,3,5,2,8,3,9}
#随机删除元素并且返回删除元素
print(s.pop())#1
print(s)#{2, 3, 5, 8, 9}

13、remove()

s={1,3,5,2,8,3,9}
#删除指定元素并且无返回元素
print(s.remove(5))#None
print(s)#{1, 2, 3, 8, 9}

14、symmetric_difference()

s1={'a','b','c'}
s2={'a','d','c','e'}
#s1与s2中删除相同元素，保留不同元素，求对称差，相当于s1-s2与s2-s1的并集
print(s1.symmetric_difference(s2))#{'d', 'b', 'e'}

15、symmetric_difference_update()

s1={1,2,3,4,5}
s2={2,3,4}
s3={1,}
#将s1与s2集合的对称集求出来，然后与s1集合进行更新
s1.symmetric_difference_update(s2)
print(s1)#{1, 5}
#将s3与s2集合的对称集求出来，然后与s3集合进行更新
s3.symmetric_difference_update(s2)
print(s3)#{1, 2, 3, 4}

16、union()

s1={1,2,3,4,5}
s2={2,3,4}
#求出s1与s2的并集
print(s1.union(s2))#{1, 2, 3, 4, 5}
print(s1|s2)#{1, 2, 3, 4, 5}

17、update()

s1={1,2,3,4,5}
s2={2,3,4}
#对s1进行更新，相当于求两个集合的并集
s1.update(s2)
print(s1)#{1, 2, 3, 4, 5}

三、集合常用方法

1、并集

使用union方法或者操作符“|”进行两个或者多个集合求并集

namelist1={'alia','sanb','lige'}
namelist2={'alia','bobu'}
print(namelist1|namelist2)#{'alia', 'sanb', 'bobu', 'lige'}
print(namelist1.union(namelist2))#{'alia', 'sanb', 'bobu', 'lige'}

2、交集

使用intersection方法或者操作符“&”进行两个或多个集合求交集

namelist1={'alia','sanb','lige'}
namelist2={'alia','bobu'}
print(namelist1&namelist2)#{'alia'}
print(namelist1.intersection(namelist2))#{'alia'}

3、差集

使用difference方法或者操作符“-”进行两个或多个集合求差集

namelist1={'alia','sanb','lige'}
namelist2={'alia','bobu'}
print(namelist1-namelist2)#{'sanb', 'lige'}
print(namelist1.difference(namelist2))#{'sanb', 'lige'}

4、对称差集

使用symmetric_difference方法或者操作符“^”进行两个或多个集合求对称差集

namelist1={'alia','sanb','lige'}
namelist2={'alia','bobu'}
print(namelist1^namelist2)#{'sanb', 'bobu', 'lige'}
print(namelist1.symmetric_difference(namelist2))#{'sanb', 'bobu', 'lige'}

5、子集

使用issubset方法或者操作符“<”判断当前集合是否是某个集合的子集

str1=set("hello")
str2=set("he")
#判断str2是否是str1的子集
print(str2<str1)#True
print(str2.issubset(str1))#True

四、集合与函数

 1、len()

获取集合中元素的个数

s={1,2,4,5,3,8}
print(len(s))#6

2、max()

获取集合中最大的元素

s={1,2,4,5,3,8}
print(max(s))#8

3、min()

获取集合中最小的元素

s={1,2,4,5,3,8}
print(min(s))#1

4、sum()

返回集合的所有元素之和

s={1,2,4,5,3,8}
print(sum(s))#23

5、sorted()

返回排序后的集合列表

s={1,2,4,5,3,8}
print(sorted(s))#[1, 2, 3, 4, 5, 8]

6、enumerate()

返回一个可迭代的enumerate的数据类型，迭代后可以取出索引值及其具体的值。

s={1,2,4,5,3,8}
print(enumerate(s))#<enumerate object at 0x00000000054DA558>
for i,j in enumerate(s):
    print(i,j)

#######输出#######
    <enumerate object at 0x00000000054DA558>
    0 1
    1 2
    2 3
    3 4
    4 5
    5 8

7、all()

如果集合中的所有元素都是 True（或者集合为空），则返回 True。

s={0,1,2}
print(all(s))#False

#集合为空
s={}
print(all(s))#True

8、any()

如果集合中的所有元素都是 True，则返回 True；如果集合为空，则返回 False。

s={0,1,2}
print(any(s))#True

#集合为空
s={}
print(any(s))#False

五、frozenset只读集合

class frozenset(object):
    """
    frozenset() -> empty frozenset object
    frozenset(iterable) -> frozenset object
    
    Build an immutable unordered collection of unique elements.
    """
    def copy(self, *args, **kwargs): # real signature unknown
        """ Return a shallow copy of a set. """
        pass

    def difference(self, *args, **kwargs): # real signature unknown
        """
        Return the difference of two or more sets as a new set.
        
        (i.e. all elements that are in this set but not the others.)
        """
        pass

    def intersection(self, *args, **kwargs): # real signature unknown
        """
        Return the intersection of two sets as a new set.
        
        (i.e. all elements that are in both sets.)
        """
        pass

    def isdisjoint(self, *args, **kwargs): # real signature unknown
        """ Return True if two sets have a null intersection. """
        pass

    def issubset(self, *args, **kwargs): # real signature unknown
        """ Report whether another set contains this set. """
        pass

    def issuperset(self, *args, **kwargs): # real signature unknown
        """ Report whether this set contains another set. """
        pass

    def symmetric_difference(self, *args, **kwargs): # real signature unknown
        """
        Return the symmetric difference of two sets as a new set.
        
        (i.e. all elements that are in exactly one of the sets.)
        """
        pass

    def union(self, *args, **kwargs): # real signature unknown
        """
        Return the union of sets as a new set.
        
        (i.e. all elements that are in either set.)
        """
        pass

    def __and__(self, *args, **kwargs): # real signature unknown
        """ Return self&value. """
        pass

    def __contains__(self, y): # real signature unknown; restored from __doc__
        """ x.__contains__(y) <==> y in x. """
        pass

    def __eq__(self, *args, **kwargs): # real signature unknown
        """ Return self==value. """
        pass

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __ge__(self, *args, **kwargs): # real signature unknown
        """ Return self>=value. """
        pass

    def __gt__(self, *args, **kwargs): # real signature unknown
        """ Return self>value. """
        pass

    def __hash__(self, *args, **kwargs): # real signature unknown
        """ Return hash(self). """
        pass

    def __init__(self, seq=()): # known special case of frozenset.__init__
        """ Initialize self.  See help(type(self)) for accurate signature. """
        pass

    def __iter__(self, *args, **kwargs): # real signature unknown
        """ Implement iter(self). """
        pass

    def __len__(self, *args, **kwargs): # real signature unknown
        """ Return len(self). """
        pass

    def __le__(self, *args, **kwargs): # real signature unknown
        """ Return self<=value. """
        pass

    def __lt__(self, *args, **kwargs): # real signature unknown
        """ Return self<value. """
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __ne__(self, *args, **kwargs): # real signature unknown
        """ Return self!=value. """
        pass

    def __or__(self, *args, **kwargs): # real signature unknown
        """ Return self|value. """
        pass

    def __rand__(self, *args, **kwargs): # real signature unknown
        """ Return value&self. """
        pass

    def __reduce__(self, *args, **kwargs): # real signature unknown
        """ Return state information for pickling. """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    def __ror__(self, *args, **kwargs): # real signature unknown
        """ Return value|self. """
        pass

    def __rsub__(self, *args, **kwargs): # real signature unknown
        """ Return value-self. """
        pass

    def __rxor__(self, *args, **kwargs): # real signature unknown
        """ Return value^self. """
        pass

    def __sizeof__(self): # real signature unknown; restored from __doc__
        """ S.__sizeof__() -> size of S in memory, in bytes """
        pass

    def __sub__(self, *args, **kwargs): # real signature unknown
        """ Return self-value. """
        pass

    def __xor__(self, *args, **kwargs): # real signature unknown
        """ Return self^value. """
        pass

　　由于集合是可变的，所以不能作为集合的元素或者字典的key，但是可以利用frozenset类型将集合转为可读的，这样就可以作为集合的元素以及字典的key。

#定义两个集合s1,s2
s1=set("abcdefg")
s2=set([1,2,3,4])
#向s1,s2中添加元素
s1.add("h")
s2.add(5)
print(s1)
print(s2)
#############输出##########
    {'a', 'd', 'c', 'f', 'e', 'h', 'g', 'b'}
    {1, 2, 3, 4, 5}

上面是正常的添加过程，但是s1集合添加s2，就会抛出异常

#定义两个集合s1,s2
s1=set("abcdefg")
s2=set([1,2,3,4])
s1.add(s2)
print(s1)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-120-33029c9f337b> in <module>
      2 s1=set("abcdefg")
      3 s2=set([1,2,3,4])
----> 4 s1.add(s2)
      5 print(s1)

TypeError: unhashable type: 'set'

这时使用frozenset函数将s2集合转为可读集合，再进行添加

#定义两个集合s1,s2
s1=set("abcdefg")
s2=set([1,2,3,4])

s1.add(frozenset(s2))
print(s1)

###########输出######
{'a', 'd', 'c', frozenset({1, 2, 3, 4}), 'f', 'e', 'g', 'b'}

同理这时frozenset后的集合也可以作为字典的key。

dict={"name":"bright"}
s2=set([1,2,3,4])

dict.setdefault(frozenset(s2),[7,8,9])
print(dict)
##########输出#########
{frozenset({1, 2, 3, 4}): [7, 8, 9], 'name': 'bright'}