集合操作

集合是一个无序的，不重复的数据组合，它的主要作用如下：

• 去重，把一个列表变成集合，就自动去重了
• 关系测试，测试两组数据之前的交集、差集、并集等关系

 

 

1.set.add() 添加元素

help(set.add)
Help on method_descriptor:

add(...)
    Add an element to a set.    
    This has no effect if the element is already present.
#往集合中添加一个元素。对集合中已经存在的元素没有影响。

s=set([1,2,3,4,5,6])

s.add(7)
s
Out[177]: {1, 2, 3, 4, 5, 6, 7}

s.add(7)  #集合自带去重，所以不重复添加，也不报错
s
Out[179]: {1, 2, 3, 4, 5, 6, 7}

2.set.clear() 清空所有元素

help(set.clear)
Help on method_descriptor:

clear(...)
    Remove all elements from this set.


s.clear()
s
Out[182]: set()

3.set.copy()  浅拷贝

help(set.copy)
Help on method_descriptor:

copy(...)
    Return a shallow copy of a set.

s=set([1,2,3,4,5,6])
s1=s.copy()
s1
Out[186]: {1, 2, 3, 4, 5, 6}

4.set.difference()     s.difference(t)返回s中有的，t中没有的新集合 s-t

help(set.difference)
Help on method_descriptor:

difference(...)
    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.)
#s.difference(t)  返回一个新的集合， s中有但是t中没有的元素.

s={1,2,3,4,5,6,7,8,9}
s.difference({2,4,6,10})
Out[3]: {1, 3, 5, 7, 8, 9}   #返回的新集合是s的子集，且是t中没有的元素。

5.set.difference_update()       s.difference_update(t)返回s中有的，t中没有的集合，直接更改s的结果。

help(set.difference_update)
Help on method_descriptor:

difference_update(...)
    Remove all elements of another set from this set.
#从这个集合中移除另一个集合中的所有元素。
'''difference_update  与difference的功能相同，都是寻找不同的元素，差别是difference_update直接更新原有set'''

s={1,2,3,4,5,6,7,8,9}
s.difference_update({2,4,6,10})   #直接作用于集合s
s
Out[21]: {1, 3, 5, 7, 8, 9}

6.set.discard()   set.remove()的功能一样，删除集合中的元素，如集合中无该元素，不报错。

help(set.discard)
Help on method_descriptor:

discard(...)
    Remove an element from a set if it is a member.
    If the element is not a member, do nothing.
'''给定的参数是集合中的元素，在集合中删除该元素。如果没有该元素，不报错。
丢弃操作：remove()的友好版本，如果s中存在ojb，从s中删除它.'''

s
Out[23]: {1, 3, 5, 7, 8, 9}  
s.discard(1)   #删除集合中有的元素
s
Out[25]: {3, 5, 7, 8, 9}
s.discard(2)   #集合中没有元素不报错
s
Out[27]: {3, 5, 7, 8, 9}

7.set.intersection()  将两个集合的交集作为新集合输出   s & t

help(set.intersection)
Help on method_descriptor:

intersection(...)
    Return the intersection of two sets as a new set.
     (i.e. all elements that are in both sets.)
#返回两个集合的交集，作为新的集合输出。

{1,2,3,4,5,6}.intersection({1,7,8,9})
Out[34]: {1}

 

8.set.intersection_update()  获取交集，在原来的set上进行覆盖更新，而不是输出到新的set。

help(set.intersection_update)
Help on method_descriptor:

intersection_update(...)
    Update a set with the intersection of itself and another.
#将两个集合的交集更新覆盖到集合set,不创建新集合。

s
Out[37]: {3, 5, 7, 8}
s.intersection_update({3,4,9})  #将两个集合的交集直接在原集合s上进行覆盖更新。交集的结果输出到原集合。
s
Out[39]: {3}

9.set.isdisjoint()  判断两个集合是否相交，两个有交集，则返回False；两个没有交集，则返回True。

help(set.isdisjoint)
Help on method_descriptor:

isdisjoint(...)
    Return True if two sets have a null intersection.
#如果两个集合没有相交，则返回True；如果两个集合有相交，则返回False。

{1,2,3,4,5,6}.isdisjoint({9,8,7})
Out[45]: True  #没有相交

{1,2,3,4,5,6}.isdisjoint({1,2,9,8,7})
Out[46]: False  #两个集合相交

10.set.issubset()   s.issubset(t)判断s是否是t的子集  s<=t

help(set.issubset)
Help on method_descriptor:

issubset(...)
    Report whether another set contains this set.
#判断s是否是t的子集

{1,2,3}.issubset({1,2,3,4,5})
Out[48]: True

{1,2,4}.issubset({1,2})
Out[49]: False

11.set.issuperset()  s.issuperset(t)判断s是否包含t  s>=t

help(set.issuperset)
Help on method_descriptor:

issuperset(...)
    Report whether this set contains another set.
#返回判断s是否包含t。

{1,2,4}.issuperset({1})
Out[51]: True

{1,2,4}.issuperset({1,2,3,4})
Out[52]: False

12.set.pop()  随机删除集合中的一个元素，如果是空集合，则会报错。

help(set.pop)
Help on method_descriptor:

pop(...)
    Remove and return an arbitrary set element.
    Raises KeyError if the set is empty.
#随机删除集合内的一个元素，并返回该删除的元素；
#如果集合中为空值，则会报错。

s=set('hello')
s
Out[55]: {'e', 'h', 'l', 'o'}
s.pop()  #随机删除集合内的一个元素，并返回该删除的元素
Out[57]: 'e'
s
Out[58]: {'h', 'l', 'o'}

13.set.remove()  删除集合中存在的指定的该元素，若集合中没有该元素，报错。

Help on method_descriptor:

remove(...)
    Remove an element from a set; it must be a member.    
    If the element is not a member, raise a KeyError.
#从集合中删除指定的元素。如集合中没有该元素，则会报错。

s
Out[29]: {3, 5, 7, 8, 9}

s.remove(1)
Traceback (most recent call last):
  File "<ipython-input-30-47aee57f52ad>", line 1, in <module>
    s.remove(1)
KeyError: 1


s.remove(9)
s
Out[32]: {3, 5, 7, 8}

14.set.symmetric_difference()  对称差分操作：s中包括仅属于s或仅属于t的成员，输出新集合  s^t

help(set.symmetric_difference)
Help on method_descriptor:

symmetric_difference(...)
    Return the symmetric difference of two sets as a new set.
    (i.e. all elements that are in exactly one of the sets.)
#返回两个集合的对称差分，作为新集合输出。
#所有的元素仅仅在两个元素中有且仅有一个，删除交集。

{1,2,3}.symmetric_difference({1,4,5,6})
Out[66]: {2, 3, 4, 5, 6}  #删除交集{1}

 

15.set.symmetric_difference_update()  对称差分修改操作：s中包括仅属于s或仅属于t的成员，在原集合上修改

help(set.symmetric_difference_update)
Help on method_descriptor:

symmetric_difference_update(...)
    Update a set with the symmetric difference of itself and another.
#在原集合s上更新两个集合中去掉交集的元素。

s
Out[68]: {1, 2, 3, 'o', 'l', 'h'}
s.symmetric_difference_update({1,9,87})
s
Out[70]: {2, 3, 'o', 'l', 9, 87, 'h'}

16.set.union() 将两个集合的并集作为新集合输出   s | t

help(set.union)
Help on method_descriptor:

union(...)
    Return the union of sets as a new set.
    (i.e. all elements that are in either set.)
#返回两个集合的并集作为元素的新集合

{1,2,3}.union({2,4})
Out[60]: {1, 2, 3, 4}

17.set.update()  将两个集合的并集结果直接在原来的集合中更新

help(set.update)
Help on method_descriptor:

update(...)
    Update a set with the union of itself and others.
#将两个集合的并集在原来的集合中直接更新。

s
Out[62]: {'h', 'l', 'o'}
s.update({1,2,3,'o'})
s
Out[64]: {1, 2, 3, 'o', 'l', 'h'}

 

 集合的方法：

len(s)  #集合计数，返回集合s中的元素个数

set([obj])  #可变集合工厂函数：obj必须是支持迭代的，如列表，字典等，由obj中的元素创建集合，否则创建一个空集合

set([1,2,3])
Out[72]: {1, 2, 3}

set((1,2,3))
Out[73]: {1, 2, 3}

set({1:2,3:4})
Out[74]: {1, 3}

frozenset([obj])  #不可变集合工厂函数：执行方式和set()方法相同，但它返回的是不可变集合

frozenset([1,2,3])
Out[75]: frozenset({1, 2, 3})

s=frozenset([1,2,3])

s.update({4,5})
Traceback (most recent call last):

  File "<ipython-input-77-7d750493f9ab>", line 1, in <module>
    s.update({4,5})

AttributeError: 'frozenset' object has no attribute 'update'

Methods defined here:
1.copy()
2.differece()
3.intersection()
4.isdisjoint()
5.issubset()
6.issuperset()
7.symmetric_difference()
8.union

obj in s 成员测试

{1} in {1,2,3}
Out[79]: False

1 in {1,2,3}  #元素的成员测试
Out[80]: True

obj not in s 非成员测试

{1}  not in {1,2,3}
Out[81]: True

1 not in {1,2,3}
Out[82]: False

s==t 等价测试

  {1,2,3}=={3,2,1} 2 Out[86]: True 

s!=t 不等价测试

  {1,2,3}!={3,2,1} 2 Out[87]: False 

s <t （严格意义上）子集测试

  1 {1,2,3}<{1,2,3,4} 2 Out[88]: True 

s <=t 子集测试  #等价 s.issubset(t)

  1 {1,2,3}<={1,2,3,4} 2 Out[88]: True 

s>t （严格意义上）超集测试

  {1,2,3}>{1,2} 2 Out[90]: True 

s >=t 超集测试  #等价 s.issuperset(t)

 {1,2,3}>={1,2,3} 2 Out[92]: True